]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wx.Rect.Inflate/Defalte docs
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1364 #define SWIGTYPE_p_wxIcon swig_types[23]
1365 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1366 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1369 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxSound swig_types[37]
1379 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1380 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1381 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1382 #define SWIGTYPE_p_wxArrayString swig_types[41]
1383 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxToolTip swig_types[44]
1386 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1387 #define SWIGTYPE_p_wxFileConfig swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1390 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1393 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1394 #define SWIGTYPE_p_wxRect swig_types[53]
1395 #define SWIGTYPE_p_char swig_types[54]
1396 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1397 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1398 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1399 #define SWIGTYPE_p_wxFrame swig_types[58]
1400 #define SWIGTYPE_p_wxTimer swig_types[59]
1401 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1402 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1403 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1404 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxJoystick swig_types[65]
1407 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1408 #define SWIGTYPE_p_wxPoint swig_types[67]
1409 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1410 #define SWIGTYPE_p_wxCursor swig_types[69]
1411 #define SWIGTYPE_p_wxObject swig_types[70]
1412 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1413 #define SWIGTYPE_p_wxDateTime swig_types[72]
1414 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1415 #define SWIGTYPE_p_unsigned_long swig_types[74]
1416 #define SWIGTYPE_p_wxKillError swig_types[75]
1417 #define SWIGTYPE_p_wxWindow swig_types[76]
1418 #define SWIGTYPE_p_wxString swig_types[77]
1419 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1420 #define SWIGTYPE_p_wxBitmap swig_types[79]
1421 #define SWIGTYPE_p_wxConfig swig_types[80]
1422 #define SWIGTYPE_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_char swig_types[83]
1425 #define SWIGTYPE_p_wxChar swig_types[84]
1426 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1427 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPyLog swig_types[90]
1432 #define SWIGTYPE_p_wxLogNull swig_types[91]
1433 #define SWIGTYPE_p_wxColour swig_types[92]
1434 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1435 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1436 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443 @(target):= _misc_.so
1444 ------------------------------------------------*/
1445 #define SWIG_init init_misc_
1446
1447 #define SWIG_name "_misc_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451 #include "wx/wxPython/pyistream.h"
1452
1453 static const wxString wxPyEmptyString(wxEmptyString);
1454
1455
1456
1457 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1458 #define SWIG_From_int PyInt_FromLong
1459 /*@@*/
1460
1461
1462 #include <limits.h>
1463
1464
1465 SWIGINTERN int
1466 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1467 const char *errmsg)
1468 {
1469 if (value < min_value) {
1470 if (errmsg) {
1471 PyErr_Format(PyExc_OverflowError,
1472 "value %ld is less than '%s' minimum %ld",
1473 value, errmsg, min_value);
1474 }
1475 return 0;
1476 } else if (value > max_value) {
1477 if (errmsg) {
1478 PyErr_Format(PyExc_OverflowError,
1479 "value %ld is greater than '%s' maximum %ld",
1480 value, errmsg, max_value);
1481 }
1482 return 0;
1483 }
1484 return 1;
1485 }
1486
1487
1488 SWIGINTERN int
1489 SWIG_AsVal_long(PyObject* obj, long* val)
1490 {
1491 if (PyNumber_Check(obj)) {
1492 if (val) *val = PyInt_AsLong(obj);
1493 return 1;
1494 }
1495 else {
1496 SWIG_type_error("number", obj);
1497 }
1498 return 0;
1499 }
1500
1501
1502 #if INT_MAX != LONG_MAX
1503 SWIGINTERN int
1504 SWIG_AsVal_int(PyObject *obj, int *val)
1505 {
1506 const char* errmsg = val ? "int" : (char*)0;
1507 long v;
1508 if (SWIG_AsVal_long(obj, &v)) {
1509 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1510 if (val) *val = (int)(v);
1511 return 1;
1512 } else {
1513 return 0;
1514 }
1515 } else {
1516 PyErr_Clear();
1517 }
1518 if (val) {
1519 SWIG_type_error(errmsg, obj);
1520 }
1521 return 0;
1522 }
1523 #else
1524 SWIGINTERNSHORT int
1525 SWIG_AsVal_int(PyObject *obj, int *val)
1526 {
1527 return SWIG_AsVal_long(obj,(long*)val);
1528 }
1529 #endif
1530
1531
1532 SWIGINTERNSHORT int
1533 SWIG_As_int(PyObject* obj)
1534 {
1535 int v;
1536 if (!SWIG_AsVal_int(obj, &v)) {
1537 /*
1538 this is needed to make valgrind/purify happier.
1539 */
1540 memset((void*)&v, 0, sizeof(int));
1541 }
1542 return v;
1543 }
1544
1545
1546 SWIGINTERNSHORT int
1547 SWIG_Check_int(PyObject* obj)
1548 {
1549 return SWIG_AsVal_int(obj, (int*)0);
1550 }
1551
1552 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1553
1554 #include <wx/stockitem.h>
1555
1556 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1557 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1558 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1559
1560 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1561 #define SWIG_From_long PyInt_FromLong
1562 /*@@*/
1563
1564
1565 SWIGINTERNSHORT long
1566 SWIG_As_long(PyObject* obj)
1567 {
1568 long v;
1569 if (!SWIG_AsVal_long(obj, &v)) {
1570 /*
1571 this is needed to make valgrind/purify happier.
1572 */
1573 memset((void*)&v, 0, sizeof(long));
1574 }
1575 return v;
1576 }
1577
1578
1579 SWIGINTERNSHORT int
1580 SWIG_Check_long(PyObject* obj)
1581 {
1582 return SWIG_AsVal_long(obj, (long*)0);
1583 }
1584
1585
1586 SWIGINTERN int
1587 SWIG_AsVal_bool(PyObject *obj, bool *val)
1588 {
1589 if (obj == Py_True) {
1590 if (val) *val = true;
1591 return 1;
1592 }
1593 if (obj == Py_False) {
1594 if (val) *val = false;
1595 return 1;
1596 }
1597 int res = 0;
1598 if (SWIG_AsVal_int(obj, &res)) {
1599 if (val) *val = res ? true : false;
1600 return 1;
1601 } else {
1602 PyErr_Clear();
1603 }
1604 if (val) {
1605 SWIG_type_error("bool", obj);
1606 }
1607 return 0;
1608 }
1609
1610
1611 SWIGINTERNSHORT bool
1612 SWIG_As_bool(PyObject* obj)
1613 {
1614 bool v;
1615 if (!SWIG_AsVal_bool(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(bool));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_bool(PyObject* obj)
1627 {
1628 return SWIG_AsVal_bool(obj, (bool*)0);
1629 }
1630
1631
1632 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1633 PyObject* o2;
1634 PyObject* o3;
1635
1636 if (!target) {
1637 target = o;
1638 } else if (target == Py_None) {
1639 Py_DECREF(Py_None);
1640 target = o;
1641 } else {
1642 if (!PyTuple_Check(target)) {
1643 o2 = target;
1644 target = PyTuple_New(1);
1645 PyTuple_SetItem(target, 0, o2);
1646 }
1647 o3 = PyTuple_New(1);
1648 PyTuple_SetItem(o3, 0, o);
1649
1650 o2 = target;
1651 target = PySequence_Concat(o2, o3);
1652 Py_DECREF(o2);
1653 Py_DECREF(o3);
1654 }
1655 return target;
1656 }
1657
1658
1659
1660 SWIGINTERN int
1661 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1662 {
1663 long v = 0;
1664 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1665 SWIG_type_error("unsigned number", obj);
1666 }
1667 else if (val)
1668 *val = (unsigned long)v;
1669 return 1;
1670 }
1671
1672
1673 SWIGINTERNSHORT unsigned long
1674 SWIG_As_unsigned_SS_long(PyObject* obj)
1675 {
1676 unsigned long v;
1677 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1678 /*
1679 this is needed to make valgrind/purify happier.
1680 */
1681 memset((void*)&v, 0, sizeof(unsigned long));
1682 }
1683 return v;
1684 }
1685
1686
1687 SWIGINTERNSHORT int
1688 SWIG_Check_unsigned_SS_long(PyObject* obj)
1689 {
1690 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1691 }
1692
1693
1694 SWIGINTERNSHORT PyObject*
1695 SWIG_From_unsigned_SS_long(unsigned long value)
1696 {
1697 return (value > LONG_MAX) ?
1698 PyLong_FromUnsignedLong(value)
1699 : PyInt_FromLong((long)(value));
1700 }
1701
1702
1703 bool wxThread_IsMain() {
1704 #ifdef WXP_WITH_THREAD
1705 return wxThread::IsMain();
1706 #else
1707 return true;
1708 #endif
1709 }
1710
1711
1712 int wxCaret_GetBlinkTime() {
1713 return wxCaret::GetBlinkTime();
1714 }
1715
1716 void wxCaret_SetBlinkTime(int milliseconds) {
1717 wxCaret::SetBlinkTime(milliseconds);
1718 }
1719
1720
1721 #include <wx/snglinst.h>
1722
1723
1724 #include <wx/tipdlg.h>
1725
1726
1727 class wxPyTipProvider : public wxTipProvider {
1728 public:
1729 wxPyTipProvider(size_t currentTip)
1730 : wxTipProvider(currentTip) {}
1731
1732 DEC_PYCALLBACK_STRING__pure(GetTip);
1733 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1734 PYPRIVATE;
1735 };
1736
1737 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1738 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1739
1740
1741 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1742
1743 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1744
1745 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1746 : wxTimer(owner, id)
1747 {
1748 if (owner == NULL) SetOwner(this);
1749 }
1750
1751
1752 void wxPyTimer::Notify() {
1753 bool found;
1754 bool blocked = wxPyBeginBlockThreads();
1755 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1756 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1757 wxPyEndBlockThreads(blocked);
1758 if (! found)
1759 wxTimer::Notify();
1760 }
1761 void wxPyTimer::base_Notify() {
1762 wxTimer::Notify();
1763 }
1764
1765
1766
1767 SWIGINTERN PyObject *
1768 SWIG_FromCharPtr(const char* cptr)
1769 {
1770 if (cptr) {
1771 size_t size = strlen(cptr);
1772 if (size > INT_MAX) {
1773 return SWIG_NewPointerObj((char*)(cptr),
1774 SWIG_TypeQuery("char *"), 0);
1775 } else {
1776 if (size != 0) {
1777 return PyString_FromStringAndSize(cptr, size);
1778 } else {
1779 return PyString_FromString(cptr);
1780 }
1781 }
1782 }
1783 Py_INCREF(Py_None);
1784 return Py_None;
1785 }
1786
1787
1788 SWIGINTERNSHORT int
1789 SWIG_CheckUnsignedLongInRange(unsigned long value,
1790 unsigned long max_value,
1791 const char *errmsg)
1792 {
1793 if (value > max_value) {
1794 if (errmsg) {
1795 PyErr_Format(PyExc_OverflowError,
1796 "value %lu is greater than '%s' minimum %lu",
1797 value, errmsg, max_value);
1798 }
1799 return 0;
1800 }
1801 return 1;
1802 }
1803
1804
1805 #if UINT_MAX != ULONG_MAX
1806 SWIGINTERN int
1807 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1808 {
1809 const char* errmsg = val ? "unsigned int" : (char*)0;
1810 unsigned long v;
1811 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1812 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1813 if (val) *val = (unsigned int)(v);
1814 return 1;
1815 }
1816 } else {
1817 PyErr_Clear();
1818 }
1819 if (val) {
1820 SWIG_type_error(errmsg, obj);
1821 }
1822 return 0;
1823 }
1824 #else
1825 SWIGINTERNSHORT unsigned int
1826 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1827 {
1828 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1829 }
1830 #endif
1831
1832
1833 SWIGINTERNSHORT unsigned int
1834 SWIG_As_unsigned_SS_int(PyObject* obj)
1835 {
1836 unsigned int v;
1837 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1838 /*
1839 this is needed to make valgrind/purify happier.
1840 */
1841 memset((void*)&v, 0, sizeof(unsigned int));
1842 }
1843 return v;
1844 }
1845
1846
1847 SWIGINTERNSHORT int
1848 SWIG_Check_unsigned_SS_int(PyObject* obj)
1849 {
1850 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1851 }
1852
1853 static wxString Log_TimeStamp(){
1854 wxString msg;
1855 wxLog::TimeStamp(&msg);
1856 return msg;
1857 }
1858 static void wxLog_Destroy(wxLog *self){ delete self; }
1859 // Make somce wrappers that double any % signs so they are 'escaped'
1860 void wxPyLogFatalError(const wxString& msg)
1861 {
1862 wxString m(msg);
1863 m.Replace(wxT("%"), wxT("%%"));
1864 wxLogFatalError(m);
1865 }
1866
1867 void wxPyLogError(const wxString& msg)
1868 {
1869 wxString m(msg);
1870 m.Replace(wxT("%"), wxT("%%"));
1871 wxLogError(m);
1872 }
1873
1874 void wxPyLogWarning(const wxString& msg)
1875 {
1876 wxString m(msg);
1877 m.Replace(wxT("%"), wxT("%%"));
1878 wxLogWarning(m);
1879 }
1880
1881 void wxPyLogMessage(const wxString& msg)
1882 {
1883 wxString m(msg);
1884 m.Replace(wxT("%"), wxT("%%"));
1885 wxLogMessage(m);
1886 }
1887
1888 void wxPyLogInfo(const wxString& msg)
1889 {
1890 wxString m(msg);
1891 m.Replace(wxT("%"), wxT("%%"));
1892 wxLogInfo(m);
1893 }
1894
1895 void wxPyLogDebug(const wxString& msg)
1896 {
1897 wxString m(msg);
1898 m.Replace(wxT("%"), wxT("%%"));
1899 wxLogDebug(m);
1900 }
1901
1902 void wxPyLogVerbose(const wxString& msg)
1903 {
1904 wxString m(msg);
1905 m.Replace(wxT("%"), wxT("%%"));
1906 wxLogVerbose(m);
1907 }
1908
1909 void wxPyLogStatus(const wxString& msg)
1910 {
1911 wxString m(msg);
1912 m.Replace(wxT("%"), wxT("%%"));
1913 wxLogStatus(m);
1914 }
1915
1916 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1917 {
1918 wxString m(msg);
1919 m.Replace(wxT("%"), wxT("%%"));
1920 wxLogStatus(pFrame, m);
1921 }
1922
1923 void wxPyLogSysError(const wxString& msg)
1924 {
1925 wxString m(msg);
1926 m.Replace(wxT("%"), wxT("%%"));
1927 wxLogSysError(m);
1928 }
1929
1930 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1931 {
1932 wxString m(msg);
1933 m.Replace(wxT("%"), wxT("%%"));
1934 wxLogGeneric(level, m);
1935 }
1936
1937 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1938 {
1939 wxString m(msg);
1940 m.Replace(wxT("%"), wxT("%%"));
1941 wxLogTrace(mask, m);
1942 }
1943
1944 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1945 {
1946 wxString m(msg);
1947 m.Replace(wxT("%"), wxT("%%"));
1948 wxLogTrace(mask, m);
1949 }
1950
1951
1952
1953 // A wxLog class that can be derived from in wxPython
1954 class wxPyLog : public wxLog {
1955 public:
1956 wxPyLog() : wxLog() {}
1957
1958 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1959 bool found;
1960 bool blocked = wxPyBeginBlockThreads();
1961 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1962 PyObject* s = wx2PyString(szString);
1963 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1964 Py_DECREF(s);
1965 }
1966 wxPyEndBlockThreads(blocked);
1967 if (! found)
1968 wxLog::DoLog(level, szString, t);
1969 }
1970
1971 virtual void DoLogString(const wxChar *szString, time_t t) {
1972 bool found;
1973 bool blocked = wxPyBeginBlockThreads();
1974 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1975 PyObject* s = wx2PyString(szString);
1976 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1977 Py_DECREF(s);
1978 }
1979 wxPyEndBlockThreads(blocked);
1980 if (! found)
1981 wxLog::DoLogString(szString, t);
1982 }
1983
1984 PYPRIVATE;
1985 };
1986
1987
1988
1989
1990 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1991
1992
1993 #include <wx/joystick.h>
1994
1995
1996 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
1997 // A C++ stub class for wxJoystick for platforms that don't have it.
1998 class wxJoystick : public wxObject {
1999 public:
2000 wxJoystick(int joystick = wxJOYSTICK1) {
2001 bool blocked = wxPyBeginBlockThreads();
2002 PyErr_SetString(PyExc_NotImplementedError,
2003 "wxJoystick is not available on this platform.");
2004 wxPyEndBlockThreads(blocked);
2005 }
2006 wxPoint GetPosition() { return wxPoint(-1,-1); }
2007 int GetZPosition() { return -1; }
2008 int GetButtonState() { return -1; }
2009 int GetPOVPosition() { return -1; }
2010 int GetPOVCTSPosition() { return -1; }
2011 int GetRudderPosition() { return -1; }
2012 int GetUPosition() { return -1; }
2013 int GetVPosition() { return -1; }
2014 int GetMovementThreshold() { return -1; }
2015 void SetMovementThreshold(int threshold) {}
2016
2017 bool IsOk(void) { return false; }
2018 int GetNumberJoysticks() { return -1; }
2019 int GetManufacturerId() { return -1; }
2020 int GetProductId() { return -1; }
2021 wxString GetProductName() { return wxEmptyString; }
2022 int GetXMin() { return -1; }
2023 int GetYMin() { return -1; }
2024 int GetZMin() { return -1; }
2025 int GetXMax() { return -1; }
2026 int GetYMax() { return -1; }
2027 int GetZMax() { return -1; }
2028 int GetNumberButtons() { return -1; }
2029 int GetNumberAxes() { return -1; }
2030 int GetMaxButtons() { return -1; }
2031 int GetMaxAxes() { return -1; }
2032 int GetPollingMin() { return -1; }
2033 int GetPollingMax() { return -1; }
2034 int GetRudderMin() { return -1; }
2035 int GetRudderMax() { return -1; }
2036 int GetUMin() { return -1; }
2037 int GetUMax() { return -1; }
2038 int GetVMin() { return -1; }
2039 int GetVMax() { return -1; }
2040
2041 bool HasRudder() { return false; }
2042 bool HasZ() { return false; }
2043 bool HasU() { return false; }
2044 bool HasV() { return false; }
2045 bool HasPOV() { return false; }
2046 bool HasPOV4Dir() { return false; }
2047 bool HasPOVCTS() { return false; }
2048
2049 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2050 bool ReleaseCapture() { return false; }
2051 };
2052 #endif
2053
2054
2055 #include <wx/sound.h>
2056
2057
2058 #if !wxUSE_SOUND
2059 // A C++ stub class for wxWave for platforms that don't have it.
2060 class wxSound : public wxObject
2061 {
2062 public:
2063 wxSound() {
2064 bool blocked = wxPyBeginBlockThreads();
2065 PyErr_SetString(PyExc_NotImplementedError,
2066 "wxSound is not available on this platform.");
2067 wxPyEndBlockThreads(blocked);
2068 }
2069 wxSound(const wxString&/*, bool*/) {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075 wxSound(int, const wxByte*) {
2076 bool blocked = wxPyBeginBlockThreads();
2077 PyErr_SetString(PyExc_NotImplementedError,
2078 "wxSound is not available on this platform.");
2079 wxPyEndBlockThreads(blocked);
2080 }
2081
2082 ~wxSound() {};
2083
2084 bool Create(const wxString&/*, bool*/) { return false; }
2085 bool Create(int, const wxByte*) { return false; };
2086 bool IsOk() { return false; };
2087 bool Play(unsigned) const { return false; }
2088 static bool Play(const wxString&, unsigned) { return false; }
2089 static void Stop() {}
2090 };
2091
2092 #endif
2093
2094 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2095 if (fileName.Length() == 0)
2096 return new wxSound;
2097 else
2098 return new wxSound(fileName);
2099 }
2100 static wxSound *new_wxSound(PyObject *data){
2101 unsigned char* buffer; int size;
2102 wxSound *sound = NULL;
2103
2104 bool blocked = wxPyBeginBlockThreads();
2105 if (!PyArg_Parse(data, "t#", &buffer, &size))
2106 goto done;
2107 sound = new wxSound(size, buffer);
2108 done:
2109 wxPyEndBlockThreads(blocked);
2110 return sound;
2111 }
2112 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2113 #ifndef __WXMAC__
2114 unsigned char* buffer;
2115 int size;
2116 bool rv = false;
2117
2118 bool blocked = wxPyBeginBlockThreads();
2119 if (!PyArg_Parse(data, "t#", &buffer, &size))
2120 goto done;
2121 rv = self->Create(size, buffer);
2122 done:
2123 wxPyEndBlockThreads(blocked);
2124 return rv;
2125 #else
2126 bool blocked = wxPyBeginBlockThreads();
2127 PyErr_SetString(PyExc_NotImplementedError,
2128 "Create from data is not available on this platform.");
2129 wxPyEndBlockThreads(blocked);
2130 return false;
2131 #endif
2132 }
2133
2134 #include <wx/mimetype.h>
2135
2136 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2137 wxString str;
2138 if (self->GetMimeType(&str))
2139 return wx2PyString(str);
2140 else
2141 RETURN_NONE();
2142 }
2143 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2144 wxArrayString arr;
2145 if (self->GetMimeTypes(arr))
2146 return wxArrayString2PyList_helper(arr);
2147 else
2148 RETURN_NONE();
2149 }
2150 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2151 wxArrayString arr;
2152 if (self->GetExtensions(arr))
2153 return wxArrayString2PyList_helper(arr);
2154 else
2155 RETURN_NONE();
2156 }
2157 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2158 wxIconLocation loc;
2159 if (self->GetIcon(&loc))
2160 return new wxIcon(loc);
2161 else
2162 return NULL;
2163 }
2164 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2165 wxIconLocation loc;
2166 if (self->GetIcon(&loc)) {
2167 wxString iconFile = loc.GetFileName();
2168 int iconIndex = -1;
2169
2170
2171
2172 // Make a tuple and put the values in it
2173 bool blocked = wxPyBeginBlockThreads();
2174 PyObject* tuple = PyTuple_New(3);
2175 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2176 wxT("wxIcon"), true));
2177 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2178 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2179 wxPyEndBlockThreads(blocked);
2180 return tuple;
2181 }
2182 else
2183 RETURN_NONE();
2184 }
2185 static PyObject *wxFileType_GetDescription(wxFileType *self){
2186 wxString str;
2187 if (self->GetDescription(&str))
2188 return wx2PyString(str);
2189 else
2190 RETURN_NONE();
2191 }
2192 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2193 wxString str;
2194 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2195 return wx2PyString(str);
2196 else
2197 RETURN_NONE();
2198 }
2199 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2200 wxString str;
2201 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2202 return wx2PyString(str);
2203 else
2204 RETURN_NONE();
2205 }
2206 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2207 wxArrayString verbs;
2208 wxArrayString commands;
2209 if (self->GetAllCommands(&verbs, &commands,
2210 wxFileType::MessageParameters(filename, mimetype))) {
2211 bool blocked = wxPyBeginBlockThreads();
2212 PyObject* tuple = PyTuple_New(2);
2213 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2214 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2215 wxPyEndBlockThreads(blocked);
2216 return tuple;
2217 }
2218 else
2219 RETURN_NONE();
2220 }
2221 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2222 return wxFileType::ExpandCommand(command,
2223 wxFileType::MessageParameters(filename, mimetype));
2224 }
2225 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2226 wxArrayString arr;
2227 self->EnumAllFileTypes(arr);
2228 return wxArrayString2PyList_helper(arr);
2229 }
2230
2231 #include <wx/artprov.h>
2232
2233 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2234 static const wxString wxPyART_MENU(wxART_MENU);
2235 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2236 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2237 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2238 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2239 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2240 static const wxString wxPyART_OTHER(wxART_OTHER);
2241 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2242 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2243 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2244 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2245 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2246 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2247 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2248 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2249 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2250 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2251 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2252 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2253 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2254 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2255 static const wxString wxPyART_PRINT(wxART_PRINT);
2256 static const wxString wxPyART_HELP(wxART_HELP);
2257 static const wxString wxPyART_TIP(wxART_TIP);
2258 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2259 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2260 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2261 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2262 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2263 static const wxString wxPyART_CDROM(wxART_CDROM);
2264 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2265 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2266 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2267 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2268 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2269 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2270 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2271 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2272 static const wxString wxPyART_ERROR(wxART_ERROR);
2273 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2274 static const wxString wxPyART_WARNING(wxART_WARNING);
2275 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2276 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2277 // Python aware wxArtProvider
2278 class wxPyArtProvider : public wxArtProvider {
2279 public:
2280
2281 virtual wxBitmap CreateBitmap(const wxArtID& id,
2282 const wxArtClient& client,
2283 const wxSize& size) {
2284 wxBitmap rval = wxNullBitmap;
2285 bool blocked = wxPyBeginBlockThreads();
2286 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2287 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2288 PyObject* ro;
2289 wxBitmap* ptr;
2290 PyObject* s1, *s2;
2291 s1 = wx2PyString(id);
2292 s2 = wx2PyString(client);
2293 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2294 Py_DECREF(so);
2295 Py_DECREF(s1);
2296 Py_DECREF(s2);
2297 if (ro) {
2298 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2299 rval = *ptr;
2300 Py_DECREF(ro);
2301 }
2302 }
2303 wxPyEndBlockThreads(blocked);
2304 return rval;
2305 }
2306
2307 PYPRIVATE;
2308 };
2309
2310 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2311
2312
2313
2314 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2315 PyObject* ret = PyTuple_New(3);
2316 if (ret) {
2317 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2318 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2319 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2320 }
2321 return ret;
2322 }
2323
2324 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2325 bool cont;
2326 long index = 0;
2327 wxString value;
2328
2329 cont = self->GetFirstGroup(value, index);
2330 return __EnumerationHelper(cont, value, index);
2331 }
2332 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2333 bool cont;
2334 wxString value;
2335
2336 cont = self->GetNextGroup(value, index);
2337 return __EnumerationHelper(cont, value, index);
2338 }
2339 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2340 bool cont;
2341 long index = 0;
2342 wxString value;
2343
2344 cont = self->GetFirstEntry(value, index);
2345 return __EnumerationHelper(cont, value, index);
2346 }
2347 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2348 bool cont;
2349 wxString value;
2350
2351 cont = self->GetNextEntry(value, index);
2352 return __EnumerationHelper(cont, value, index);
2353 }
2354 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2355 long rv;
2356 self->Read(key, &rv, defaultVal);
2357 return rv;
2358 }
2359
2360 SWIGINTERN int
2361 SWIG_AsVal_double(PyObject *obj, double* val)
2362 {
2363 if (PyNumber_Check(obj)) {
2364 if (val) *val = PyFloat_AsDouble(obj);
2365 return 1;
2366 }
2367 else {
2368 SWIG_type_error("number", obj);
2369 }
2370 return 0;
2371 }
2372
2373
2374 SWIGINTERNSHORT double
2375 SWIG_As_double(PyObject* obj)
2376 {
2377 double v;
2378 if (!SWIG_AsVal_double(obj, &v)) {
2379 /*
2380 this is needed to make valgrind/purify happier.
2381 */
2382 memset((void*)&v, 0, sizeof(double));
2383 }
2384 return v;
2385 }
2386
2387
2388 SWIGINTERNSHORT int
2389 SWIG_Check_double(PyObject* obj)
2390 {
2391 return SWIG_AsVal_double(obj, (double*)0);
2392 }
2393
2394 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2395 double rv;
2396 self->Read(key, &rv, defaultVal);
2397 return rv;
2398 }
2399
2400 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2401 #define SWIG_From_double PyFloat_FromDouble
2402 /*@@*/
2403
2404 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2405 bool rv;
2406 self->Read(key, &rv, defaultVal);
2407 return rv;
2408 }
2409
2410 #include <wx/datetime.h>
2411
2412 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2413 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2414
2415 #define LOCAL_TZ wxDateTime::Local
2416
2417
2418 #if UINT_MAX < LONG_MAX
2419 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2420 #define SWIG_From_unsigned_SS_int SWIG_From_long
2421 /*@@*/
2422 #else
2423 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2424 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2425 /*@@*/
2426 #endif
2427
2428 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2429 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2430 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2431 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2432 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2433 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2434 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2435 return (*self < *other);
2436 }
2437 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2438 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2439 return (*self <= *other);
2440 }
2441 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2442 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2443 return (*self > *other);
2444 }
2445 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2446 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2447 return (*self >= *other);
2448 }
2449 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2450 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2451 return (*self == *other);
2452 }
2453 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2454 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2455 return (*self != *other);
2456 }
2457 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2458 const wxChar* rv;
2459 const wxChar* _date = date;
2460 rv = self->ParseRfc822Date(_date);
2461 if (rv == NULL) return -1;
2462 return rv - _date;
2463 }
2464 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2465 const wxChar* rv;
2466 const wxChar* _date = date;
2467 rv = self->ParseFormat(_date, format, dateDef);
2468 if (rv == NULL) return -1;
2469 return rv - _date;
2470 }
2471 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2472 const wxChar* rv;
2473 const wxChar* _datetime = datetime;
2474 rv = self->ParseDateTime(_datetime);
2475 if (rv == NULL) return -1;
2476 return rv - _datetime;
2477 }
2478 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2479 const wxChar* rv;
2480 const wxChar* _date = date;
2481 rv = self->ParseDate(_date);
2482 if (rv == NULL) return -1;
2483 return rv - _date;
2484 }
2485 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2486 const wxChar* rv;
2487 const wxChar* _time = time;
2488 rv = self->ParseTime(_time);
2489 if (rv == NULL) return -1;
2490 return rv - _time;
2491 }
2492 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2493 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2494 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2495 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2496 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2497 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2498 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2499 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2500 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2501 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2502 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2503 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2504 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2505 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2506 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2507 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2508
2509 #include <wx/dataobj.h>
2510
2511 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2512 size_t count = self->GetFormatCount(dir);
2513 wxDataFormat* formats = new wxDataFormat[count];
2514 self->GetAllFormats(formats, dir);
2515
2516 bool blocked = wxPyBeginBlockThreads();
2517 PyObject* list = PyList_New(count);
2518 for (size_t i=0; i<count; i++) {
2519 wxDataFormat* format = new wxDataFormat(formats[i]);
2520 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2521 PyList_Append(list, obj);
2522 Py_DECREF(obj);
2523 }
2524 wxPyEndBlockThreads(blocked);
2525 delete [] formats;
2526 return list;
2527 }
2528 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2529 PyObject* rval = NULL;
2530 size_t size = self->GetDataSize(format);
2531 bool blocked = wxPyBeginBlockThreads();
2532 if (size) {
2533 char* buf = new char[size];
2534 if (self->GetDataHere(format, buf))
2535 rval = PyString_FromStringAndSize(buf, size);
2536 delete [] buf;
2537 }
2538 if (! rval) {
2539 rval = Py_None;
2540 Py_INCREF(rval);
2541 }
2542 wxPyEndBlockThreads(blocked);
2543 return rval;
2544 }
2545 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2546 bool rval;
2547 bool blocked = wxPyBeginBlockThreads();
2548 if (PyString_Check(data)) {
2549 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2550 }
2551 else {
2552 // raise a TypeError if not a string
2553 PyErr_SetString(PyExc_TypeError, "String expected.");
2554 rval = false;
2555 }
2556 wxPyEndBlockThreads(blocked);
2557 return rval;
2558 }
2559 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2560 PyObject* rval = NULL;
2561 size_t size = self->GetDataSize();
2562 bool blocked = wxPyBeginBlockThreads();
2563 if (size) {
2564 char* buf = new char[size];
2565 if (self->GetDataHere(buf))
2566 rval = PyString_FromStringAndSize(buf, size);
2567 delete [] buf;
2568 }
2569 if (! rval) {
2570 rval = Py_None;
2571 Py_INCREF(rval);
2572 }
2573 wxPyEndBlockThreads(blocked);
2574 return rval;
2575 }
2576 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2577 bool rval;
2578 bool blocked = wxPyBeginBlockThreads();
2579 if (PyString_Check(data)) {
2580 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2581 }
2582 else {
2583 // raise a TypeError if not a string
2584 PyErr_SetString(PyExc_TypeError, "String expected.");
2585 rval = false;
2586 }
2587 wxPyEndBlockThreads(blocked);
2588 return rval;
2589 }
2590 // Create a new class for wxPython to use
2591 class wxPyDataObjectSimple : public wxDataObjectSimple {
2592 public:
2593 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2594 : wxDataObjectSimple(format) {}
2595
2596 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2597 bool GetDataHere(void *buf) const;
2598 bool SetData(size_t len, const void *buf) const;
2599 PYPRIVATE;
2600 };
2601
2602 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2603
2604 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2605 // We need to get the data for this object and write it to buf. I think
2606 // the best way to do this for wxPython is to have the Python method
2607 // return either a string or None and then act appropriately with the
2608 // C++ version.
2609
2610 bool rval = false;
2611 bool blocked = wxPyBeginBlockThreads();
2612 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2613 PyObject* ro;
2614 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2615 if (ro) {
2616 rval = (ro != Py_None && PyString_Check(ro));
2617 if (rval)
2618 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2619 Py_DECREF(ro);
2620 }
2621 }
2622 wxPyEndBlockThreads(blocked);
2623 return rval;
2624 }
2625
2626 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2627 // For this one we simply need to make a string from buf and len
2628 // and send it to the Python method.
2629 bool rval = false;
2630 bool blocked = wxPyBeginBlockThreads();
2631 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2632 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2633 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2634 Py_DECREF(data);
2635 }
2636 wxPyEndBlockThreads(blocked);
2637 return rval;
2638 }
2639
2640 // Create a new class for wxPython to use
2641 class wxPyTextDataObject : public wxTextDataObject {
2642 public:
2643 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2644 : wxTextDataObject(text) {}
2645
2646 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2647 DEC_PYCALLBACK_STRING__const(GetText);
2648 DEC_PYCALLBACK__STRING(SetText);
2649 PYPRIVATE;
2650 };
2651
2652 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2653 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2654 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2655
2656
2657 // Create a new class for wxPython to use
2658 class wxPyBitmapDataObject : public wxBitmapDataObject {
2659 public:
2660 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2661 : wxBitmapDataObject(bitmap) {}
2662
2663 wxBitmap GetBitmap() const;
2664 void SetBitmap(const wxBitmap& bitmap);
2665 PYPRIVATE;
2666 };
2667
2668 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2669 wxBitmap* rval = &wxNullBitmap;
2670 bool blocked = wxPyBeginBlockThreads();
2671 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2672 PyObject* ro;
2673 wxBitmap* ptr;
2674 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2675 if (ro) {
2676 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2677 rval = ptr;
2678 Py_DECREF(ro);
2679 }
2680 }
2681 wxPyEndBlockThreads(blocked);
2682 return *rval;
2683 }
2684
2685 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2686 bool blocked = wxPyBeginBlockThreads();
2687 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2688 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2689 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2690 Py_DECREF(bo);
2691 }
2692 wxPyEndBlockThreads(blocked);
2693 }
2694
2695 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2696 return new wxCustomDataObject(wxDataFormat(formatName));
2697 }
2698 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2699 bool rval;
2700 bool blocked = wxPyBeginBlockThreads();
2701 if (PyString_Check(data)) {
2702 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2703 }
2704 else {
2705 // raise a TypeError if not a string
2706 PyErr_SetString(PyExc_TypeError, "String expected.");
2707 rval = false;
2708 }
2709 wxPyEndBlockThreads(blocked);
2710 return rval;
2711 }
2712 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2713 PyObject* obj;
2714 bool blocked = wxPyBeginBlockThreads();
2715 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2716 wxPyEndBlockThreads(blocked);
2717 return obj;
2718 }
2719
2720 #include <wx/metafile.h>
2721
2722
2723 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2724
2725
2726 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2727 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2728 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2729 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2730 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2731
2732
2733 class wxPyTextDropTarget : public wxTextDropTarget {
2734 public:
2735 wxPyTextDropTarget() {}
2736
2737 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2738
2739 DEC_PYCALLBACK__(OnLeave);
2740 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2741 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2742 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2743 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2744
2745 PYPRIVATE;
2746 };
2747
2748 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2749 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2750 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2751 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2752 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2753 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2754
2755
2756
2757 class wxPyFileDropTarget : public wxFileDropTarget {
2758 public:
2759 wxPyFileDropTarget() {}
2760
2761 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2762
2763 DEC_PYCALLBACK__(OnLeave);
2764 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2765 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2766 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2767 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2768
2769 PYPRIVATE;
2770 };
2771
2772 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2773 const wxArrayString& filenames) {
2774 bool rval = false;
2775 bool blocked = wxPyBeginBlockThreads();
2776 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2777 PyObject* list = wxArrayString2PyList_helper(filenames);
2778 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2779 Py_DECREF(list);
2780 }
2781 wxPyEndBlockThreads(blocked);
2782 return rval;
2783 }
2784
2785
2786
2787 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2788 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2789 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2790 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2791 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2792
2793
2794
2795
2796 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2797
2798 #include <wx/display.h>
2799
2800 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2801 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2802
2803 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2804 #if !wxUSE_DISPLAY
2805 #include <wx/dynarray.h>
2806 #include <wx/vidmode.h>
2807
2808 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2809 #include "wx/arrimpl.cpp"
2810 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2811 const wxVideoMode wxDefaultVideoMode;
2812
2813 class wxDisplay
2814 {
2815 public:
2816 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2817 ~wxDisplay() {}
2818
2819 static size_t GetCount()
2820 { wxPyRaiseNotImplemented(); return 0; }
2821
2822 static int GetFromPoint(const wxPoint& pt)
2823 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2824 static int GetFromWindow(wxWindow *window)
2825 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2826
2827 virtual bool IsOk() const { return false; }
2828 virtual wxRect GetGeometry() const { wxRect r; return r; }
2829 virtual wxString GetName() const { return wxEmptyString; }
2830 bool IsPrimary() const { return false; }
2831
2832 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2833 { wxArrayVideoModes a; return a; }
2834
2835 virtual wxVideoMode GetCurrentMode() const
2836 { return wxDefaultVideoMode; }
2837
2838 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2839 { return false; }
2840
2841 void ResetMode() {}
2842 };
2843 #endif
2844
2845 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2846 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2847 PyObject* pyList = NULL;
2848 wxArrayVideoModes arr = self->GetModes(mode);
2849 bool blocked = wxPyBeginBlockThreads();
2850 pyList = PyList_New(0);
2851 for (int i=0; i < arr.GetCount(); i++) {
2852 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2853 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2854 PyList_Append(pyList, pyObj);
2855 Py_DECREF(pyObj);
2856 }
2857 wxPyEndBlockThreads(blocked);
2858 return pyList;
2859 }
2860
2861 #include <wx/stdpaths.h>
2862
2863 static wxStandardPaths *StandardPaths_Get(){
2864 return (wxStandardPaths*) &wxStandardPaths::Get();
2865 }
2866 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2867 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2868 #ifdef __cplusplus
2869 extern "C" {
2870 #endif
2871 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2872 PyObject *resultobj;
2873 wxSystemColour arg1 ;
2874 wxColour result;
2875 PyObject * obj0 = 0 ;
2876 char *kwnames[] = {
2877 (char *) "index", NULL
2878 };
2879
2880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2881 {
2882 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2883 if (SWIG_arg_fail(1)) SWIG_fail;
2884 }
2885 {
2886 if (!wxPyCheckForApp()) SWIG_fail;
2887 PyThreadState* __tstate = wxPyBeginAllowThreads();
2888 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2889
2890 wxPyEndAllowThreads(__tstate);
2891 if (PyErr_Occurred()) SWIG_fail;
2892 }
2893 {
2894 wxColour * resultptr;
2895 resultptr = new wxColour((wxColour &)(result));
2896 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2897 }
2898 return resultobj;
2899 fail:
2900 return NULL;
2901 }
2902
2903
2904 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2905 PyObject *resultobj;
2906 wxSystemFont arg1 ;
2907 wxFont result;
2908 PyObject * obj0 = 0 ;
2909 char *kwnames[] = {
2910 (char *) "index", NULL
2911 };
2912
2913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2914 {
2915 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2916 if (SWIG_arg_fail(1)) SWIG_fail;
2917 }
2918 {
2919 if (!wxPyCheckForApp()) SWIG_fail;
2920 PyThreadState* __tstate = wxPyBeginAllowThreads();
2921 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2922
2923 wxPyEndAllowThreads(__tstate);
2924 if (PyErr_Occurred()) SWIG_fail;
2925 }
2926 {
2927 wxFont * resultptr;
2928 resultptr = new wxFont((wxFont &)(result));
2929 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2930 }
2931 return resultobj;
2932 fail:
2933 return NULL;
2934 }
2935
2936
2937 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2938 PyObject *resultobj;
2939 wxSystemMetric arg1 ;
2940 int result;
2941 PyObject * obj0 = 0 ;
2942 char *kwnames[] = {
2943 (char *) "index", NULL
2944 };
2945
2946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2947 {
2948 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2949 if (SWIG_arg_fail(1)) SWIG_fail;
2950 }
2951 {
2952 if (!wxPyCheckForApp()) SWIG_fail;
2953 PyThreadState* __tstate = wxPyBeginAllowThreads();
2954 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2955
2956 wxPyEndAllowThreads(__tstate);
2957 if (PyErr_Occurred()) SWIG_fail;
2958 }
2959 {
2960 resultobj = SWIG_From_int((int)(result));
2961 }
2962 return resultobj;
2963 fail:
2964 return NULL;
2965 }
2966
2967
2968 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2969 PyObject *resultobj;
2970 wxSystemFeature arg1 ;
2971 bool result;
2972 PyObject * obj0 = 0 ;
2973 char *kwnames[] = {
2974 (char *) "index", NULL
2975 };
2976
2977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2978 {
2979 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2980 if (SWIG_arg_fail(1)) SWIG_fail;
2981 }
2982 {
2983 if (!wxPyCheckForApp()) SWIG_fail;
2984 PyThreadState* __tstate = wxPyBeginAllowThreads();
2985 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2986
2987 wxPyEndAllowThreads(__tstate);
2988 if (PyErr_Occurred()) SWIG_fail;
2989 }
2990 {
2991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2992 }
2993 return resultobj;
2994 fail:
2995 return NULL;
2996 }
2997
2998
2999 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3000 PyObject *resultobj;
3001 wxSystemScreenType result;
3002 char *kwnames[] = {
3003 NULL
3004 };
3005
3006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3007 {
3008 if (!wxPyCheckForApp()) SWIG_fail;
3009 PyThreadState* __tstate = wxPyBeginAllowThreads();
3010 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3011
3012 wxPyEndAllowThreads(__tstate);
3013 if (PyErr_Occurred()) SWIG_fail;
3014 }
3015 resultobj = SWIG_From_int((result));
3016 return resultobj;
3017 fail:
3018 return NULL;
3019 }
3020
3021
3022 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3023 PyObject *resultobj;
3024 wxSystemScreenType arg1 ;
3025 PyObject * obj0 = 0 ;
3026 char *kwnames[] = {
3027 (char *) "screen", NULL
3028 };
3029
3030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3031 {
3032 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3033 if (SWIG_arg_fail(1)) SWIG_fail;
3034 }
3035 {
3036 if (!wxPyCheckForApp()) SWIG_fail;
3037 PyThreadState* __tstate = wxPyBeginAllowThreads();
3038 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3039
3040 wxPyEndAllowThreads(__tstate);
3041 if (PyErr_Occurred()) SWIG_fail;
3042 }
3043 Py_INCREF(Py_None); resultobj = Py_None;
3044 return resultobj;
3045 fail:
3046 return NULL;
3047 }
3048
3049
3050 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3051 PyObject *obj;
3052 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3053 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3054 Py_INCREF(obj);
3055 return Py_BuildValue((char *)"");
3056 }
3057 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3058 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3059 return 1;
3060 }
3061
3062
3063 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3064 PyObject *pyobj;
3065
3066 {
3067 #if wxUSE_UNICODE
3068 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3069 #else
3070 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3071 #endif
3072 }
3073 return pyobj;
3074 }
3075
3076
3077 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3078 PyObject *resultobj;
3079 wxSystemOptions *result;
3080 char *kwnames[] = {
3081 NULL
3082 };
3083
3084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3085 {
3086 PyThreadState* __tstate = wxPyBeginAllowThreads();
3087 result = (wxSystemOptions *)new wxSystemOptions();
3088
3089 wxPyEndAllowThreads(__tstate);
3090 if (PyErr_Occurred()) SWIG_fail;
3091 }
3092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3093 return resultobj;
3094 fail:
3095 return NULL;
3096 }
3097
3098
3099 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3100 PyObject *resultobj;
3101 wxString *arg1 = 0 ;
3102 wxString *arg2 = 0 ;
3103 bool temp1 = false ;
3104 bool temp2 = false ;
3105 PyObject * obj0 = 0 ;
3106 PyObject * obj1 = 0 ;
3107 char *kwnames[] = {
3108 (char *) "name",(char *) "value", NULL
3109 };
3110
3111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3112 {
3113 arg1 = wxString_in_helper(obj0);
3114 if (arg1 == NULL) SWIG_fail;
3115 temp1 = true;
3116 }
3117 {
3118 arg2 = wxString_in_helper(obj1);
3119 if (arg2 == NULL) SWIG_fail;
3120 temp2 = true;
3121 }
3122 {
3123 PyThreadState* __tstate = wxPyBeginAllowThreads();
3124 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3125
3126 wxPyEndAllowThreads(__tstate);
3127 if (PyErr_Occurred()) SWIG_fail;
3128 }
3129 Py_INCREF(Py_None); resultobj = Py_None;
3130 {
3131 if (temp1)
3132 delete arg1;
3133 }
3134 {
3135 if (temp2)
3136 delete arg2;
3137 }
3138 return resultobj;
3139 fail:
3140 {
3141 if (temp1)
3142 delete arg1;
3143 }
3144 {
3145 if (temp2)
3146 delete arg2;
3147 }
3148 return NULL;
3149 }
3150
3151
3152 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3153 PyObject *resultobj;
3154 wxString *arg1 = 0 ;
3155 int arg2 ;
3156 bool temp1 = false ;
3157 PyObject * obj0 = 0 ;
3158 PyObject * obj1 = 0 ;
3159 char *kwnames[] = {
3160 (char *) "name",(char *) "value", NULL
3161 };
3162
3163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3164 {
3165 arg1 = wxString_in_helper(obj0);
3166 if (arg1 == NULL) SWIG_fail;
3167 temp1 = true;
3168 }
3169 {
3170 arg2 = (int)(SWIG_As_int(obj1));
3171 if (SWIG_arg_fail(2)) SWIG_fail;
3172 }
3173 {
3174 PyThreadState* __tstate = wxPyBeginAllowThreads();
3175 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3176
3177 wxPyEndAllowThreads(__tstate);
3178 if (PyErr_Occurred()) SWIG_fail;
3179 }
3180 Py_INCREF(Py_None); resultobj = Py_None;
3181 {
3182 if (temp1)
3183 delete arg1;
3184 }
3185 return resultobj;
3186 fail:
3187 {
3188 if (temp1)
3189 delete arg1;
3190 }
3191 return NULL;
3192 }
3193
3194
3195 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3196 PyObject *resultobj;
3197 wxString *arg1 = 0 ;
3198 wxString result;
3199 bool temp1 = false ;
3200 PyObject * obj0 = 0 ;
3201 char *kwnames[] = {
3202 (char *) "name", NULL
3203 };
3204
3205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3206 {
3207 arg1 = wxString_in_helper(obj0);
3208 if (arg1 == NULL) SWIG_fail;
3209 temp1 = true;
3210 }
3211 {
3212 PyThreadState* __tstate = wxPyBeginAllowThreads();
3213 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3214
3215 wxPyEndAllowThreads(__tstate);
3216 if (PyErr_Occurred()) SWIG_fail;
3217 }
3218 {
3219 #if wxUSE_UNICODE
3220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3221 #else
3222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3223 #endif
3224 }
3225 {
3226 if (temp1)
3227 delete arg1;
3228 }
3229 return resultobj;
3230 fail:
3231 {
3232 if (temp1)
3233 delete arg1;
3234 }
3235 return NULL;
3236 }
3237
3238
3239 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3240 PyObject *resultobj;
3241 wxString *arg1 = 0 ;
3242 int result;
3243 bool temp1 = false ;
3244 PyObject * obj0 = 0 ;
3245 char *kwnames[] = {
3246 (char *) "name", NULL
3247 };
3248
3249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3250 {
3251 arg1 = wxString_in_helper(obj0);
3252 if (arg1 == NULL) SWIG_fail;
3253 temp1 = true;
3254 }
3255 {
3256 PyThreadState* __tstate = wxPyBeginAllowThreads();
3257 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3258
3259 wxPyEndAllowThreads(__tstate);
3260 if (PyErr_Occurred()) SWIG_fail;
3261 }
3262 {
3263 resultobj = SWIG_From_int((int)(result));
3264 }
3265 {
3266 if (temp1)
3267 delete arg1;
3268 }
3269 return resultobj;
3270 fail:
3271 {
3272 if (temp1)
3273 delete arg1;
3274 }
3275 return NULL;
3276 }
3277
3278
3279 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3280 PyObject *resultobj;
3281 wxString *arg1 = 0 ;
3282 bool result;
3283 bool temp1 = false ;
3284 PyObject * obj0 = 0 ;
3285 char *kwnames[] = {
3286 (char *) "name", NULL
3287 };
3288
3289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3290 {
3291 arg1 = wxString_in_helper(obj0);
3292 if (arg1 == NULL) SWIG_fail;
3293 temp1 = true;
3294 }
3295 {
3296 PyThreadState* __tstate = wxPyBeginAllowThreads();
3297 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3298
3299 wxPyEndAllowThreads(__tstate);
3300 if (PyErr_Occurred()) SWIG_fail;
3301 }
3302 {
3303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3304 }
3305 {
3306 if (temp1)
3307 delete arg1;
3308 }
3309 return resultobj;
3310 fail:
3311 {
3312 if (temp1)
3313 delete arg1;
3314 }
3315 return NULL;
3316 }
3317
3318
3319 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3320 PyObject *obj;
3321 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3322 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3323 Py_INCREF(obj);
3324 return Py_BuildValue((char *)"");
3325 }
3326 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3327 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3328 return 1;
3329 }
3330
3331
3332 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3333 PyObject *pyobj;
3334
3335 {
3336 #if wxUSE_UNICODE
3337 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3338 #else
3339 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3340 #endif
3341 }
3342 return pyobj;
3343 }
3344
3345
3346 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3347 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3348 return 1;
3349 }
3350
3351
3352 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3353 PyObject *pyobj;
3354
3355 {
3356 #if wxUSE_UNICODE
3357 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3358 #else
3359 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3360 #endif
3361 }
3362 return pyobj;
3363 }
3364
3365
3366 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3367 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3368 return 1;
3369 }
3370
3371
3372 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3373 PyObject *pyobj;
3374
3375 {
3376 #if wxUSE_UNICODE
3377 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3378 #else
3379 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3380 #endif
3381 }
3382 return pyobj;
3383 }
3384
3385
3386 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3387 PyObject *resultobj;
3388 long result;
3389 char *kwnames[] = {
3390 NULL
3391 };
3392
3393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3394 {
3395 PyThreadState* __tstate = wxPyBeginAllowThreads();
3396 result = (long)wxNewId();
3397
3398 wxPyEndAllowThreads(__tstate);
3399 if (PyErr_Occurred()) SWIG_fail;
3400 }
3401 {
3402 resultobj = SWIG_From_long((long)(result));
3403 }
3404 return resultobj;
3405 fail:
3406 return NULL;
3407 }
3408
3409
3410 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3411 PyObject *resultobj;
3412 long arg1 ;
3413 PyObject * obj0 = 0 ;
3414 char *kwnames[] = {
3415 (char *) "id", NULL
3416 };
3417
3418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3419 {
3420 arg1 = (long)(SWIG_As_long(obj0));
3421 if (SWIG_arg_fail(1)) SWIG_fail;
3422 }
3423 {
3424 PyThreadState* __tstate = wxPyBeginAllowThreads();
3425 wxRegisterId(arg1);
3426
3427 wxPyEndAllowThreads(__tstate);
3428 if (PyErr_Occurred()) SWIG_fail;
3429 }
3430 Py_INCREF(Py_None); resultobj = Py_None;
3431 return resultobj;
3432 fail:
3433 return NULL;
3434 }
3435
3436
3437 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3438 PyObject *resultobj;
3439 long result;
3440 char *kwnames[] = {
3441 NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3445 {
3446 PyThreadState* __tstate = wxPyBeginAllowThreads();
3447 result = (long)wxGetCurrentId();
3448
3449 wxPyEndAllowThreads(__tstate);
3450 if (PyErr_Occurred()) SWIG_fail;
3451 }
3452 {
3453 resultobj = SWIG_From_long((long)(result));
3454 }
3455 return resultobj;
3456 fail:
3457 return NULL;
3458 }
3459
3460
3461 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3462 PyObject *resultobj;
3463 int arg1 ;
3464 bool result;
3465 PyObject * obj0 = 0 ;
3466 char *kwnames[] = {
3467 (char *) "id", NULL
3468 };
3469
3470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3471 {
3472 arg1 = (int)(SWIG_As_int(obj0));
3473 if (SWIG_arg_fail(1)) SWIG_fail;
3474 }
3475 {
3476 PyThreadState* __tstate = wxPyBeginAllowThreads();
3477 result = (bool)wxIsStockID(arg1);
3478
3479 wxPyEndAllowThreads(__tstate);
3480 if (PyErr_Occurred()) SWIG_fail;
3481 }
3482 {
3483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3484 }
3485 return resultobj;
3486 fail:
3487 return NULL;
3488 }
3489
3490
3491 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3492 PyObject *resultobj;
3493 int arg1 ;
3494 wxString *arg2 = 0 ;
3495 bool result;
3496 bool temp2 = false ;
3497 PyObject * obj0 = 0 ;
3498 PyObject * obj1 = 0 ;
3499 char *kwnames[] = {
3500 (char *) "id",(char *) "label", NULL
3501 };
3502
3503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3504 {
3505 arg1 = (int)(SWIG_As_int(obj0));
3506 if (SWIG_arg_fail(1)) SWIG_fail;
3507 }
3508 {
3509 arg2 = wxString_in_helper(obj1);
3510 if (arg2 == NULL) SWIG_fail;
3511 temp2 = true;
3512 }
3513 {
3514 PyThreadState* __tstate = wxPyBeginAllowThreads();
3515 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3516
3517 wxPyEndAllowThreads(__tstate);
3518 if (PyErr_Occurred()) SWIG_fail;
3519 }
3520 {
3521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3522 }
3523 {
3524 if (temp2)
3525 delete arg2;
3526 }
3527 return resultobj;
3528 fail:
3529 {
3530 if (temp2)
3531 delete arg2;
3532 }
3533 return NULL;
3534 }
3535
3536
3537 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3538 PyObject *resultobj;
3539 int arg1 ;
3540 bool arg2 = (bool) true ;
3541 wxString arg3 = (wxString) wxPyEmptyString ;
3542 wxString result;
3543 PyObject * obj0 = 0 ;
3544 PyObject * obj1 = 0 ;
3545 PyObject * obj2 = 0 ;
3546 char *kwnames[] = {
3547 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3548 };
3549
3550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3551 {
3552 arg1 = (int)(SWIG_As_int(obj0));
3553 if (SWIG_arg_fail(1)) SWIG_fail;
3554 }
3555 if (obj1) {
3556 {
3557 arg2 = (bool)(SWIG_As_bool(obj1));
3558 if (SWIG_arg_fail(2)) SWIG_fail;
3559 }
3560 }
3561 if (obj2) {
3562 {
3563 wxString* sptr = wxString_in_helper(obj2);
3564 if (sptr == NULL) SWIG_fail;
3565 arg3 = *sptr;
3566 delete sptr;
3567 }
3568 }
3569 {
3570 PyThreadState* __tstate = wxPyBeginAllowThreads();
3571 result = wxGetStockLabel(arg1,arg2,arg3);
3572
3573 wxPyEndAllowThreads(__tstate);
3574 if (PyErr_Occurred()) SWIG_fail;
3575 }
3576 {
3577 #if wxUSE_UNICODE
3578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3579 #else
3580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3581 #endif
3582 }
3583 return resultobj;
3584 fail:
3585 return NULL;
3586 }
3587
3588
3589 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3590 PyObject *resultobj;
3591 char *kwnames[] = {
3592 NULL
3593 };
3594
3595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3596 {
3597 if (!wxPyCheckForApp()) SWIG_fail;
3598 PyThreadState* __tstate = wxPyBeginAllowThreads();
3599 wxBell();
3600
3601 wxPyEndAllowThreads(__tstate);
3602 if (PyErr_Occurred()) SWIG_fail;
3603 }
3604 Py_INCREF(Py_None); resultobj = Py_None;
3605 return resultobj;
3606 fail:
3607 return NULL;
3608 }
3609
3610
3611 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3612 PyObject *resultobj;
3613 char *kwnames[] = {
3614 NULL
3615 };
3616
3617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3618 {
3619 if (!wxPyCheckForApp()) SWIG_fail;
3620 PyThreadState* __tstate = wxPyBeginAllowThreads();
3621 wxEndBusyCursor();
3622
3623 wxPyEndAllowThreads(__tstate);
3624 if (PyErr_Occurred()) SWIG_fail;
3625 }
3626 Py_INCREF(Py_None); resultobj = Py_None;
3627 return resultobj;
3628 fail:
3629 return NULL;
3630 }
3631
3632
3633 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3634 PyObject *resultobj;
3635 bool arg1 = (bool) true ;
3636 long result;
3637 PyObject * obj0 = 0 ;
3638 char *kwnames[] = {
3639 (char *) "resetTimer", NULL
3640 };
3641
3642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3643 if (obj0) {
3644 {
3645 arg1 = (bool)(SWIG_As_bool(obj0));
3646 if (SWIG_arg_fail(1)) SWIG_fail;
3647 }
3648 }
3649 {
3650 PyThreadState* __tstate = wxPyBeginAllowThreads();
3651 result = (long)wxGetElapsedTime(arg1);
3652
3653 wxPyEndAllowThreads(__tstate);
3654 if (PyErr_Occurred()) SWIG_fail;
3655 }
3656 {
3657 resultobj = SWIG_From_long((long)(result));
3658 }
3659 return resultobj;
3660 fail:
3661 return NULL;
3662 }
3663
3664
3665 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3666 PyObject *resultobj;
3667 int *arg1 = (int *) 0 ;
3668 int *arg2 = (int *) 0 ;
3669 int temp1 ;
3670 int res1 = 0 ;
3671 int temp2 ;
3672 int res2 = 0 ;
3673 char *kwnames[] = {
3674 NULL
3675 };
3676
3677 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3678 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3680 {
3681 if (!wxPyCheckForApp()) SWIG_fail;
3682 PyThreadState* __tstate = wxPyBeginAllowThreads();
3683 wxGetMousePosition(arg1,arg2);
3684
3685 wxPyEndAllowThreads(__tstate);
3686 if (PyErr_Occurred()) SWIG_fail;
3687 }
3688 Py_INCREF(Py_None); resultobj = Py_None;
3689 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3690 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3691 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3692 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3693 return resultobj;
3694 fail:
3695 return NULL;
3696 }
3697
3698
3699 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3700 PyObject *resultobj;
3701 bool result;
3702 char *kwnames[] = {
3703 NULL
3704 };
3705
3706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3707 {
3708 PyThreadState* __tstate = wxPyBeginAllowThreads();
3709 result = (bool)wxIsBusy();
3710
3711 wxPyEndAllowThreads(__tstate);
3712 if (PyErr_Occurred()) SWIG_fail;
3713 }
3714 {
3715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3716 }
3717 return resultobj;
3718 fail:
3719 return NULL;
3720 }
3721
3722
3723 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3724 PyObject *resultobj;
3725 wxString result;
3726 char *kwnames[] = {
3727 NULL
3728 };
3729
3730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3731 {
3732 PyThreadState* __tstate = wxPyBeginAllowThreads();
3733 result = wxNow();
3734
3735 wxPyEndAllowThreads(__tstate);
3736 if (PyErr_Occurred()) SWIG_fail;
3737 }
3738 {
3739 #if wxUSE_UNICODE
3740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3741 #else
3742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3743 #endif
3744 }
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
3751 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3752 PyObject *resultobj;
3753 wxString const &arg1_defvalue = wxPyEmptyString ;
3754 wxString *arg1 = (wxString *) &arg1_defvalue ;
3755 bool result;
3756 bool temp1 = false ;
3757 PyObject * obj0 = 0 ;
3758 char *kwnames[] = {
3759 (char *) "command", NULL
3760 };
3761
3762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3763 if (obj0) {
3764 {
3765 arg1 = wxString_in_helper(obj0);
3766 if (arg1 == NULL) SWIG_fail;
3767 temp1 = true;
3768 }
3769 }
3770 {
3771 PyThreadState* __tstate = wxPyBeginAllowThreads();
3772 result = (bool)wxShell((wxString const &)*arg1);
3773
3774 wxPyEndAllowThreads(__tstate);
3775 if (PyErr_Occurred()) SWIG_fail;
3776 }
3777 {
3778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3779 }
3780 {
3781 if (temp1)
3782 delete arg1;
3783 }
3784 return resultobj;
3785 fail:
3786 {
3787 if (temp1)
3788 delete arg1;
3789 }
3790 return NULL;
3791 }
3792
3793
3794 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3795 PyObject *resultobj;
3796 char *kwnames[] = {
3797 NULL
3798 };
3799
3800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3801 {
3802 PyThreadState* __tstate = wxPyBeginAllowThreads();
3803 wxStartTimer();
3804
3805 wxPyEndAllowThreads(__tstate);
3806 if (PyErr_Occurred()) SWIG_fail;
3807 }
3808 Py_INCREF(Py_None); resultobj = Py_None;
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj;
3817 int *arg1 = (int *) 0 ;
3818 int *arg2 = (int *) 0 ;
3819 int result;
3820 int temp1 ;
3821 int res1 = 0 ;
3822 int temp2 ;
3823 int res2 = 0 ;
3824 char *kwnames[] = {
3825 NULL
3826 };
3827
3828 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3829 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3831 {
3832 PyThreadState* __tstate = wxPyBeginAllowThreads();
3833 result = (int)wxGetOsVersion(arg1,arg2);
3834
3835 wxPyEndAllowThreads(__tstate);
3836 if (PyErr_Occurred()) SWIG_fail;
3837 }
3838 {
3839 resultobj = SWIG_From_int((int)(result));
3840 }
3841 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3842 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3843 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3844 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3845 return resultobj;
3846 fail:
3847 return NULL;
3848 }
3849
3850
3851 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3852 PyObject *resultobj;
3853 wxString result;
3854 char *kwnames[] = {
3855 NULL
3856 };
3857
3858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3859 {
3860 PyThreadState* __tstate = wxPyBeginAllowThreads();
3861 result = wxGetOsDescription();
3862
3863 wxPyEndAllowThreads(__tstate);
3864 if (PyErr_Occurred()) SWIG_fail;
3865 }
3866 {
3867 #if wxUSE_UNICODE
3868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3869 #else
3870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3871 #endif
3872 }
3873 return resultobj;
3874 fail:
3875 return NULL;
3876 }
3877
3878
3879 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3880 PyObject *resultobj;
3881 long result;
3882 char *kwnames[] = {
3883 NULL
3884 };
3885
3886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3887 {
3888 PyThreadState* __tstate = wxPyBeginAllowThreads();
3889 result = (long)wxGetFreeMemory();
3890
3891 wxPyEndAllowThreads(__tstate);
3892 if (PyErr_Occurred()) SWIG_fail;
3893 }
3894 {
3895 resultobj = SWIG_From_long((long)(result));
3896 }
3897 return resultobj;
3898 fail:
3899 return NULL;
3900 }
3901
3902
3903 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3904 PyObject *resultobj;
3905 wxShutdownFlags arg1 ;
3906 bool result;
3907 PyObject * obj0 = 0 ;
3908 char *kwnames[] = {
3909 (char *) "wFlags", NULL
3910 };
3911
3912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3913 {
3914 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3915 if (SWIG_arg_fail(1)) SWIG_fail;
3916 }
3917 {
3918 if (!wxPyCheckForApp()) SWIG_fail;
3919 PyThreadState* __tstate = wxPyBeginAllowThreads();
3920 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3921
3922 wxPyEndAllowThreads(__tstate);
3923 if (PyErr_Occurred()) SWIG_fail;
3924 }
3925 {
3926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3927 }
3928 return resultobj;
3929 fail:
3930 return NULL;
3931 }
3932
3933
3934 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3935 PyObject *resultobj;
3936 int arg1 ;
3937 PyObject * obj0 = 0 ;
3938 char *kwnames[] = {
3939 (char *) "secs", NULL
3940 };
3941
3942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3943 {
3944 arg1 = (int)(SWIG_As_int(obj0));
3945 if (SWIG_arg_fail(1)) SWIG_fail;
3946 }
3947 {
3948 PyThreadState* __tstate = wxPyBeginAllowThreads();
3949 wxSleep(arg1);
3950
3951 wxPyEndAllowThreads(__tstate);
3952 if (PyErr_Occurred()) SWIG_fail;
3953 }
3954 Py_INCREF(Py_None); resultobj = Py_None;
3955 return resultobj;
3956 fail:
3957 return NULL;
3958 }
3959
3960
3961 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3962 PyObject *resultobj;
3963 unsigned long arg1 ;
3964 PyObject * obj0 = 0 ;
3965 char *kwnames[] = {
3966 (char *) "milliseconds", NULL
3967 };
3968
3969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3970 {
3971 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3972 if (SWIG_arg_fail(1)) SWIG_fail;
3973 }
3974 {
3975 PyThreadState* __tstate = wxPyBeginAllowThreads();
3976 wxMilliSleep(arg1);
3977
3978 wxPyEndAllowThreads(__tstate);
3979 if (PyErr_Occurred()) SWIG_fail;
3980 }
3981 Py_INCREF(Py_None); resultobj = Py_None;
3982 return resultobj;
3983 fail:
3984 return NULL;
3985 }
3986
3987
3988 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3989 PyObject *resultobj;
3990 unsigned long arg1 ;
3991 PyObject * obj0 = 0 ;
3992 char *kwnames[] = {
3993 (char *) "microseconds", NULL
3994 };
3995
3996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
3997 {
3998 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3999 if (SWIG_arg_fail(1)) SWIG_fail;
4000 }
4001 {
4002 PyThreadState* __tstate = wxPyBeginAllowThreads();
4003 wxMicroSleep(arg1);
4004
4005 wxPyEndAllowThreads(__tstate);
4006 if (PyErr_Occurred()) SWIG_fail;
4007 }
4008 Py_INCREF(Py_None); resultobj = Py_None;
4009 return resultobj;
4010 fail:
4011 return NULL;
4012 }
4013
4014
4015 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4016 PyObject *resultobj;
4017 bool arg1 ;
4018 PyObject * obj0 = 0 ;
4019 char *kwnames[] = {
4020 (char *) "enable", NULL
4021 };
4022
4023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4024 {
4025 arg1 = (bool)(SWIG_As_bool(obj0));
4026 if (SWIG_arg_fail(1)) SWIG_fail;
4027 }
4028 {
4029 PyThreadState* __tstate = wxPyBeginAllowThreads();
4030 wxEnableTopLevelWindows(arg1);
4031
4032 wxPyEndAllowThreads(__tstate);
4033 if (PyErr_Occurred()) SWIG_fail;
4034 }
4035 Py_INCREF(Py_None); resultobj = Py_None;
4036 return resultobj;
4037 fail:
4038 return NULL;
4039 }
4040
4041
4042 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4043 PyObject *resultobj;
4044 wxString *arg1 = 0 ;
4045 wxString result;
4046 bool temp1 = false ;
4047 PyObject * obj0 = 0 ;
4048 char *kwnames[] = {
4049 (char *) "in", NULL
4050 };
4051
4052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4053 {
4054 arg1 = wxString_in_helper(obj0);
4055 if (arg1 == NULL) SWIG_fail;
4056 temp1 = true;
4057 }
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 result = wxStripMenuCodes((wxString const &)*arg1);
4061
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 {
4066 #if wxUSE_UNICODE
4067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4068 #else
4069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4070 #endif
4071 }
4072 {
4073 if (temp1)
4074 delete arg1;
4075 }
4076 return resultobj;
4077 fail:
4078 {
4079 if (temp1)
4080 delete arg1;
4081 }
4082 return NULL;
4083 }
4084
4085
4086 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4087 PyObject *resultobj;
4088 wxString result;
4089 char *kwnames[] = {
4090 NULL
4091 };
4092
4093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4094 {
4095 PyThreadState* __tstate = wxPyBeginAllowThreads();
4096 result = wxGetEmailAddress();
4097
4098 wxPyEndAllowThreads(__tstate);
4099 if (PyErr_Occurred()) SWIG_fail;
4100 }
4101 {
4102 #if wxUSE_UNICODE
4103 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4104 #else
4105 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4106 #endif
4107 }
4108 return resultobj;
4109 fail:
4110 return NULL;
4111 }
4112
4113
4114 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4115 PyObject *resultobj;
4116 wxString result;
4117 char *kwnames[] = {
4118 NULL
4119 };
4120
4121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4122 {
4123 PyThreadState* __tstate = wxPyBeginAllowThreads();
4124 result = wxGetHostName();
4125
4126 wxPyEndAllowThreads(__tstate);
4127 if (PyErr_Occurred()) SWIG_fail;
4128 }
4129 {
4130 #if wxUSE_UNICODE
4131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4132 #else
4133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4134 #endif
4135 }
4136 return resultobj;
4137 fail:
4138 return NULL;
4139 }
4140
4141
4142 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4143 PyObject *resultobj;
4144 wxString result;
4145 char *kwnames[] = {
4146 NULL
4147 };
4148
4149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4150 {
4151 PyThreadState* __tstate = wxPyBeginAllowThreads();
4152 result = wxGetFullHostName();
4153
4154 wxPyEndAllowThreads(__tstate);
4155 if (PyErr_Occurred()) SWIG_fail;
4156 }
4157 {
4158 #if wxUSE_UNICODE
4159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4160 #else
4161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4162 #endif
4163 }
4164 return resultobj;
4165 fail:
4166 return NULL;
4167 }
4168
4169
4170 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4171 PyObject *resultobj;
4172 wxString result;
4173 char *kwnames[] = {
4174 NULL
4175 };
4176
4177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4178 {
4179 PyThreadState* __tstate = wxPyBeginAllowThreads();
4180 result = wxGetUserId();
4181
4182 wxPyEndAllowThreads(__tstate);
4183 if (PyErr_Occurred()) SWIG_fail;
4184 }
4185 {
4186 #if wxUSE_UNICODE
4187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4188 #else
4189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4190 #endif
4191 }
4192 return resultobj;
4193 fail:
4194 return NULL;
4195 }
4196
4197
4198 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj;
4200 wxString result;
4201 char *kwnames[] = {
4202 NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4206 {
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 result = wxGetUserName();
4209
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 {
4214 #if wxUSE_UNICODE
4215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4216 #else
4217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4218 #endif
4219 }
4220 return resultobj;
4221 fail:
4222 return NULL;
4223 }
4224
4225
4226 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4227 PyObject *resultobj;
4228 wxString result;
4229 char *kwnames[] = {
4230 NULL
4231 };
4232
4233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4234 {
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 result = wxGetHomeDir();
4237
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 {
4242 #if wxUSE_UNICODE
4243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4244 #else
4245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4246 #endif
4247 }
4248 return resultobj;
4249 fail:
4250 return NULL;
4251 }
4252
4253
4254 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4255 PyObject *resultobj;
4256 wxString const &arg1_defvalue = wxPyEmptyString ;
4257 wxString *arg1 = (wxString *) &arg1_defvalue ;
4258 wxString result;
4259 bool temp1 = false ;
4260 PyObject * obj0 = 0 ;
4261 char *kwnames[] = {
4262 (char *) "user", NULL
4263 };
4264
4265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4266 if (obj0) {
4267 {
4268 arg1 = wxString_in_helper(obj0);
4269 if (arg1 == NULL) SWIG_fail;
4270 temp1 = true;
4271 }
4272 }
4273 {
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 result = wxGetUserHome((wxString const &)*arg1);
4276
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 {
4281 #if wxUSE_UNICODE
4282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4283 #else
4284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4285 #endif
4286 }
4287 {
4288 if (temp1)
4289 delete arg1;
4290 }
4291 return resultobj;
4292 fail:
4293 {
4294 if (temp1)
4295 delete arg1;
4296 }
4297 return NULL;
4298 }
4299
4300
4301 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4302 PyObject *resultobj;
4303 unsigned long result;
4304 char *kwnames[] = {
4305 NULL
4306 };
4307
4308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4309 {
4310 PyThreadState* __tstate = wxPyBeginAllowThreads();
4311 result = (unsigned long)wxGetProcessId();
4312
4313 wxPyEndAllowThreads(__tstate);
4314 if (PyErr_Occurred()) SWIG_fail;
4315 }
4316 {
4317 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4318 }
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4326 PyObject *resultobj;
4327 char *kwnames[] = {
4328 NULL
4329 };
4330
4331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4332 {
4333 PyThreadState* __tstate = wxPyBeginAllowThreads();
4334 wxTrap();
4335
4336 wxPyEndAllowThreads(__tstate);
4337 if (PyErr_Occurred()) SWIG_fail;
4338 }
4339 Py_INCREF(Py_None); resultobj = Py_None;
4340 return resultobj;
4341 fail:
4342 return NULL;
4343 }
4344
4345
4346 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4347 PyObject *resultobj;
4348 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4349 wxString *arg1 = (wxString *) &arg1_defvalue ;
4350 wxString const &arg2_defvalue = wxPyEmptyString ;
4351 wxString *arg2 = (wxString *) &arg2_defvalue ;
4352 wxString const &arg3_defvalue = wxPyEmptyString ;
4353 wxString *arg3 = (wxString *) &arg3_defvalue ;
4354 wxString const &arg4_defvalue = wxPyEmptyString ;
4355 wxString *arg4 = (wxString *) &arg4_defvalue ;
4356 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4357 wxString *arg5 = (wxString *) &arg5_defvalue ;
4358 int arg6 = (int) 0 ;
4359 wxWindow *arg7 = (wxWindow *) NULL ;
4360 int arg8 = (int) -1 ;
4361 int arg9 = (int) -1 ;
4362 wxString result;
4363 bool temp1 = false ;
4364 bool temp2 = false ;
4365 bool temp3 = false ;
4366 bool temp4 = false ;
4367 bool temp5 = false ;
4368 PyObject * obj0 = 0 ;
4369 PyObject * obj1 = 0 ;
4370 PyObject * obj2 = 0 ;
4371 PyObject * obj3 = 0 ;
4372 PyObject * obj4 = 0 ;
4373 PyObject * obj5 = 0 ;
4374 PyObject * obj6 = 0 ;
4375 PyObject * obj7 = 0 ;
4376 PyObject * obj8 = 0 ;
4377 char *kwnames[] = {
4378 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4379 };
4380
4381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4382 if (obj0) {
4383 {
4384 arg1 = wxString_in_helper(obj0);
4385 if (arg1 == NULL) SWIG_fail;
4386 temp1 = true;
4387 }
4388 }
4389 if (obj1) {
4390 {
4391 arg2 = wxString_in_helper(obj1);
4392 if (arg2 == NULL) SWIG_fail;
4393 temp2 = true;
4394 }
4395 }
4396 if (obj2) {
4397 {
4398 arg3 = wxString_in_helper(obj2);
4399 if (arg3 == NULL) SWIG_fail;
4400 temp3 = true;
4401 }
4402 }
4403 if (obj3) {
4404 {
4405 arg4 = wxString_in_helper(obj3);
4406 if (arg4 == NULL) SWIG_fail;
4407 temp4 = true;
4408 }
4409 }
4410 if (obj4) {
4411 {
4412 arg5 = wxString_in_helper(obj4);
4413 if (arg5 == NULL) SWIG_fail;
4414 temp5 = true;
4415 }
4416 }
4417 if (obj5) {
4418 {
4419 arg6 = (int)(SWIG_As_int(obj5));
4420 if (SWIG_arg_fail(6)) SWIG_fail;
4421 }
4422 }
4423 if (obj6) {
4424 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4425 if (SWIG_arg_fail(7)) SWIG_fail;
4426 }
4427 if (obj7) {
4428 {
4429 arg8 = (int)(SWIG_As_int(obj7));
4430 if (SWIG_arg_fail(8)) SWIG_fail;
4431 }
4432 }
4433 if (obj8) {
4434 {
4435 arg9 = (int)(SWIG_As_int(obj8));
4436 if (SWIG_arg_fail(9)) SWIG_fail;
4437 }
4438 }
4439 {
4440 if (!wxPyCheckForApp()) SWIG_fail;
4441 PyThreadState* __tstate = wxPyBeginAllowThreads();
4442 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4443
4444 wxPyEndAllowThreads(__tstate);
4445 if (PyErr_Occurred()) SWIG_fail;
4446 }
4447 {
4448 #if wxUSE_UNICODE
4449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4450 #else
4451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4452 #endif
4453 }
4454 {
4455 if (temp1)
4456 delete arg1;
4457 }
4458 {
4459 if (temp2)
4460 delete arg2;
4461 }
4462 {
4463 if (temp3)
4464 delete arg3;
4465 }
4466 {
4467 if (temp4)
4468 delete arg4;
4469 }
4470 {
4471 if (temp5)
4472 delete arg5;
4473 }
4474 return resultobj;
4475 fail:
4476 {
4477 if (temp1)
4478 delete arg1;
4479 }
4480 {
4481 if (temp2)
4482 delete arg2;
4483 }
4484 {
4485 if (temp3)
4486 delete arg3;
4487 }
4488 {
4489 if (temp4)
4490 delete arg4;
4491 }
4492 {
4493 if (temp5)
4494 delete arg5;
4495 }
4496 return NULL;
4497 }
4498
4499
4500 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4501 PyObject *resultobj;
4502 wxString *arg1 = 0 ;
4503 wxString *arg2 = 0 ;
4504 wxString const &arg3_defvalue = wxPyEmptyString ;
4505 wxString *arg3 = (wxString *) &arg3_defvalue ;
4506 wxWindow *arg4 = (wxWindow *) NULL ;
4507 wxString result;
4508 bool temp1 = false ;
4509 bool temp2 = false ;
4510 bool temp3 = false ;
4511 PyObject * obj0 = 0 ;
4512 PyObject * obj1 = 0 ;
4513 PyObject * obj2 = 0 ;
4514 PyObject * obj3 = 0 ;
4515 char *kwnames[] = {
4516 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4517 };
4518
4519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4520 {
4521 arg1 = wxString_in_helper(obj0);
4522 if (arg1 == NULL) SWIG_fail;
4523 temp1 = true;
4524 }
4525 {
4526 arg2 = wxString_in_helper(obj1);
4527 if (arg2 == NULL) SWIG_fail;
4528 temp2 = true;
4529 }
4530 if (obj2) {
4531 {
4532 arg3 = wxString_in_helper(obj2);
4533 if (arg3 == NULL) SWIG_fail;
4534 temp3 = true;
4535 }
4536 }
4537 if (obj3) {
4538 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4539 if (SWIG_arg_fail(4)) SWIG_fail;
4540 }
4541 {
4542 if (!wxPyCheckForApp()) SWIG_fail;
4543 PyThreadState* __tstate = wxPyBeginAllowThreads();
4544 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4545
4546 wxPyEndAllowThreads(__tstate);
4547 if (PyErr_Occurred()) SWIG_fail;
4548 }
4549 {
4550 #if wxUSE_UNICODE
4551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4552 #else
4553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4554 #endif
4555 }
4556 {
4557 if (temp1)
4558 delete arg1;
4559 }
4560 {
4561 if (temp2)
4562 delete arg2;
4563 }
4564 {
4565 if (temp3)
4566 delete arg3;
4567 }
4568 return resultobj;
4569 fail:
4570 {
4571 if (temp1)
4572 delete arg1;
4573 }
4574 {
4575 if (temp2)
4576 delete arg2;
4577 }
4578 {
4579 if (temp3)
4580 delete arg3;
4581 }
4582 return NULL;
4583 }
4584
4585
4586 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj;
4588 wxString *arg1 = 0 ;
4589 wxString *arg2 = 0 ;
4590 wxString const &arg3_defvalue = wxPyEmptyString ;
4591 wxString *arg3 = (wxString *) &arg3_defvalue ;
4592 wxWindow *arg4 = (wxWindow *) NULL ;
4593 wxString result;
4594 bool temp1 = false ;
4595 bool temp2 = false ;
4596 bool temp3 = false ;
4597 PyObject * obj0 = 0 ;
4598 PyObject * obj1 = 0 ;
4599 PyObject * obj2 = 0 ;
4600 PyObject * obj3 = 0 ;
4601 char *kwnames[] = {
4602 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4603 };
4604
4605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4606 {
4607 arg1 = wxString_in_helper(obj0);
4608 if (arg1 == NULL) SWIG_fail;
4609 temp1 = true;
4610 }
4611 {
4612 arg2 = wxString_in_helper(obj1);
4613 if (arg2 == NULL) SWIG_fail;
4614 temp2 = true;
4615 }
4616 if (obj2) {
4617 {
4618 arg3 = wxString_in_helper(obj2);
4619 if (arg3 == NULL) SWIG_fail;
4620 temp3 = true;
4621 }
4622 }
4623 if (obj3) {
4624 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4625 if (SWIG_arg_fail(4)) SWIG_fail;
4626 }
4627 {
4628 if (!wxPyCheckForApp()) SWIG_fail;
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 {
4636 #if wxUSE_UNICODE
4637 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4638 #else
4639 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4640 #endif
4641 }
4642 {
4643 if (temp1)
4644 delete arg1;
4645 }
4646 {
4647 if (temp2)
4648 delete arg2;
4649 }
4650 {
4651 if (temp3)
4652 delete arg3;
4653 }
4654 return resultobj;
4655 fail:
4656 {
4657 if (temp1)
4658 delete arg1;
4659 }
4660 {
4661 if (temp2)
4662 delete arg2;
4663 }
4664 {
4665 if (temp3)
4666 delete arg3;
4667 }
4668 return NULL;
4669 }
4670
4671
4672 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4673 PyObject *resultobj;
4674 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4675 wxString *arg1 = (wxString *) &arg1_defvalue ;
4676 wxString const &arg2_defvalue = wxPyEmptyString ;
4677 wxString *arg2 = (wxString *) &arg2_defvalue ;
4678 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4679 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4680 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4681 wxWindow *arg5 = (wxWindow *) NULL ;
4682 wxString result;
4683 bool temp1 = false ;
4684 bool temp2 = false ;
4685 wxPoint temp4 ;
4686 PyObject * obj0 = 0 ;
4687 PyObject * obj1 = 0 ;
4688 PyObject * obj2 = 0 ;
4689 PyObject * obj3 = 0 ;
4690 PyObject * obj4 = 0 ;
4691 char *kwnames[] = {
4692 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4693 };
4694
4695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4696 if (obj0) {
4697 {
4698 arg1 = wxString_in_helper(obj0);
4699 if (arg1 == NULL) SWIG_fail;
4700 temp1 = true;
4701 }
4702 }
4703 if (obj1) {
4704 {
4705 arg2 = wxString_in_helper(obj1);
4706 if (arg2 == NULL) SWIG_fail;
4707 temp2 = true;
4708 }
4709 }
4710 if (obj2) {
4711 {
4712 arg3 = (long)(SWIG_As_long(obj2));
4713 if (SWIG_arg_fail(3)) SWIG_fail;
4714 }
4715 }
4716 if (obj3) {
4717 {
4718 arg4 = &temp4;
4719 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4720 }
4721 }
4722 if (obj4) {
4723 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4724 if (SWIG_arg_fail(5)) SWIG_fail;
4725 }
4726 {
4727 if (!wxPyCheckForApp()) SWIG_fail;
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4730
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 {
4735 #if wxUSE_UNICODE
4736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4737 #else
4738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4739 #endif
4740 }
4741 {
4742 if (temp1)
4743 delete arg1;
4744 }
4745 {
4746 if (temp2)
4747 delete arg2;
4748 }
4749 return resultobj;
4750 fail:
4751 {
4752 if (temp1)
4753 delete arg1;
4754 }
4755 {
4756 if (temp2)
4757 delete arg2;
4758 }
4759 return NULL;
4760 }
4761
4762
4763 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4764 PyObject *resultobj;
4765 wxString *arg1 = 0 ;
4766 wxString const &arg2_defvalue = wxPyEmptyString ;
4767 wxString *arg2 = (wxString *) &arg2_defvalue ;
4768 wxString const &arg3_defvalue = wxPyEmptyString ;
4769 wxString *arg3 = (wxString *) &arg3_defvalue ;
4770 wxWindow *arg4 = (wxWindow *) NULL ;
4771 int arg5 = (int) -1 ;
4772 int arg6 = (int) -1 ;
4773 bool arg7 = (bool) true ;
4774 wxString result;
4775 bool temp1 = false ;
4776 bool temp2 = false ;
4777 bool temp3 = false ;
4778 PyObject * obj0 = 0 ;
4779 PyObject * obj1 = 0 ;
4780 PyObject * obj2 = 0 ;
4781 PyObject * obj3 = 0 ;
4782 PyObject * obj4 = 0 ;
4783 PyObject * obj5 = 0 ;
4784 PyObject * obj6 = 0 ;
4785 char *kwnames[] = {
4786 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4787 };
4788
4789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4790 {
4791 arg1 = wxString_in_helper(obj0);
4792 if (arg1 == NULL) SWIG_fail;
4793 temp1 = true;
4794 }
4795 if (obj1) {
4796 {
4797 arg2 = wxString_in_helper(obj1);
4798 if (arg2 == NULL) SWIG_fail;
4799 temp2 = true;
4800 }
4801 }
4802 if (obj2) {
4803 {
4804 arg3 = wxString_in_helper(obj2);
4805 if (arg3 == NULL) SWIG_fail;
4806 temp3 = true;
4807 }
4808 }
4809 if (obj3) {
4810 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4811 if (SWIG_arg_fail(4)) SWIG_fail;
4812 }
4813 if (obj4) {
4814 {
4815 arg5 = (int)(SWIG_As_int(obj4));
4816 if (SWIG_arg_fail(5)) SWIG_fail;
4817 }
4818 }
4819 if (obj5) {
4820 {
4821 arg6 = (int)(SWIG_As_int(obj5));
4822 if (SWIG_arg_fail(6)) SWIG_fail;
4823 }
4824 }
4825 if (obj6) {
4826 {
4827 arg7 = (bool)(SWIG_As_bool(obj6));
4828 if (SWIG_arg_fail(7)) SWIG_fail;
4829 }
4830 }
4831 {
4832 if (!wxPyCheckForApp()) SWIG_fail;
4833 PyThreadState* __tstate = wxPyBeginAllowThreads();
4834 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4835
4836 wxPyEndAllowThreads(__tstate);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 {
4840 #if wxUSE_UNICODE
4841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4842 #else
4843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4844 #endif
4845 }
4846 {
4847 if (temp1)
4848 delete arg1;
4849 }
4850 {
4851 if (temp2)
4852 delete arg2;
4853 }
4854 {
4855 if (temp3)
4856 delete arg3;
4857 }
4858 return resultobj;
4859 fail:
4860 {
4861 if (temp1)
4862 delete arg1;
4863 }
4864 {
4865 if (temp2)
4866 delete arg2;
4867 }
4868 {
4869 if (temp3)
4870 delete arg3;
4871 }
4872 return NULL;
4873 }
4874
4875
4876 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4877 PyObject *resultobj;
4878 wxString *arg1 = 0 ;
4879 wxString const &arg2_defvalue = wxPyEmptyString ;
4880 wxString *arg2 = (wxString *) &arg2_defvalue ;
4881 wxString const &arg3_defvalue = wxPyEmptyString ;
4882 wxString *arg3 = (wxString *) &arg3_defvalue ;
4883 wxWindow *arg4 = (wxWindow *) NULL ;
4884 wxString result;
4885 bool temp1 = false ;
4886 bool temp2 = false ;
4887 bool temp3 = false ;
4888 PyObject * obj0 = 0 ;
4889 PyObject * obj1 = 0 ;
4890 PyObject * obj2 = 0 ;
4891 PyObject * obj3 = 0 ;
4892 char *kwnames[] = {
4893 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4894 };
4895
4896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4897 {
4898 arg1 = wxString_in_helper(obj0);
4899 if (arg1 == NULL) SWIG_fail;
4900 temp1 = true;
4901 }
4902 if (obj1) {
4903 {
4904 arg2 = wxString_in_helper(obj1);
4905 if (arg2 == NULL) SWIG_fail;
4906 temp2 = true;
4907 }
4908 }
4909 if (obj2) {
4910 {
4911 arg3 = wxString_in_helper(obj2);
4912 if (arg3 == NULL) SWIG_fail;
4913 temp3 = true;
4914 }
4915 }
4916 if (obj3) {
4917 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4918 if (SWIG_arg_fail(4)) SWIG_fail;
4919 }
4920 {
4921 if (!wxPyCheckForApp()) SWIG_fail;
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4924
4925 wxPyEndAllowThreads(__tstate);
4926 if (PyErr_Occurred()) SWIG_fail;
4927 }
4928 {
4929 #if wxUSE_UNICODE
4930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4931 #else
4932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4933 #endif
4934 }
4935 {
4936 if (temp1)
4937 delete arg1;
4938 }
4939 {
4940 if (temp2)
4941 delete arg2;
4942 }
4943 {
4944 if (temp3)
4945 delete arg3;
4946 }
4947 return resultobj;
4948 fail:
4949 {
4950 if (temp1)
4951 delete arg1;
4952 }
4953 {
4954 if (temp2)
4955 delete arg2;
4956 }
4957 {
4958 if (temp3)
4959 delete arg3;
4960 }
4961 return NULL;
4962 }
4963
4964
4965 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj;
4967 wxString *arg1 = 0 ;
4968 wxString *arg2 = 0 ;
4969 int arg3 ;
4970 wxString *arg4 = (wxString *) 0 ;
4971 wxWindow *arg5 = (wxWindow *) NULL ;
4972 int arg6 = (int) -1 ;
4973 int arg7 = (int) -1 ;
4974 bool arg8 = (bool) true ;
4975 int arg9 = (int) 150 ;
4976 int arg10 = (int) 200 ;
4977 wxString result;
4978 bool temp1 = false ;
4979 bool temp2 = false ;
4980 PyObject * obj0 = 0 ;
4981 PyObject * obj1 = 0 ;
4982 PyObject * obj2 = 0 ;
4983 PyObject * obj3 = 0 ;
4984 PyObject * obj4 = 0 ;
4985 PyObject * obj5 = 0 ;
4986 PyObject * obj6 = 0 ;
4987 PyObject * obj7 = 0 ;
4988 PyObject * obj8 = 0 ;
4989 char *kwnames[] = {
4990 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4991 };
4992
4993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4994 {
4995 arg1 = wxString_in_helper(obj0);
4996 if (arg1 == NULL) SWIG_fail;
4997 temp1 = true;
4998 }
4999 {
5000 arg2 = wxString_in_helper(obj1);
5001 if (arg2 == NULL) SWIG_fail;
5002 temp2 = true;
5003 }
5004 {
5005 arg3 = PyList_Size(obj2);
5006 arg4 = wxString_LIST_helper(obj2);
5007 if (arg4 == NULL) SWIG_fail;
5008 }
5009 if (obj3) {
5010 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5011 if (SWIG_arg_fail(5)) SWIG_fail;
5012 }
5013 if (obj4) {
5014 {
5015 arg6 = (int)(SWIG_As_int(obj4));
5016 if (SWIG_arg_fail(6)) SWIG_fail;
5017 }
5018 }
5019 if (obj5) {
5020 {
5021 arg7 = (int)(SWIG_As_int(obj5));
5022 if (SWIG_arg_fail(7)) SWIG_fail;
5023 }
5024 }
5025 if (obj6) {
5026 {
5027 arg8 = (bool)(SWIG_As_bool(obj6));
5028 if (SWIG_arg_fail(8)) SWIG_fail;
5029 }
5030 }
5031 if (obj7) {
5032 {
5033 arg9 = (int)(SWIG_As_int(obj7));
5034 if (SWIG_arg_fail(9)) SWIG_fail;
5035 }
5036 }
5037 if (obj8) {
5038 {
5039 arg10 = (int)(SWIG_As_int(obj8));
5040 if (SWIG_arg_fail(10)) SWIG_fail;
5041 }
5042 }
5043 {
5044 if (!wxPyCheckForApp()) SWIG_fail;
5045 PyThreadState* __tstate = wxPyBeginAllowThreads();
5046 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5047
5048 wxPyEndAllowThreads(__tstate);
5049 if (PyErr_Occurred()) SWIG_fail;
5050 }
5051 {
5052 #if wxUSE_UNICODE
5053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5054 #else
5055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5056 #endif
5057 }
5058 {
5059 if (temp1)
5060 delete arg1;
5061 }
5062 {
5063 if (temp2)
5064 delete arg2;
5065 }
5066 {
5067 if (arg4) delete [] arg4;
5068 }
5069 return resultobj;
5070 fail:
5071 {
5072 if (temp1)
5073 delete arg1;
5074 }
5075 {
5076 if (temp2)
5077 delete arg2;
5078 }
5079 {
5080 if (arg4) delete [] arg4;
5081 }
5082 return NULL;
5083 }
5084
5085
5086 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5087 PyObject *resultobj;
5088 wxString *arg1 = 0 ;
5089 wxString *arg2 = 0 ;
5090 int arg3 ;
5091 wxString *arg4 = (wxString *) 0 ;
5092 wxWindow *arg5 = (wxWindow *) NULL ;
5093 int arg6 = (int) -1 ;
5094 int arg7 = (int) -1 ;
5095 bool arg8 = (bool) true ;
5096 int arg9 = (int) 150 ;
5097 int arg10 = (int) 200 ;
5098 int result;
5099 bool temp1 = false ;
5100 bool temp2 = false ;
5101 PyObject * obj0 = 0 ;
5102 PyObject * obj1 = 0 ;
5103 PyObject * obj2 = 0 ;
5104 PyObject * obj3 = 0 ;
5105 PyObject * obj4 = 0 ;
5106 PyObject * obj5 = 0 ;
5107 PyObject * obj6 = 0 ;
5108 PyObject * obj7 = 0 ;
5109 PyObject * obj8 = 0 ;
5110 char *kwnames[] = {
5111 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5112 };
5113
5114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5115 {
5116 arg1 = wxString_in_helper(obj0);
5117 if (arg1 == NULL) SWIG_fail;
5118 temp1 = true;
5119 }
5120 {
5121 arg2 = wxString_in_helper(obj1);
5122 if (arg2 == NULL) SWIG_fail;
5123 temp2 = true;
5124 }
5125 {
5126 arg3 = PyList_Size(obj2);
5127 arg4 = wxString_LIST_helper(obj2);
5128 if (arg4 == NULL) SWIG_fail;
5129 }
5130 if (obj3) {
5131 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5132 if (SWIG_arg_fail(5)) SWIG_fail;
5133 }
5134 if (obj4) {
5135 {
5136 arg6 = (int)(SWIG_As_int(obj4));
5137 if (SWIG_arg_fail(6)) SWIG_fail;
5138 }
5139 }
5140 if (obj5) {
5141 {
5142 arg7 = (int)(SWIG_As_int(obj5));
5143 if (SWIG_arg_fail(7)) SWIG_fail;
5144 }
5145 }
5146 if (obj6) {
5147 {
5148 arg8 = (bool)(SWIG_As_bool(obj6));
5149 if (SWIG_arg_fail(8)) SWIG_fail;
5150 }
5151 }
5152 if (obj7) {
5153 {
5154 arg9 = (int)(SWIG_As_int(obj7));
5155 if (SWIG_arg_fail(9)) SWIG_fail;
5156 }
5157 }
5158 if (obj8) {
5159 {
5160 arg10 = (int)(SWIG_As_int(obj8));
5161 if (SWIG_arg_fail(10)) SWIG_fail;
5162 }
5163 }
5164 {
5165 if (!wxPyCheckForApp()) SWIG_fail;
5166 PyThreadState* __tstate = wxPyBeginAllowThreads();
5167 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5168
5169 wxPyEndAllowThreads(__tstate);
5170 if (PyErr_Occurred()) SWIG_fail;
5171 }
5172 {
5173 resultobj = SWIG_From_int((int)(result));
5174 }
5175 {
5176 if (temp1)
5177 delete arg1;
5178 }
5179 {
5180 if (temp2)
5181 delete arg2;
5182 }
5183 {
5184 if (arg4) delete [] arg4;
5185 }
5186 return resultobj;
5187 fail:
5188 {
5189 if (temp1)
5190 delete arg1;
5191 }
5192 {
5193 if (temp2)
5194 delete arg2;
5195 }
5196 {
5197 if (arg4) delete [] arg4;
5198 }
5199 return NULL;
5200 }
5201
5202
5203 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5204 PyObject *resultobj;
5205 wxString *arg1 = 0 ;
5206 wxString const &arg2_defvalue = wxPyEmptyString ;
5207 wxString *arg2 = (wxString *) &arg2_defvalue ;
5208 int arg3 = (int) wxOK|wxCENTRE ;
5209 wxWindow *arg4 = (wxWindow *) NULL ;
5210 int arg5 = (int) -1 ;
5211 int arg6 = (int) -1 ;
5212 int result;
5213 bool temp1 = false ;
5214 bool temp2 = false ;
5215 PyObject * obj0 = 0 ;
5216 PyObject * obj1 = 0 ;
5217 PyObject * obj2 = 0 ;
5218 PyObject * obj3 = 0 ;
5219 PyObject * obj4 = 0 ;
5220 PyObject * obj5 = 0 ;
5221 char *kwnames[] = {
5222 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5223 };
5224
5225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5226 {
5227 arg1 = wxString_in_helper(obj0);
5228 if (arg1 == NULL) SWIG_fail;
5229 temp1 = true;
5230 }
5231 if (obj1) {
5232 {
5233 arg2 = wxString_in_helper(obj1);
5234 if (arg2 == NULL) SWIG_fail;
5235 temp2 = true;
5236 }
5237 }
5238 if (obj2) {
5239 {
5240 arg3 = (int)(SWIG_As_int(obj2));
5241 if (SWIG_arg_fail(3)) SWIG_fail;
5242 }
5243 }
5244 if (obj3) {
5245 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5246 if (SWIG_arg_fail(4)) SWIG_fail;
5247 }
5248 if (obj4) {
5249 {
5250 arg5 = (int)(SWIG_As_int(obj4));
5251 if (SWIG_arg_fail(5)) SWIG_fail;
5252 }
5253 }
5254 if (obj5) {
5255 {
5256 arg6 = (int)(SWIG_As_int(obj5));
5257 if (SWIG_arg_fail(6)) SWIG_fail;
5258 }
5259 }
5260 {
5261 if (!wxPyCheckForApp()) SWIG_fail;
5262 PyThreadState* __tstate = wxPyBeginAllowThreads();
5263 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5264
5265 wxPyEndAllowThreads(__tstate);
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 {
5269 resultobj = SWIG_From_int((int)(result));
5270 }
5271 {
5272 if (temp1)
5273 delete arg1;
5274 }
5275 {
5276 if (temp2)
5277 delete arg2;
5278 }
5279 return resultobj;
5280 fail:
5281 {
5282 if (temp1)
5283 delete arg1;
5284 }
5285 {
5286 if (temp2)
5287 delete arg2;
5288 }
5289 return NULL;
5290 }
5291
5292
5293 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5294 PyObject *resultobj;
5295 wxString *arg1 = 0 ;
5296 wxString *arg2 = 0 ;
5297 wxString *arg3 = 0 ;
5298 long arg4 ;
5299 long arg5 = (long) 0 ;
5300 long arg6 = (long) 100 ;
5301 wxWindow *arg7 = (wxWindow *) NULL ;
5302 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5303 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5304 long result;
5305 bool temp1 = false ;
5306 bool temp2 = false ;
5307 bool temp3 = false ;
5308 wxPoint temp8 ;
5309 PyObject * obj0 = 0 ;
5310 PyObject * obj1 = 0 ;
5311 PyObject * obj2 = 0 ;
5312 PyObject * obj3 = 0 ;
5313 PyObject * obj4 = 0 ;
5314 PyObject * obj5 = 0 ;
5315 PyObject * obj6 = 0 ;
5316 PyObject * obj7 = 0 ;
5317 char *kwnames[] = {
5318 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5319 };
5320
5321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5322 {
5323 arg1 = wxString_in_helper(obj0);
5324 if (arg1 == NULL) SWIG_fail;
5325 temp1 = true;
5326 }
5327 {
5328 arg2 = wxString_in_helper(obj1);
5329 if (arg2 == NULL) SWIG_fail;
5330 temp2 = true;
5331 }
5332 {
5333 arg3 = wxString_in_helper(obj2);
5334 if (arg3 == NULL) SWIG_fail;
5335 temp3 = true;
5336 }
5337 {
5338 arg4 = (long)(SWIG_As_long(obj3));
5339 if (SWIG_arg_fail(4)) SWIG_fail;
5340 }
5341 if (obj4) {
5342 {
5343 arg5 = (long)(SWIG_As_long(obj4));
5344 if (SWIG_arg_fail(5)) SWIG_fail;
5345 }
5346 }
5347 if (obj5) {
5348 {
5349 arg6 = (long)(SWIG_As_long(obj5));
5350 if (SWIG_arg_fail(6)) SWIG_fail;
5351 }
5352 }
5353 if (obj6) {
5354 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5355 if (SWIG_arg_fail(7)) SWIG_fail;
5356 }
5357 if (obj7) {
5358 {
5359 arg8 = &temp8;
5360 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5361 }
5362 }
5363 {
5364 if (!wxPyCheckForApp()) SWIG_fail;
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 resultobj = SWIG_From_long((long)(result));
5373 }
5374 {
5375 if (temp1)
5376 delete arg1;
5377 }
5378 {
5379 if (temp2)
5380 delete arg2;
5381 }
5382 {
5383 if (temp3)
5384 delete arg3;
5385 }
5386 return resultobj;
5387 fail:
5388 {
5389 if (temp1)
5390 delete arg1;
5391 }
5392 {
5393 if (temp2)
5394 delete arg2;
5395 }
5396 {
5397 if (temp3)
5398 delete arg3;
5399 }
5400 return NULL;
5401 }
5402
5403
5404 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 bool result;
5407 char *kwnames[] = {
5408 NULL
5409 };
5410
5411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5412 {
5413 if (!wxPyCheckForApp()) SWIG_fail;
5414 PyThreadState* __tstate = wxPyBeginAllowThreads();
5415 result = (bool)wxColourDisplay();
5416
5417 wxPyEndAllowThreads(__tstate);
5418 if (PyErr_Occurred()) SWIG_fail;
5419 }
5420 {
5421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5422 }
5423 return resultobj;
5424 fail:
5425 return NULL;
5426 }
5427
5428
5429 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5430 PyObject *resultobj;
5431 int result;
5432 char *kwnames[] = {
5433 NULL
5434 };
5435
5436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5437 {
5438 if (!wxPyCheckForApp()) SWIG_fail;
5439 PyThreadState* __tstate = wxPyBeginAllowThreads();
5440 result = (int)wxDisplayDepth();
5441
5442 wxPyEndAllowThreads(__tstate);
5443 if (PyErr_Occurred()) SWIG_fail;
5444 }
5445 {
5446 resultobj = SWIG_From_int((int)(result));
5447 }
5448 return resultobj;
5449 fail:
5450 return NULL;
5451 }
5452
5453
5454 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5455 PyObject *resultobj;
5456 int result;
5457 char *kwnames[] = {
5458 NULL
5459 };
5460
5461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5462 {
5463 if (!wxPyCheckForApp()) SWIG_fail;
5464 PyThreadState* __tstate = wxPyBeginAllowThreads();
5465 result = (int)wxGetDisplayDepth();
5466
5467 wxPyEndAllowThreads(__tstate);
5468 if (PyErr_Occurred()) SWIG_fail;
5469 }
5470 {
5471 resultobj = SWIG_From_int((int)(result));
5472 }
5473 return resultobj;
5474 fail:
5475 return NULL;
5476 }
5477
5478
5479 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5480 PyObject *resultobj;
5481 int *arg1 = (int *) 0 ;
5482 int *arg2 = (int *) 0 ;
5483 int temp1 ;
5484 int res1 = 0 ;
5485 int temp2 ;
5486 int res2 = 0 ;
5487 char *kwnames[] = {
5488 NULL
5489 };
5490
5491 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5492 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5494 {
5495 if (!wxPyCheckForApp()) SWIG_fail;
5496 PyThreadState* __tstate = wxPyBeginAllowThreads();
5497 wxDisplaySize(arg1,arg2);
5498
5499 wxPyEndAllowThreads(__tstate);
5500 if (PyErr_Occurred()) SWIG_fail;
5501 }
5502 Py_INCREF(Py_None); resultobj = Py_None;
5503 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5504 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5505 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5506 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5514 PyObject *resultobj;
5515 wxSize result;
5516 char *kwnames[] = {
5517 NULL
5518 };
5519
5520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5521 {
5522 if (!wxPyCheckForApp()) SWIG_fail;
5523 PyThreadState* __tstate = wxPyBeginAllowThreads();
5524 result = wxGetDisplaySize();
5525
5526 wxPyEndAllowThreads(__tstate);
5527 if (PyErr_Occurred()) SWIG_fail;
5528 }
5529 {
5530 wxSize * resultptr;
5531 resultptr = new wxSize((wxSize &)(result));
5532 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj;
5542 int *arg1 = (int *) 0 ;
5543 int *arg2 = (int *) 0 ;
5544 int temp1 ;
5545 int res1 = 0 ;
5546 int temp2 ;
5547 int res2 = 0 ;
5548 char *kwnames[] = {
5549 NULL
5550 };
5551
5552 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5553 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5555 {
5556 if (!wxPyCheckForApp()) SWIG_fail;
5557 PyThreadState* __tstate = wxPyBeginAllowThreads();
5558 wxDisplaySizeMM(arg1,arg2);
5559
5560 wxPyEndAllowThreads(__tstate);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 Py_INCREF(Py_None); resultobj = Py_None;
5564 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5565 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5566 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5567 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5568 return resultobj;
5569 fail:
5570 return NULL;
5571 }
5572
5573
5574 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5575 PyObject *resultobj;
5576 wxSize result;
5577 char *kwnames[] = {
5578 NULL
5579 };
5580
5581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5582 {
5583 if (!wxPyCheckForApp()) SWIG_fail;
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 result = wxGetDisplaySizeMM();
5586
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 {
5591 wxSize * resultptr;
5592 resultptr = new wxSize((wxSize &)(result));
5593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5594 }
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj;
5603 int *arg1 = (int *) 0 ;
5604 int *arg2 = (int *) 0 ;
5605 int *arg3 = (int *) 0 ;
5606 int *arg4 = (int *) 0 ;
5607 int temp1 ;
5608 int res1 = 0 ;
5609 int temp2 ;
5610 int res2 = 0 ;
5611 int temp3 ;
5612 int res3 = 0 ;
5613 int temp4 ;
5614 int res4 = 0 ;
5615 char *kwnames[] = {
5616 NULL
5617 };
5618
5619 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5620 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5621 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5622 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5624 {
5625 if (!wxPyCheckForApp()) SWIG_fail;
5626 PyThreadState* __tstate = wxPyBeginAllowThreads();
5627 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5628
5629 wxPyEndAllowThreads(__tstate);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 Py_INCREF(Py_None); resultobj = Py_None;
5633 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5634 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5635 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5636 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5637 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5638 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5639 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5640 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5641 return resultobj;
5642 fail:
5643 return NULL;
5644 }
5645
5646
5647 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5648 PyObject *resultobj;
5649 wxRect result;
5650 char *kwnames[] = {
5651 NULL
5652 };
5653
5654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5655 {
5656 if (!wxPyCheckForApp()) SWIG_fail;
5657 PyThreadState* __tstate = wxPyBeginAllowThreads();
5658 result = wxGetClientDisplayRect();
5659
5660 wxPyEndAllowThreads(__tstate);
5661 if (PyErr_Occurred()) SWIG_fail;
5662 }
5663 {
5664 wxRect * resultptr;
5665 resultptr = new wxRect((wxRect &)(result));
5666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5667 }
5668 return resultobj;
5669 fail:
5670 return NULL;
5671 }
5672
5673
5674 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5675 PyObject *resultobj;
5676 wxCursor *arg1 = 0 ;
5677 PyObject * obj0 = 0 ;
5678 char *kwnames[] = {
5679 (char *) "cursor", NULL
5680 };
5681
5682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5683 {
5684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5685 if (SWIG_arg_fail(1)) SWIG_fail;
5686 if (arg1 == NULL) {
5687 SWIG_null_ref("wxCursor");
5688 }
5689 if (SWIG_arg_fail(1)) SWIG_fail;
5690 }
5691 {
5692 if (!wxPyCheckForApp()) SWIG_fail;
5693 PyThreadState* __tstate = wxPyBeginAllowThreads();
5694 wxSetCursor(*arg1);
5695
5696 wxPyEndAllowThreads(__tstate);
5697 if (PyErr_Occurred()) SWIG_fail;
5698 }
5699 Py_INCREF(Py_None); resultobj = Py_None;
5700 return resultobj;
5701 fail:
5702 return NULL;
5703 }
5704
5705
5706 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5707 PyObject *resultobj;
5708 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5709 PyObject * obj0 = 0 ;
5710 char *kwnames[] = {
5711 (char *) "cursor", NULL
5712 };
5713
5714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5715 if (obj0) {
5716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5717 if (SWIG_arg_fail(1)) SWIG_fail;
5718 }
5719 {
5720 if (!wxPyCheckForApp()) SWIG_fail;
5721 PyThreadState* __tstate = wxPyBeginAllowThreads();
5722 wxBeginBusyCursor(arg1);
5723
5724 wxPyEndAllowThreads(__tstate);
5725 if (PyErr_Occurred()) SWIG_fail;
5726 }
5727 Py_INCREF(Py_None); resultobj = Py_None;
5728 return resultobj;
5729 fail:
5730 return NULL;
5731 }
5732
5733
5734 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5735 PyObject *resultobj;
5736 wxWindow *result;
5737 char *kwnames[] = {
5738 NULL
5739 };
5740
5741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5742 {
5743 if (!wxPyCheckForApp()) SWIG_fail;
5744 PyThreadState* __tstate = wxPyBeginAllowThreads();
5745 result = (wxWindow *)wxGetActiveWindow();
5746
5747 wxPyEndAllowThreads(__tstate);
5748 if (PyErr_Occurred()) SWIG_fail;
5749 }
5750 {
5751 resultobj = wxPyMake_wxObject(result, 0);
5752 }
5753 return resultobj;
5754 fail:
5755 return NULL;
5756 }
5757
5758
5759 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5760 PyObject *resultobj;
5761 wxPoint *arg1 = 0 ;
5762 wxWindow *result;
5763 wxPoint temp1 ;
5764 PyObject * obj0 = 0 ;
5765 char *kwnames[] = {
5766 (char *) "pt", NULL
5767 };
5768
5769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5770 {
5771 arg1 = &temp1;
5772 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5773 }
5774 {
5775 if (!wxPyCheckForApp()) SWIG_fail;
5776 PyThreadState* __tstate = wxPyBeginAllowThreads();
5777 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5778
5779 wxPyEndAllowThreads(__tstate);
5780 if (PyErr_Occurred()) SWIG_fail;
5781 }
5782 {
5783 resultobj = wxPyMake_wxObject(result, 0);
5784 }
5785 return resultobj;
5786 fail:
5787 return NULL;
5788 }
5789
5790
5791 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5792 PyObject *resultobj;
5793 wxPoint *arg1 = 0 ;
5794 wxWindow *result;
5795 wxPoint temp1 ;
5796 PyObject * obj0 = 0 ;
5797 char *kwnames[] = {
5798 (char *) "pt", NULL
5799 };
5800
5801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5802 {
5803 arg1 = &temp1;
5804 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5805 }
5806 {
5807 if (!wxPyCheckForApp()) SWIG_fail;
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5810
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 {
5815 resultobj = wxPyMake_wxObject(result, 0);
5816 }
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5824 PyObject *resultobj;
5825 wxWindow *arg1 = (wxWindow *) 0 ;
5826 wxWindow *result;
5827 PyObject * obj0 = 0 ;
5828 char *kwnames[] = {
5829 (char *) "win", NULL
5830 };
5831
5832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5834 if (SWIG_arg_fail(1)) SWIG_fail;
5835 {
5836 if (!wxPyCheckForApp()) SWIG_fail;
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 result = (wxWindow *)wxGetTopLevelParent(arg1);
5839
5840 wxPyEndAllowThreads(__tstate);
5841 if (PyErr_Occurred()) SWIG_fail;
5842 }
5843 {
5844 resultobj = wxPyMake_wxObject(result, 0);
5845 }
5846 return resultobj;
5847 fail:
5848 return NULL;
5849 }
5850
5851
5852 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5853 PyObject *resultobj;
5854 wxKeyCode arg1 ;
5855 bool result;
5856 PyObject * obj0 = 0 ;
5857 char *kwnames[] = {
5858 (char *) "key", NULL
5859 };
5860
5861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5862 {
5863 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5864 if (SWIG_arg_fail(1)) SWIG_fail;
5865 }
5866 {
5867 if (!wxPyCheckForApp()) SWIG_fail;
5868 PyThreadState* __tstate = wxPyBeginAllowThreads();
5869 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5870
5871 wxPyEndAllowThreads(__tstate);
5872 if (PyErr_Occurred()) SWIG_fail;
5873 }
5874 {
5875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5876 }
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj;
5885 char *kwnames[] = {
5886 NULL
5887 };
5888
5889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5890 {
5891 if (!wxPyCheckForApp()) SWIG_fail;
5892 PyThreadState* __tstate = wxPyBeginAllowThreads();
5893 wxWakeUpMainThread();
5894
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 Py_INCREF(Py_None); resultobj = Py_None;
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5906 PyObject *resultobj;
5907 char *kwnames[] = {
5908 NULL
5909 };
5910
5911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5912 {
5913 if (!wxPyCheckForApp()) SWIG_fail;
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 wxMutexGuiEnter();
5916
5917 wxPyEndAllowThreads(__tstate);
5918 if (PyErr_Occurred()) SWIG_fail;
5919 }
5920 Py_INCREF(Py_None); resultobj = Py_None;
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj;
5929 char *kwnames[] = {
5930 NULL
5931 };
5932
5933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5934 {
5935 if (!wxPyCheckForApp()) SWIG_fail;
5936 PyThreadState* __tstate = wxPyBeginAllowThreads();
5937 wxMutexGuiLeave();
5938
5939 wxPyEndAllowThreads(__tstate);
5940 if (PyErr_Occurred()) SWIG_fail;
5941 }
5942 Py_INCREF(Py_None); resultobj = Py_None;
5943 return resultobj;
5944 fail:
5945 return NULL;
5946 }
5947
5948
5949 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5950 PyObject *resultobj;
5951 wxMutexGuiLocker *result;
5952 char *kwnames[] = {
5953 NULL
5954 };
5955
5956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5957 {
5958 if (!wxPyCheckForApp()) SWIG_fail;
5959 PyThreadState* __tstate = wxPyBeginAllowThreads();
5960 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5961
5962 wxPyEndAllowThreads(__tstate);
5963 if (PyErr_Occurred()) SWIG_fail;
5964 }
5965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5966 return resultobj;
5967 fail:
5968 return NULL;
5969 }
5970
5971
5972 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5973 PyObject *resultobj;
5974 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5975 PyObject * obj0 = 0 ;
5976 char *kwnames[] = {
5977 (char *) "self", NULL
5978 };
5979
5980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5982 if (SWIG_arg_fail(1)) SWIG_fail;
5983 {
5984 PyThreadState* __tstate = wxPyBeginAllowThreads();
5985 delete arg1;
5986
5987 wxPyEndAllowThreads(__tstate);
5988 if (PyErr_Occurred()) SWIG_fail;
5989 }
5990 Py_INCREF(Py_None); resultobj = Py_None;
5991 return resultobj;
5992 fail:
5993 return NULL;
5994 }
5995
5996
5997 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
5998 PyObject *obj;
5999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6000 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6001 Py_INCREF(obj);
6002 return Py_BuildValue((char *)"");
6003 }
6004 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6005 PyObject *resultobj;
6006 bool result;
6007 char *kwnames[] = {
6008 NULL
6009 };
6010
6011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6012 {
6013 PyThreadState* __tstate = wxPyBeginAllowThreads();
6014 result = (bool)wxThread_IsMain();
6015
6016 wxPyEndAllowThreads(__tstate);
6017 if (PyErr_Occurred()) SWIG_fail;
6018 }
6019 {
6020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6021 }
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6029 PyObject *resultobj;
6030 wxString *arg1 = 0 ;
6031 wxToolTip *result;
6032 bool temp1 = false ;
6033 PyObject * obj0 = 0 ;
6034 char *kwnames[] = {
6035 (char *) "tip", NULL
6036 };
6037
6038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6039 {
6040 arg1 = wxString_in_helper(obj0);
6041 if (arg1 == NULL) SWIG_fail;
6042 temp1 = true;
6043 }
6044 {
6045 if (!wxPyCheckForApp()) SWIG_fail;
6046 PyThreadState* __tstate = wxPyBeginAllowThreads();
6047 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6048
6049 wxPyEndAllowThreads(__tstate);
6050 if (PyErr_Occurred()) SWIG_fail;
6051 }
6052 {
6053 resultobj = wxPyMake_wxObject(result, 1);
6054 }
6055 {
6056 if (temp1)
6057 delete arg1;
6058 }
6059 return resultobj;
6060 fail:
6061 {
6062 if (temp1)
6063 delete arg1;
6064 }
6065 return NULL;
6066 }
6067
6068
6069 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6070 PyObject *resultobj;
6071 wxToolTip *arg1 = (wxToolTip *) 0 ;
6072 wxString *arg2 = 0 ;
6073 bool temp2 = false ;
6074 PyObject * obj0 = 0 ;
6075 PyObject * obj1 = 0 ;
6076 char *kwnames[] = {
6077 (char *) "self",(char *) "tip", NULL
6078 };
6079
6080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6082 if (SWIG_arg_fail(1)) SWIG_fail;
6083 {
6084 arg2 = wxString_in_helper(obj1);
6085 if (arg2 == NULL) SWIG_fail;
6086 temp2 = true;
6087 }
6088 {
6089 PyThreadState* __tstate = wxPyBeginAllowThreads();
6090 (arg1)->SetTip((wxString const &)*arg2);
6091
6092 wxPyEndAllowThreads(__tstate);
6093 if (PyErr_Occurred()) SWIG_fail;
6094 }
6095 Py_INCREF(Py_None); resultobj = Py_None;
6096 {
6097 if (temp2)
6098 delete arg2;
6099 }
6100 return resultobj;
6101 fail:
6102 {
6103 if (temp2)
6104 delete arg2;
6105 }
6106 return NULL;
6107 }
6108
6109
6110 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj;
6112 wxToolTip *arg1 = (wxToolTip *) 0 ;
6113 wxString result;
6114 PyObject * obj0 = 0 ;
6115 char *kwnames[] = {
6116 (char *) "self", NULL
6117 };
6118
6119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6121 if (SWIG_arg_fail(1)) SWIG_fail;
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (arg1)->GetTip();
6125
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 {
6130 #if wxUSE_UNICODE
6131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6132 #else
6133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6134 #endif
6135 }
6136 return resultobj;
6137 fail:
6138 return NULL;
6139 }
6140
6141
6142 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6143 PyObject *resultobj;
6144 wxToolTip *arg1 = (wxToolTip *) 0 ;
6145 wxWindow *result;
6146 PyObject * obj0 = 0 ;
6147 char *kwnames[] = {
6148 (char *) "self", NULL
6149 };
6150
6151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6153 if (SWIG_arg_fail(1)) SWIG_fail;
6154 {
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 result = (wxWindow *)(arg1)->GetWindow();
6157
6158 wxPyEndAllowThreads(__tstate);
6159 if (PyErr_Occurred()) SWIG_fail;
6160 }
6161 {
6162 resultobj = wxPyMake_wxObject(result, 0);
6163 }
6164 return resultobj;
6165 fail:
6166 return NULL;
6167 }
6168
6169
6170 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6171 PyObject *resultobj;
6172 bool arg1 ;
6173 PyObject * obj0 = 0 ;
6174 char *kwnames[] = {
6175 (char *) "flag", NULL
6176 };
6177
6178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6179 {
6180 arg1 = (bool)(SWIG_As_bool(obj0));
6181 if (SWIG_arg_fail(1)) SWIG_fail;
6182 }
6183 {
6184 PyThreadState* __tstate = wxPyBeginAllowThreads();
6185 wxToolTip::Enable(arg1);
6186
6187 wxPyEndAllowThreads(__tstate);
6188 if (PyErr_Occurred()) SWIG_fail;
6189 }
6190 Py_INCREF(Py_None); resultobj = Py_None;
6191 return resultobj;
6192 fail:
6193 return NULL;
6194 }
6195
6196
6197 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6198 PyObject *resultobj;
6199 long arg1 ;
6200 PyObject * obj0 = 0 ;
6201 char *kwnames[] = {
6202 (char *) "milliseconds", NULL
6203 };
6204
6205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6206 {
6207 arg1 = (long)(SWIG_As_long(obj0));
6208 if (SWIG_arg_fail(1)) SWIG_fail;
6209 }
6210 {
6211 PyThreadState* __tstate = wxPyBeginAllowThreads();
6212 wxToolTip::SetDelay(arg1);
6213
6214 wxPyEndAllowThreads(__tstate);
6215 if (PyErr_Occurred()) SWIG_fail;
6216 }
6217 Py_INCREF(Py_None); resultobj = Py_None;
6218 return resultobj;
6219 fail:
6220 return NULL;
6221 }
6222
6223
6224 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6225 PyObject *obj;
6226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6227 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6228 Py_INCREF(obj);
6229 return Py_BuildValue((char *)"");
6230 }
6231 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6232 PyObject *resultobj;
6233 wxWindow *arg1 = (wxWindow *) 0 ;
6234 wxSize *arg2 = 0 ;
6235 wxCaret *result;
6236 wxSize temp2 ;
6237 PyObject * obj0 = 0 ;
6238 PyObject * obj1 = 0 ;
6239 char *kwnames[] = {
6240 (char *) "window",(char *) "size", NULL
6241 };
6242
6243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6245 if (SWIG_arg_fail(1)) SWIG_fail;
6246 {
6247 arg2 = &temp2;
6248 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6249 }
6250 {
6251 if (!wxPyCheckForApp()) SWIG_fail;
6252 PyThreadState* __tstate = wxPyBeginAllowThreads();
6253 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6254
6255 wxPyEndAllowThreads(__tstate);
6256 if (PyErr_Occurred()) SWIG_fail;
6257 }
6258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj;
6267 wxCaret *arg1 = (wxCaret *) 0 ;
6268 PyObject * obj0 = 0 ;
6269 char *kwnames[] = {
6270 (char *) "self", NULL
6271 };
6272
6273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6275 if (SWIG_arg_fail(1)) SWIG_fail;
6276 {
6277 PyThreadState* __tstate = wxPyBeginAllowThreads();
6278 delete arg1;
6279
6280 wxPyEndAllowThreads(__tstate);
6281 if (PyErr_Occurred()) SWIG_fail;
6282 }
6283 Py_INCREF(Py_None); resultobj = Py_None;
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj;
6292 wxCaret *arg1 = (wxCaret *) 0 ;
6293 bool result;
6294 PyObject * obj0 = 0 ;
6295 char *kwnames[] = {
6296 (char *) "self", NULL
6297 };
6298
6299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6301 if (SWIG_arg_fail(1)) SWIG_fail;
6302 {
6303 PyThreadState* __tstate = wxPyBeginAllowThreads();
6304 result = (bool)(arg1)->IsOk();
6305
6306 wxPyEndAllowThreads(__tstate);
6307 if (PyErr_Occurred()) SWIG_fail;
6308 }
6309 {
6310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6311 }
6312 return resultobj;
6313 fail:
6314 return NULL;
6315 }
6316
6317
6318 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6319 PyObject *resultobj;
6320 wxCaret *arg1 = (wxCaret *) 0 ;
6321 bool result;
6322 PyObject * obj0 = 0 ;
6323 char *kwnames[] = {
6324 (char *) "self", NULL
6325 };
6326
6327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6329 if (SWIG_arg_fail(1)) SWIG_fail;
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 result = (bool)(arg1)->IsVisible();
6333
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 {
6338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6339 }
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6347 PyObject *resultobj;
6348 wxCaret *arg1 = (wxCaret *) 0 ;
6349 wxPoint result;
6350 PyObject * obj0 = 0 ;
6351 char *kwnames[] = {
6352 (char *) "self", NULL
6353 };
6354
6355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6357 if (SWIG_arg_fail(1)) SWIG_fail;
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 result = (arg1)->GetPosition();
6361
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 {
6366 wxPoint * resultptr;
6367 resultptr = new wxPoint((wxPoint &)(result));
6368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6369 }
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxCaret *arg1 = (wxCaret *) 0 ;
6379 int *arg2 = (int *) 0 ;
6380 int *arg3 = (int *) 0 ;
6381 int temp2 ;
6382 int res2 = 0 ;
6383 int temp3 ;
6384 int res3 = 0 ;
6385 PyObject * obj0 = 0 ;
6386 char *kwnames[] = {
6387 (char *) "self", NULL
6388 };
6389
6390 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6391 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6394 if (SWIG_arg_fail(1)) SWIG_fail;
6395 {
6396 PyThreadState* __tstate = wxPyBeginAllowThreads();
6397 (arg1)->GetPosition(arg2,arg3);
6398
6399 wxPyEndAllowThreads(__tstate);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 Py_INCREF(Py_None); resultobj = Py_None;
6403 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6404 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6405 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6406 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6407 return resultobj;
6408 fail:
6409 return NULL;
6410 }
6411
6412
6413 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj;
6415 wxCaret *arg1 = (wxCaret *) 0 ;
6416 wxSize result;
6417 PyObject * obj0 = 0 ;
6418 char *kwnames[] = {
6419 (char *) "self", NULL
6420 };
6421
6422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6424 if (SWIG_arg_fail(1)) SWIG_fail;
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 result = (arg1)->GetSize();
6428
6429 wxPyEndAllowThreads(__tstate);
6430 if (PyErr_Occurred()) SWIG_fail;
6431 }
6432 {
6433 wxSize * resultptr;
6434 resultptr = new wxSize((wxSize &)(result));
6435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6436 }
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6444 PyObject *resultobj;
6445 wxCaret *arg1 = (wxCaret *) 0 ;
6446 int *arg2 = (int *) 0 ;
6447 int *arg3 = (int *) 0 ;
6448 int temp2 ;
6449 int res2 = 0 ;
6450 int temp3 ;
6451 int res3 = 0 ;
6452 PyObject * obj0 = 0 ;
6453 char *kwnames[] = {
6454 (char *) "self", NULL
6455 };
6456
6457 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6458 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6461 if (SWIG_arg_fail(1)) SWIG_fail;
6462 {
6463 PyThreadState* __tstate = wxPyBeginAllowThreads();
6464 (arg1)->GetSize(arg2,arg3);
6465
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 Py_INCREF(Py_None); resultobj = Py_None;
6470 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6471 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6472 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6473 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6474 return resultobj;
6475 fail:
6476 return NULL;
6477 }
6478
6479
6480 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6481 PyObject *resultobj;
6482 wxCaret *arg1 = (wxCaret *) 0 ;
6483 wxWindow *result;
6484 PyObject * obj0 = 0 ;
6485 char *kwnames[] = {
6486 (char *) "self", NULL
6487 };
6488
6489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6491 if (SWIG_arg_fail(1)) SWIG_fail;
6492 {
6493 PyThreadState* __tstate = wxPyBeginAllowThreads();
6494 result = (wxWindow *)(arg1)->GetWindow();
6495
6496 wxPyEndAllowThreads(__tstate);
6497 if (PyErr_Occurred()) SWIG_fail;
6498 }
6499 {
6500 resultobj = wxPyMake_wxObject(result, 0);
6501 }
6502 return resultobj;
6503 fail:
6504 return NULL;
6505 }
6506
6507
6508 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6509 PyObject *resultobj;
6510 wxCaret *arg1 = (wxCaret *) 0 ;
6511 int arg2 ;
6512 int arg3 ;
6513 PyObject * obj0 = 0 ;
6514 PyObject * obj1 = 0 ;
6515 PyObject * obj2 = 0 ;
6516 char *kwnames[] = {
6517 (char *) "self",(char *) "x",(char *) "y", NULL
6518 };
6519
6520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6522 if (SWIG_arg_fail(1)) SWIG_fail;
6523 {
6524 arg2 = (int)(SWIG_As_int(obj1));
6525 if (SWIG_arg_fail(2)) SWIG_fail;
6526 }
6527 {
6528 arg3 = (int)(SWIG_As_int(obj2));
6529 if (SWIG_arg_fail(3)) SWIG_fail;
6530 }
6531 {
6532 PyThreadState* __tstate = wxPyBeginAllowThreads();
6533 (arg1)->Move(arg2,arg3);
6534
6535 wxPyEndAllowThreads(__tstate);
6536 if (PyErr_Occurred()) SWIG_fail;
6537 }
6538 Py_INCREF(Py_None); resultobj = Py_None;
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6546 PyObject *resultobj;
6547 wxCaret *arg1 = (wxCaret *) 0 ;
6548 wxPoint *arg2 = 0 ;
6549 wxPoint temp2 ;
6550 PyObject * obj0 = 0 ;
6551 PyObject * obj1 = 0 ;
6552 char *kwnames[] = {
6553 (char *) "self",(char *) "pt", NULL
6554 };
6555
6556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6558 if (SWIG_arg_fail(1)) SWIG_fail;
6559 {
6560 arg2 = &temp2;
6561 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6562 }
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 (arg1)->Move((wxPoint const &)*arg2);
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 Py_INCREF(Py_None); resultobj = Py_None;
6571 return resultobj;
6572 fail:
6573 return NULL;
6574 }
6575
6576
6577 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6578 PyObject *resultobj;
6579 wxCaret *arg1 = (wxCaret *) 0 ;
6580 int arg2 ;
6581 int arg3 ;
6582 PyObject * obj0 = 0 ;
6583 PyObject * obj1 = 0 ;
6584 PyObject * obj2 = 0 ;
6585 char *kwnames[] = {
6586 (char *) "self",(char *) "width",(char *) "height", NULL
6587 };
6588
6589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6591 if (SWIG_arg_fail(1)) SWIG_fail;
6592 {
6593 arg2 = (int)(SWIG_As_int(obj1));
6594 if (SWIG_arg_fail(2)) SWIG_fail;
6595 }
6596 {
6597 arg3 = (int)(SWIG_As_int(obj2));
6598 if (SWIG_arg_fail(3)) SWIG_fail;
6599 }
6600 {
6601 PyThreadState* __tstate = wxPyBeginAllowThreads();
6602 (arg1)->SetSize(arg2,arg3);
6603
6604 wxPyEndAllowThreads(__tstate);
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 Py_INCREF(Py_None); resultobj = Py_None;
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj;
6616 wxCaret *arg1 = (wxCaret *) 0 ;
6617 wxSize *arg2 = 0 ;
6618 wxSize temp2 ;
6619 PyObject * obj0 = 0 ;
6620 PyObject * obj1 = 0 ;
6621 char *kwnames[] = {
6622 (char *) "self",(char *) "size", NULL
6623 };
6624
6625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6627 if (SWIG_arg_fail(1)) SWIG_fail;
6628 {
6629 arg2 = &temp2;
6630 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6631 }
6632 {
6633 PyThreadState* __tstate = wxPyBeginAllowThreads();
6634 (arg1)->SetSize((wxSize const &)*arg2);
6635
6636 wxPyEndAllowThreads(__tstate);
6637 if (PyErr_Occurred()) SWIG_fail;
6638 }
6639 Py_INCREF(Py_None); resultobj = Py_None;
6640 return resultobj;
6641 fail:
6642 return NULL;
6643 }
6644
6645
6646 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6647 PyObject *resultobj;
6648 wxCaret *arg1 = (wxCaret *) 0 ;
6649 int arg2 = (int) true ;
6650 PyObject * obj0 = 0 ;
6651 PyObject * obj1 = 0 ;
6652 char *kwnames[] = {
6653 (char *) "self",(char *) "show", NULL
6654 };
6655
6656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6658 if (SWIG_arg_fail(1)) SWIG_fail;
6659 if (obj1) {
6660 {
6661 arg2 = (int)(SWIG_As_int(obj1));
6662 if (SWIG_arg_fail(2)) SWIG_fail;
6663 }
6664 }
6665 {
6666 PyThreadState* __tstate = wxPyBeginAllowThreads();
6667 (arg1)->Show(arg2);
6668
6669 wxPyEndAllowThreads(__tstate);
6670 if (PyErr_Occurred()) SWIG_fail;
6671 }
6672 Py_INCREF(Py_None); resultobj = Py_None;
6673 return resultobj;
6674 fail:
6675 return NULL;
6676 }
6677
6678
6679 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj;
6681 wxCaret *arg1 = (wxCaret *) 0 ;
6682 PyObject * obj0 = 0 ;
6683 char *kwnames[] = {
6684 (char *) "self", NULL
6685 };
6686
6687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6689 if (SWIG_arg_fail(1)) SWIG_fail;
6690 {
6691 PyThreadState* __tstate = wxPyBeginAllowThreads();
6692 (arg1)->Hide();
6693
6694 wxPyEndAllowThreads(__tstate);
6695 if (PyErr_Occurred()) SWIG_fail;
6696 }
6697 Py_INCREF(Py_None); resultobj = Py_None;
6698 return resultobj;
6699 fail:
6700 return NULL;
6701 }
6702
6703
6704 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6705 PyObject *obj;
6706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6707 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6708 Py_INCREF(obj);
6709 return Py_BuildValue((char *)"");
6710 }
6711 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6712 PyObject *resultobj;
6713 int result;
6714 char *kwnames[] = {
6715 NULL
6716 };
6717
6718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6719 {
6720 PyThreadState* __tstate = wxPyBeginAllowThreads();
6721 result = (int)wxCaret_GetBlinkTime();
6722
6723 wxPyEndAllowThreads(__tstate);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 {
6727 resultobj = SWIG_From_int((int)(result));
6728 }
6729 return resultobj;
6730 fail:
6731 return NULL;
6732 }
6733
6734
6735 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6736 PyObject *resultobj;
6737 int arg1 ;
6738 PyObject * obj0 = 0 ;
6739 char *kwnames[] = {
6740 (char *) "milliseconds", NULL
6741 };
6742
6743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6744 {
6745 arg1 = (int)(SWIG_As_int(obj0));
6746 if (SWIG_arg_fail(1)) SWIG_fail;
6747 }
6748 {
6749 PyThreadState* __tstate = wxPyBeginAllowThreads();
6750 wxCaret_SetBlinkTime(arg1);
6751
6752 wxPyEndAllowThreads(__tstate);
6753 if (PyErr_Occurred()) SWIG_fail;
6754 }
6755 Py_INCREF(Py_None); resultobj = Py_None;
6756 return resultobj;
6757 fail:
6758 return NULL;
6759 }
6760
6761
6762 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6763 PyObject *resultobj;
6764 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6765 wxBusyCursor *result;
6766 PyObject * obj0 = 0 ;
6767 char *kwnames[] = {
6768 (char *) "cursor", NULL
6769 };
6770
6771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6772 if (obj0) {
6773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6774 if (SWIG_arg_fail(1)) SWIG_fail;
6775 }
6776 {
6777 if (!wxPyCheckForApp()) SWIG_fail;
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6780
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj;
6793 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6794 PyObject * obj0 = 0 ;
6795 char *kwnames[] = {
6796 (char *) "self", NULL
6797 };
6798
6799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6801 if (SWIG_arg_fail(1)) SWIG_fail;
6802 {
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 delete arg1;
6805
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 Py_INCREF(Py_None); resultobj = Py_None;
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6817 PyObject *obj;
6818 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6819 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6820 Py_INCREF(obj);
6821 return Py_BuildValue((char *)"");
6822 }
6823 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj;
6825 wxWindow *arg1 = (wxWindow *) NULL ;
6826 wxWindowDisabler *result;
6827 PyObject * obj0 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "winToSkip", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6833 if (obj0) {
6834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6835 if (SWIG_arg_fail(1)) SWIG_fail;
6836 }
6837 {
6838 if (!wxPyCheckForApp()) SWIG_fail;
6839 PyThreadState* __tstate = wxPyBeginAllowThreads();
6840 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6841
6842 wxPyEndAllowThreads(__tstate);
6843 if (PyErr_Occurred()) SWIG_fail;
6844 }
6845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6846 return resultobj;
6847 fail:
6848 return NULL;
6849 }
6850
6851
6852 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6853 PyObject *resultobj;
6854 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6855 PyObject * obj0 = 0 ;
6856 char *kwnames[] = {
6857 (char *) "self", NULL
6858 };
6859
6860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6862 if (SWIG_arg_fail(1)) SWIG_fail;
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 delete arg1;
6866
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 Py_INCREF(Py_None); resultobj = Py_None;
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6878 PyObject *obj;
6879 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6880 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6881 Py_INCREF(obj);
6882 return Py_BuildValue((char *)"");
6883 }
6884 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6885 PyObject *resultobj;
6886 wxString *arg1 = 0 ;
6887 wxBusyInfo *result;
6888 bool temp1 = false ;
6889 PyObject * obj0 = 0 ;
6890 char *kwnames[] = {
6891 (char *) "message", NULL
6892 };
6893
6894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6895 {
6896 arg1 = wxString_in_helper(obj0);
6897 if (arg1 == NULL) SWIG_fail;
6898 temp1 = true;
6899 }
6900 {
6901 if (!wxPyCheckForApp()) SWIG_fail;
6902 PyThreadState* __tstate = wxPyBeginAllowThreads();
6903 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6904
6905 wxPyEndAllowThreads(__tstate);
6906 if (PyErr_Occurred()) SWIG_fail;
6907 }
6908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6909 {
6910 if (temp1)
6911 delete arg1;
6912 }
6913 return resultobj;
6914 fail:
6915 {
6916 if (temp1)
6917 delete arg1;
6918 }
6919 return NULL;
6920 }
6921
6922
6923 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj;
6925 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6926 PyObject * obj0 = 0 ;
6927 char *kwnames[] = {
6928 (char *) "self", NULL
6929 };
6930
6931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6933 if (SWIG_arg_fail(1)) SWIG_fail;
6934 {
6935 PyThreadState* __tstate = wxPyBeginAllowThreads();
6936 delete arg1;
6937
6938 wxPyEndAllowThreads(__tstate);
6939 if (PyErr_Occurred()) SWIG_fail;
6940 }
6941 Py_INCREF(Py_None); resultobj = Py_None;
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6949 PyObject *obj;
6950 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6951 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6952 Py_INCREF(obj);
6953 return Py_BuildValue((char *)"");
6954 }
6955 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxStopWatch *result;
6958 char *kwnames[] = {
6959 NULL
6960 };
6961
6962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6963 {
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 result = (wxStopWatch *)new wxStopWatch();
6966
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6978 PyObject *resultobj;
6979 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6980 long arg2 = (long) 0 ;
6981 PyObject * obj0 = 0 ;
6982 PyObject * obj1 = 0 ;
6983 char *kwnames[] = {
6984 (char *) "self",(char *) "t0", NULL
6985 };
6986
6987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6989 if (SWIG_arg_fail(1)) SWIG_fail;
6990 if (obj1) {
6991 {
6992 arg2 = (long)(SWIG_As_long(obj1));
6993 if (SWIG_arg_fail(2)) SWIG_fail;
6994 }
6995 }
6996 {
6997 PyThreadState* __tstate = wxPyBeginAllowThreads();
6998 (arg1)->Start(arg2);
6999
7000 wxPyEndAllowThreads(__tstate);
7001 if (PyErr_Occurred()) SWIG_fail;
7002 }
7003 Py_INCREF(Py_None); resultobj = Py_None;
7004 return resultobj;
7005 fail:
7006 return NULL;
7007 }
7008
7009
7010 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7011 PyObject *resultobj;
7012 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7013 PyObject * obj0 = 0 ;
7014 char *kwnames[] = {
7015 (char *) "self", NULL
7016 };
7017
7018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7020 if (SWIG_arg_fail(1)) SWIG_fail;
7021 {
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 (arg1)->Pause();
7024
7025 wxPyEndAllowThreads(__tstate);
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 Py_INCREF(Py_None); resultobj = Py_None;
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7036 PyObject *resultobj;
7037 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7038 PyObject * obj0 = 0 ;
7039 char *kwnames[] = {
7040 (char *) "self", NULL
7041 };
7042
7043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7045 if (SWIG_arg_fail(1)) SWIG_fail;
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 (arg1)->Resume();
7049
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 Py_INCREF(Py_None); resultobj = Py_None;
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7061 PyObject *resultobj;
7062 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7063 long result;
7064 PyObject * obj0 = 0 ;
7065 char *kwnames[] = {
7066 (char *) "self", NULL
7067 };
7068
7069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7071 if (SWIG_arg_fail(1)) SWIG_fail;
7072 {
7073 PyThreadState* __tstate = wxPyBeginAllowThreads();
7074 result = (long)((wxStopWatch const *)arg1)->Time();
7075
7076 wxPyEndAllowThreads(__tstate);
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 {
7080 resultobj = SWIG_From_long((long)(result));
7081 }
7082 return resultobj;
7083 fail:
7084 return NULL;
7085 }
7086
7087
7088 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7089 PyObject *obj;
7090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7091 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7092 Py_INCREF(obj);
7093 return Py_BuildValue((char *)"");
7094 }
7095 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7096 PyObject *resultobj;
7097 int arg1 = (int) 9 ;
7098 int arg2 = (int) wxID_FILE1 ;
7099 wxFileHistory *result;
7100 PyObject * obj0 = 0 ;
7101 PyObject * obj1 = 0 ;
7102 char *kwnames[] = {
7103 (char *) "maxFiles",(char *) "idBase", NULL
7104 };
7105
7106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7107 if (obj0) {
7108 {
7109 arg1 = (int)(SWIG_As_int(obj0));
7110 if (SWIG_arg_fail(1)) SWIG_fail;
7111 }
7112 }
7113 if (obj1) {
7114 {
7115 arg2 = (int)(SWIG_As_int(obj1));
7116 if (SWIG_arg_fail(2)) SWIG_fail;
7117 }
7118 }
7119 {
7120 PyThreadState* __tstate = wxPyBeginAllowThreads();
7121 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7122
7123 wxPyEndAllowThreads(__tstate);
7124 if (PyErr_Occurred()) SWIG_fail;
7125 }
7126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7127 return resultobj;
7128 fail:
7129 return NULL;
7130 }
7131
7132
7133 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7134 PyObject *resultobj;
7135 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7136 PyObject * obj0 = 0 ;
7137 char *kwnames[] = {
7138 (char *) "self", NULL
7139 };
7140
7141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7143 if (SWIG_arg_fail(1)) SWIG_fail;
7144 {
7145 PyThreadState* __tstate = wxPyBeginAllowThreads();
7146 delete arg1;
7147
7148 wxPyEndAllowThreads(__tstate);
7149 if (PyErr_Occurred()) SWIG_fail;
7150 }
7151 Py_INCREF(Py_None); resultobj = Py_None;
7152 return resultobj;
7153 fail:
7154 return NULL;
7155 }
7156
7157
7158 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7159 PyObject *resultobj;
7160 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7161 wxString *arg2 = 0 ;
7162 bool temp2 = false ;
7163 PyObject * obj0 = 0 ;
7164 PyObject * obj1 = 0 ;
7165 char *kwnames[] = {
7166 (char *) "self",(char *) "file", NULL
7167 };
7168
7169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7171 if (SWIG_arg_fail(1)) SWIG_fail;
7172 {
7173 arg2 = wxString_in_helper(obj1);
7174 if (arg2 == NULL) SWIG_fail;
7175 temp2 = true;
7176 }
7177 {
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 (arg1)->AddFileToHistory((wxString const &)*arg2);
7180
7181 wxPyEndAllowThreads(__tstate);
7182 if (PyErr_Occurred()) SWIG_fail;
7183 }
7184 Py_INCREF(Py_None); resultobj = Py_None;
7185 {
7186 if (temp2)
7187 delete arg2;
7188 }
7189 return resultobj;
7190 fail:
7191 {
7192 if (temp2)
7193 delete arg2;
7194 }
7195 return NULL;
7196 }
7197
7198
7199 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7200 PyObject *resultobj;
7201 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7202 int arg2 ;
7203 PyObject * obj0 = 0 ;
7204 PyObject * obj1 = 0 ;
7205 char *kwnames[] = {
7206 (char *) "self",(char *) "i", NULL
7207 };
7208
7209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7211 if (SWIG_arg_fail(1)) SWIG_fail;
7212 {
7213 arg2 = (int)(SWIG_As_int(obj1));
7214 if (SWIG_arg_fail(2)) SWIG_fail;
7215 }
7216 {
7217 PyThreadState* __tstate = wxPyBeginAllowThreads();
7218 (arg1)->RemoveFileFromHistory(arg2);
7219
7220 wxPyEndAllowThreads(__tstate);
7221 if (PyErr_Occurred()) SWIG_fail;
7222 }
7223 Py_INCREF(Py_None); resultobj = Py_None;
7224 return resultobj;
7225 fail:
7226 return NULL;
7227 }
7228
7229
7230 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7231 PyObject *resultobj;
7232 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7233 int result;
7234 PyObject * obj0 = 0 ;
7235 char *kwnames[] = {
7236 (char *) "self", NULL
7237 };
7238
7239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7241 if (SWIG_arg_fail(1)) SWIG_fail;
7242 {
7243 PyThreadState* __tstate = wxPyBeginAllowThreads();
7244 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7245
7246 wxPyEndAllowThreads(__tstate);
7247 if (PyErr_Occurred()) SWIG_fail;
7248 }
7249 {
7250 resultobj = SWIG_From_int((int)(result));
7251 }
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj;
7260 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7261 wxMenu *arg2 = (wxMenu *) 0 ;
7262 PyObject * obj0 = 0 ;
7263 PyObject * obj1 = 0 ;
7264 char *kwnames[] = {
7265 (char *) "self",(char *) "menu", NULL
7266 };
7267
7268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7270 if (SWIG_arg_fail(1)) SWIG_fail;
7271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7272 if (SWIG_arg_fail(2)) SWIG_fail;
7273 {
7274 PyThreadState* __tstate = wxPyBeginAllowThreads();
7275 (arg1)->UseMenu(arg2);
7276
7277 wxPyEndAllowThreads(__tstate);
7278 if (PyErr_Occurred()) SWIG_fail;
7279 }
7280 Py_INCREF(Py_None); resultobj = Py_None;
7281 return resultobj;
7282 fail:
7283 return NULL;
7284 }
7285
7286
7287 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7288 PyObject *resultobj;
7289 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7290 wxMenu *arg2 = (wxMenu *) 0 ;
7291 PyObject * obj0 = 0 ;
7292 PyObject * obj1 = 0 ;
7293 char *kwnames[] = {
7294 (char *) "self",(char *) "menu", NULL
7295 };
7296
7297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7299 if (SWIG_arg_fail(1)) SWIG_fail;
7300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7301 if (SWIG_arg_fail(2)) SWIG_fail;
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 (arg1)->RemoveMenu(arg2);
7305
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 Py_INCREF(Py_None); resultobj = Py_None;
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj;
7318 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7319 wxConfigBase *arg2 = 0 ;
7320 PyObject * obj0 = 0 ;
7321 PyObject * obj1 = 0 ;
7322 char *kwnames[] = {
7323 (char *) "self",(char *) "config", NULL
7324 };
7325
7326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7328 if (SWIG_arg_fail(1)) SWIG_fail;
7329 {
7330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7331 if (SWIG_arg_fail(2)) SWIG_fail;
7332 if (arg2 == NULL) {
7333 SWIG_null_ref("wxConfigBase");
7334 }
7335 if (SWIG_arg_fail(2)) SWIG_fail;
7336 }
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 (arg1)->Load(*arg2);
7340
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 Py_INCREF(Py_None); resultobj = Py_None;
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj;
7353 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7354 wxConfigBase *arg2 = 0 ;
7355 PyObject * obj0 = 0 ;
7356 PyObject * obj1 = 0 ;
7357 char *kwnames[] = {
7358 (char *) "self",(char *) "config", NULL
7359 };
7360
7361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7363 if (SWIG_arg_fail(1)) SWIG_fail;
7364 {
7365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7366 if (SWIG_arg_fail(2)) SWIG_fail;
7367 if (arg2 == NULL) {
7368 SWIG_null_ref("wxConfigBase");
7369 }
7370 if (SWIG_arg_fail(2)) SWIG_fail;
7371 }
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 (arg1)->Save(*arg2);
7375
7376 wxPyEndAllowThreads(__tstate);
7377 if (PyErr_Occurred()) SWIG_fail;
7378 }
7379 Py_INCREF(Py_None); resultobj = Py_None;
7380 return resultobj;
7381 fail:
7382 return NULL;
7383 }
7384
7385
7386 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7387 PyObject *resultobj;
7388 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7389 PyObject * obj0 = 0 ;
7390 char *kwnames[] = {
7391 (char *) "self", NULL
7392 };
7393
7394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7396 if (SWIG_arg_fail(1)) SWIG_fail;
7397 {
7398 PyThreadState* __tstate = wxPyBeginAllowThreads();
7399 (arg1)->AddFilesToMenu();
7400
7401 wxPyEndAllowThreads(__tstate);
7402 if (PyErr_Occurred()) SWIG_fail;
7403 }
7404 Py_INCREF(Py_None); resultobj = Py_None;
7405 return resultobj;
7406 fail:
7407 return NULL;
7408 }
7409
7410
7411 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7412 PyObject *resultobj;
7413 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7414 wxMenu *arg2 = (wxMenu *) 0 ;
7415 PyObject * obj0 = 0 ;
7416 PyObject * obj1 = 0 ;
7417 char *kwnames[] = {
7418 (char *) "self",(char *) "menu", NULL
7419 };
7420
7421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7423 if (SWIG_arg_fail(1)) SWIG_fail;
7424 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7425 if (SWIG_arg_fail(2)) SWIG_fail;
7426 {
7427 PyThreadState* __tstate = wxPyBeginAllowThreads();
7428 (arg1)->AddFilesToMenu(arg2);
7429
7430 wxPyEndAllowThreads(__tstate);
7431 if (PyErr_Occurred()) SWIG_fail;
7432 }
7433 Py_INCREF(Py_None); resultobj = Py_None;
7434 return resultobj;
7435 fail:
7436 return NULL;
7437 }
7438
7439
7440 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7441 PyObject *resultobj;
7442 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7443 int arg2 ;
7444 wxString result;
7445 PyObject * obj0 = 0 ;
7446 PyObject * obj1 = 0 ;
7447 char *kwnames[] = {
7448 (char *) "self",(char *) "i", NULL
7449 };
7450
7451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7453 if (SWIG_arg_fail(1)) SWIG_fail;
7454 {
7455 arg2 = (int)(SWIG_As_int(obj1));
7456 if (SWIG_arg_fail(2)) SWIG_fail;
7457 }
7458 {
7459 PyThreadState* __tstate = wxPyBeginAllowThreads();
7460 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7461
7462 wxPyEndAllowThreads(__tstate);
7463 if (PyErr_Occurred()) SWIG_fail;
7464 }
7465 {
7466 #if wxUSE_UNICODE
7467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7468 #else
7469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7470 #endif
7471 }
7472 return resultobj;
7473 fail:
7474 return NULL;
7475 }
7476
7477
7478 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7479 PyObject *resultobj;
7480 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7481 int result;
7482 PyObject * obj0 = 0 ;
7483 char *kwnames[] = {
7484 (char *) "self", NULL
7485 };
7486
7487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7489 if (SWIG_arg_fail(1)) SWIG_fail;
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 result = (int)((wxFileHistory const *)arg1)->GetCount();
7493
7494 wxPyEndAllowThreads(__tstate);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 {
7498 resultobj = SWIG_From_int((int)(result));
7499 }
7500 return resultobj;
7501 fail:
7502 return NULL;
7503 }
7504
7505
7506 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7507 PyObject *obj;
7508 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7509 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7510 Py_INCREF(obj);
7511 return Py_BuildValue((char *)"");
7512 }
7513 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7514 PyObject *resultobj;
7515 wxString *arg1 = 0 ;
7516 wxString const &arg2_defvalue = wxPyEmptyString ;
7517 wxString *arg2 = (wxString *) &arg2_defvalue ;
7518 wxSingleInstanceChecker *result;
7519 bool temp1 = false ;
7520 bool temp2 = false ;
7521 PyObject * obj0 = 0 ;
7522 PyObject * obj1 = 0 ;
7523 char *kwnames[] = {
7524 (char *) "name",(char *) "path", NULL
7525 };
7526
7527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7528 {
7529 arg1 = wxString_in_helper(obj0);
7530 if (arg1 == NULL) SWIG_fail;
7531 temp1 = true;
7532 }
7533 if (obj1) {
7534 {
7535 arg2 = wxString_in_helper(obj1);
7536 if (arg2 == NULL) SWIG_fail;
7537 temp2 = true;
7538 }
7539 }
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7543
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7548 {
7549 if (temp1)
7550 delete arg1;
7551 }
7552 {
7553 if (temp2)
7554 delete arg2;
7555 }
7556 return resultobj;
7557 fail:
7558 {
7559 if (temp1)
7560 delete arg1;
7561 }
7562 {
7563 if (temp2)
7564 delete arg2;
7565 }
7566 return NULL;
7567 }
7568
7569
7570 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7571 PyObject *resultobj;
7572 wxSingleInstanceChecker *result;
7573 char *kwnames[] = {
7574 NULL
7575 };
7576
7577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj;
7594 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7595 PyObject * obj0 = 0 ;
7596 char *kwnames[] = {
7597 (char *) "self", NULL
7598 };
7599
7600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7602 if (SWIG_arg_fail(1)) SWIG_fail;
7603 {
7604 PyThreadState* __tstate = wxPyBeginAllowThreads();
7605 delete arg1;
7606
7607 wxPyEndAllowThreads(__tstate);
7608 if (PyErr_Occurred()) SWIG_fail;
7609 }
7610 Py_INCREF(Py_None); resultobj = Py_None;
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7618 PyObject *resultobj;
7619 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7620 wxString *arg2 = 0 ;
7621 wxString const &arg3_defvalue = wxPyEmptyString ;
7622 wxString *arg3 = (wxString *) &arg3_defvalue ;
7623 bool result;
7624 bool temp2 = false ;
7625 bool temp3 = false ;
7626 PyObject * obj0 = 0 ;
7627 PyObject * obj1 = 0 ;
7628 PyObject * obj2 = 0 ;
7629 char *kwnames[] = {
7630 (char *) "self",(char *) "name",(char *) "path", NULL
7631 };
7632
7633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7635 if (SWIG_arg_fail(1)) SWIG_fail;
7636 {
7637 arg2 = wxString_in_helper(obj1);
7638 if (arg2 == NULL) SWIG_fail;
7639 temp2 = true;
7640 }
7641 if (obj2) {
7642 {
7643 arg3 = wxString_in_helper(obj2);
7644 if (arg3 == NULL) SWIG_fail;
7645 temp3 = true;
7646 }
7647 }
7648 {
7649 PyThreadState* __tstate = wxPyBeginAllowThreads();
7650 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7651
7652 wxPyEndAllowThreads(__tstate);
7653 if (PyErr_Occurred()) SWIG_fail;
7654 }
7655 {
7656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7657 }
7658 {
7659 if (temp2)
7660 delete arg2;
7661 }
7662 {
7663 if (temp3)
7664 delete arg3;
7665 }
7666 return resultobj;
7667 fail:
7668 {
7669 if (temp2)
7670 delete arg2;
7671 }
7672 {
7673 if (temp3)
7674 delete arg3;
7675 }
7676 return NULL;
7677 }
7678
7679
7680 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj;
7682 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7683 bool result;
7684 PyObject * obj0 = 0 ;
7685 char *kwnames[] = {
7686 (char *) "self", NULL
7687 };
7688
7689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7691 if (SWIG_arg_fail(1)) SWIG_fail;
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7695
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 {
7700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7701 }
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7709 PyObject *obj;
7710 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7711 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7712 Py_INCREF(obj);
7713 return Py_BuildValue((char *)"");
7714 }
7715 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7716 PyObject *resultobj;
7717 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7718 PyObject * obj0 = 0 ;
7719 char *kwnames[] = {
7720 (char *) "self", NULL
7721 };
7722
7723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7725 if (SWIG_arg_fail(1)) SWIG_fail;
7726 {
7727 PyThreadState* __tstate = wxPyBeginAllowThreads();
7728 delete arg1;
7729
7730 wxPyEndAllowThreads(__tstate);
7731 if (PyErr_Occurred()) SWIG_fail;
7732 }
7733 Py_INCREF(Py_None); resultobj = Py_None;
7734 return resultobj;
7735 fail:
7736 return NULL;
7737 }
7738
7739
7740 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7741 PyObject *resultobj;
7742 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7743 wxString result;
7744 PyObject * obj0 = 0 ;
7745 char *kwnames[] = {
7746 (char *) "self", NULL
7747 };
7748
7749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7751 if (SWIG_arg_fail(1)) SWIG_fail;
7752 {
7753 PyThreadState* __tstate = wxPyBeginAllowThreads();
7754 result = (arg1)->GetTip();
7755
7756 wxPyEndAllowThreads(__tstate);
7757 if (PyErr_Occurred()) SWIG_fail;
7758 }
7759 {
7760 #if wxUSE_UNICODE
7761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7762 #else
7763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7764 #endif
7765 }
7766 return resultobj;
7767 fail:
7768 return NULL;
7769 }
7770
7771
7772 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7773 PyObject *resultobj;
7774 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7775 size_t result;
7776 PyObject * obj0 = 0 ;
7777 char *kwnames[] = {
7778 (char *) "self", NULL
7779 };
7780
7781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7783 if (SWIG_arg_fail(1)) SWIG_fail;
7784 {
7785 PyThreadState* __tstate = wxPyBeginAllowThreads();
7786 result = (size_t)(arg1)->GetCurrentTip();
7787
7788 wxPyEndAllowThreads(__tstate);
7789 if (PyErr_Occurred()) SWIG_fail;
7790 }
7791 {
7792 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7793 }
7794 return resultobj;
7795 fail:
7796 return NULL;
7797 }
7798
7799
7800 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7801 PyObject *resultobj;
7802 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7803 wxString *arg2 = 0 ;
7804 wxString result;
7805 bool temp2 = false ;
7806 PyObject * obj0 = 0 ;
7807 PyObject * obj1 = 0 ;
7808 char *kwnames[] = {
7809 (char *) "self",(char *) "tip", NULL
7810 };
7811
7812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7814 if (SWIG_arg_fail(1)) SWIG_fail;
7815 {
7816 arg2 = wxString_in_helper(obj1);
7817 if (arg2 == NULL) SWIG_fail;
7818 temp2 = true;
7819 }
7820 {
7821 PyThreadState* __tstate = wxPyBeginAllowThreads();
7822 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7823
7824 wxPyEndAllowThreads(__tstate);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 {
7828 #if wxUSE_UNICODE
7829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7830 #else
7831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7832 #endif
7833 }
7834 {
7835 if (temp2)
7836 delete arg2;
7837 }
7838 return resultobj;
7839 fail:
7840 {
7841 if (temp2)
7842 delete arg2;
7843 }
7844 return NULL;
7845 }
7846
7847
7848 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7849 PyObject *obj;
7850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7851 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7852 Py_INCREF(obj);
7853 return Py_BuildValue((char *)"");
7854 }
7855 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7856 PyObject *resultobj;
7857 size_t arg1 ;
7858 wxPyTipProvider *result;
7859 PyObject * obj0 = 0 ;
7860 char *kwnames[] = {
7861 (char *) "currentTip", NULL
7862 };
7863
7864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7865 {
7866 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7867 if (SWIG_arg_fail(1)) SWIG_fail;
7868 }
7869 {
7870 PyThreadState* __tstate = wxPyBeginAllowThreads();
7871 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7872
7873 wxPyEndAllowThreads(__tstate);
7874 if (PyErr_Occurred()) SWIG_fail;
7875 }
7876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7877 return resultobj;
7878 fail:
7879 return NULL;
7880 }
7881
7882
7883 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7884 PyObject *resultobj;
7885 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7886 PyObject *arg2 = (PyObject *) 0 ;
7887 PyObject *arg3 = (PyObject *) 0 ;
7888 PyObject * obj0 = 0 ;
7889 PyObject * obj1 = 0 ;
7890 PyObject * obj2 = 0 ;
7891 char *kwnames[] = {
7892 (char *) "self",(char *) "self",(char *) "_class", NULL
7893 };
7894
7895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7897 if (SWIG_arg_fail(1)) SWIG_fail;
7898 arg2 = obj1;
7899 arg3 = obj2;
7900 {
7901 PyThreadState* __tstate = wxPyBeginAllowThreads();
7902 (arg1)->_setCallbackInfo(arg2,arg3);
7903
7904 wxPyEndAllowThreads(__tstate);
7905 if (PyErr_Occurred()) SWIG_fail;
7906 }
7907 Py_INCREF(Py_None); resultobj = Py_None;
7908 return resultobj;
7909 fail:
7910 return NULL;
7911 }
7912
7913
7914 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7915 PyObject *obj;
7916 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7917 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7918 Py_INCREF(obj);
7919 return Py_BuildValue((char *)"");
7920 }
7921 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj;
7923 wxWindow *arg1 = (wxWindow *) 0 ;
7924 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7925 bool arg3 = (bool) true ;
7926 bool result;
7927 PyObject * obj0 = 0 ;
7928 PyObject * obj1 = 0 ;
7929 PyObject * obj2 = 0 ;
7930 char *kwnames[] = {
7931 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7932 };
7933
7934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7936 if (SWIG_arg_fail(1)) SWIG_fail;
7937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7938 if (SWIG_arg_fail(2)) SWIG_fail;
7939 if (obj2) {
7940 {
7941 arg3 = (bool)(SWIG_As_bool(obj2));
7942 if (SWIG_arg_fail(3)) SWIG_fail;
7943 }
7944 }
7945 {
7946 if (!wxPyCheckForApp()) SWIG_fail;
7947 PyThreadState* __tstate = wxPyBeginAllowThreads();
7948 result = (bool)wxShowTip(arg1,arg2,arg3);
7949
7950 wxPyEndAllowThreads(__tstate);
7951 if (PyErr_Occurred()) SWIG_fail;
7952 }
7953 {
7954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7955 }
7956 return resultobj;
7957 fail:
7958 return NULL;
7959 }
7960
7961
7962 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7963 PyObject *resultobj;
7964 wxString *arg1 = 0 ;
7965 size_t arg2 ;
7966 wxTipProvider *result;
7967 bool temp1 = false ;
7968 PyObject * obj0 = 0 ;
7969 PyObject * obj1 = 0 ;
7970 char *kwnames[] = {
7971 (char *) "filename",(char *) "currentTip", NULL
7972 };
7973
7974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7975 {
7976 arg1 = wxString_in_helper(obj0);
7977 if (arg1 == NULL) SWIG_fail;
7978 temp1 = true;
7979 }
7980 {
7981 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7982 if (SWIG_arg_fail(2)) SWIG_fail;
7983 }
7984 {
7985 if (!wxPyCheckForApp()) SWIG_fail;
7986 PyThreadState* __tstate = wxPyBeginAllowThreads();
7987 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7988
7989 wxPyEndAllowThreads(__tstate);
7990 if (PyErr_Occurred()) SWIG_fail;
7991 }
7992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
7993 {
7994 if (temp1)
7995 delete arg1;
7996 }
7997 return resultobj;
7998 fail:
7999 {
8000 if (temp1)
8001 delete arg1;
8002 }
8003 return NULL;
8004 }
8005
8006
8007 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8008 PyObject *resultobj;
8009 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8010 int arg2 = (int) -1 ;
8011 wxPyTimer *result;
8012 PyObject * obj0 = 0 ;
8013 PyObject * obj1 = 0 ;
8014 char *kwnames[] = {
8015 (char *) "owner",(char *) "id", NULL
8016 };
8017
8018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8019 if (obj0) {
8020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8021 if (SWIG_arg_fail(1)) SWIG_fail;
8022 }
8023 if (obj1) {
8024 {
8025 arg2 = (int)(SWIG_As_int(obj1));
8026 if (SWIG_arg_fail(2)) SWIG_fail;
8027 }
8028 }
8029 {
8030 if (!wxPyCheckForApp()) SWIG_fail;
8031 PyThreadState* __tstate = wxPyBeginAllowThreads();
8032 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8033
8034 wxPyEndAllowThreads(__tstate);
8035 if (PyErr_Occurred()) SWIG_fail;
8036 }
8037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8038 return resultobj;
8039 fail:
8040 return NULL;
8041 }
8042
8043
8044 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8045 PyObject *resultobj;
8046 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8047 PyObject * obj0 = 0 ;
8048 char *kwnames[] = {
8049 (char *) "self", NULL
8050 };
8051
8052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8054 if (SWIG_arg_fail(1)) SWIG_fail;
8055 {
8056 PyThreadState* __tstate = wxPyBeginAllowThreads();
8057 delete arg1;
8058
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 Py_INCREF(Py_None); resultobj = Py_None;
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8070 PyObject *resultobj;
8071 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8072 PyObject *arg2 = (PyObject *) 0 ;
8073 PyObject *arg3 = (PyObject *) 0 ;
8074 int arg4 = (int) 1 ;
8075 PyObject * obj0 = 0 ;
8076 PyObject * obj1 = 0 ;
8077 PyObject * obj2 = 0 ;
8078 PyObject * obj3 = 0 ;
8079 char *kwnames[] = {
8080 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8081 };
8082
8083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8085 if (SWIG_arg_fail(1)) SWIG_fail;
8086 arg2 = obj1;
8087 arg3 = obj2;
8088 if (obj3) {
8089 {
8090 arg4 = (int)(SWIG_As_int(obj3));
8091 if (SWIG_arg_fail(4)) SWIG_fail;
8092 }
8093 }
8094 {
8095 PyThreadState* __tstate = wxPyBeginAllowThreads();
8096 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8097
8098 wxPyEndAllowThreads(__tstate);
8099 if (PyErr_Occurred()) SWIG_fail;
8100 }
8101 Py_INCREF(Py_None); resultobj = Py_None;
8102 return resultobj;
8103 fail:
8104 return NULL;
8105 }
8106
8107
8108 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8109 PyObject *resultobj;
8110 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8111 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8112 int arg3 = (int) -1 ;
8113 PyObject * obj0 = 0 ;
8114 PyObject * obj1 = 0 ;
8115 PyObject * obj2 = 0 ;
8116 char *kwnames[] = {
8117 (char *) "self",(char *) "owner",(char *) "id", NULL
8118 };
8119
8120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8122 if (SWIG_arg_fail(1)) SWIG_fail;
8123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8124 if (SWIG_arg_fail(2)) SWIG_fail;
8125 if (obj2) {
8126 {
8127 arg3 = (int)(SWIG_As_int(obj2));
8128 if (SWIG_arg_fail(3)) SWIG_fail;
8129 }
8130 }
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 (arg1)->SetOwner(arg2,arg3);
8134
8135 wxPyEndAllowThreads(__tstate);
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 Py_INCREF(Py_None); resultobj = Py_None;
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj;
8147 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8148 wxEvtHandler *result;
8149 PyObject * obj0 = 0 ;
8150 char *kwnames[] = {
8151 (char *) "self", NULL
8152 };
8153
8154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8156 if (SWIG_arg_fail(1)) SWIG_fail;
8157 {
8158 PyThreadState* __tstate = wxPyBeginAllowThreads();
8159 result = (wxEvtHandler *)(arg1)->GetOwner();
8160
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 {
8165 resultobj = wxPyMake_wxObject(result, 0);
8166 }
8167 return resultobj;
8168 fail:
8169 return NULL;
8170 }
8171
8172
8173 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8174 PyObject *resultobj;
8175 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8176 int arg2 = (int) -1 ;
8177 bool arg3 = (bool) false ;
8178 bool result;
8179 PyObject * obj0 = 0 ;
8180 PyObject * obj1 = 0 ;
8181 PyObject * obj2 = 0 ;
8182 char *kwnames[] = {
8183 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8184 };
8185
8186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8188 if (SWIG_arg_fail(1)) SWIG_fail;
8189 if (obj1) {
8190 {
8191 arg2 = (int)(SWIG_As_int(obj1));
8192 if (SWIG_arg_fail(2)) SWIG_fail;
8193 }
8194 }
8195 if (obj2) {
8196 {
8197 arg3 = (bool)(SWIG_As_bool(obj2));
8198 if (SWIG_arg_fail(3)) SWIG_fail;
8199 }
8200 }
8201 {
8202 PyThreadState* __tstate = wxPyBeginAllowThreads();
8203 result = (bool)(arg1)->Start(arg2,arg3);
8204
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 {
8209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8210 }
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8218 PyObject *resultobj;
8219 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8220 PyObject * obj0 = 0 ;
8221 char *kwnames[] = {
8222 (char *) "self", NULL
8223 };
8224
8225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8227 if (SWIG_arg_fail(1)) SWIG_fail;
8228 {
8229 PyThreadState* __tstate = wxPyBeginAllowThreads();
8230 (arg1)->Stop();
8231
8232 wxPyEndAllowThreads(__tstate);
8233 if (PyErr_Occurred()) SWIG_fail;
8234 }
8235 Py_INCREF(Py_None); resultobj = Py_None;
8236 return resultobj;
8237 fail:
8238 return NULL;
8239 }
8240
8241
8242 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8243 PyObject *resultobj;
8244 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8245 bool result;
8246 PyObject * obj0 = 0 ;
8247 char *kwnames[] = {
8248 (char *) "self", NULL
8249 };
8250
8251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8253 if (SWIG_arg_fail(1)) SWIG_fail;
8254 {
8255 PyThreadState* __tstate = wxPyBeginAllowThreads();
8256 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8257
8258 wxPyEndAllowThreads(__tstate);
8259 if (PyErr_Occurred()) SWIG_fail;
8260 }
8261 {
8262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8263 }
8264 return resultobj;
8265 fail:
8266 return NULL;
8267 }
8268
8269
8270 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8271 PyObject *resultobj;
8272 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8273 int result;
8274 PyObject * obj0 = 0 ;
8275 char *kwnames[] = {
8276 (char *) "self", NULL
8277 };
8278
8279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8281 if (SWIG_arg_fail(1)) SWIG_fail;
8282 {
8283 PyThreadState* __tstate = wxPyBeginAllowThreads();
8284 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8285
8286 wxPyEndAllowThreads(__tstate);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 {
8290 resultobj = SWIG_From_int((int)(result));
8291 }
8292 return resultobj;
8293 fail:
8294 return NULL;
8295 }
8296
8297
8298 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8299 PyObject *resultobj;
8300 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8301 bool result;
8302 PyObject * obj0 = 0 ;
8303 char *kwnames[] = {
8304 (char *) "self", NULL
8305 };
8306
8307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8309 if (SWIG_arg_fail(1)) SWIG_fail;
8310 {
8311 PyThreadState* __tstate = wxPyBeginAllowThreads();
8312 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8313
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 {
8318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8319 }
8320 return resultobj;
8321 fail:
8322 return NULL;
8323 }
8324
8325
8326 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8327 PyObject *resultobj;
8328 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8329 int result;
8330 PyObject * obj0 = 0 ;
8331 char *kwnames[] = {
8332 (char *) "self", NULL
8333 };
8334
8335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8337 if (SWIG_arg_fail(1)) SWIG_fail;
8338 {
8339 PyThreadState* __tstate = wxPyBeginAllowThreads();
8340 result = (int)((wxPyTimer const *)arg1)->GetId();
8341
8342 wxPyEndAllowThreads(__tstate);
8343 if (PyErr_Occurred()) SWIG_fail;
8344 }
8345 {
8346 resultobj = SWIG_From_int((int)(result));
8347 }
8348 return resultobj;
8349 fail:
8350 return NULL;
8351 }
8352
8353
8354 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8355 PyObject *obj;
8356 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8357 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8358 Py_INCREF(obj);
8359 return Py_BuildValue((char *)"");
8360 }
8361 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj;
8363 int arg1 = (int) 0 ;
8364 int arg2 = (int) 0 ;
8365 wxTimerEvent *result;
8366 PyObject * obj0 = 0 ;
8367 PyObject * obj1 = 0 ;
8368 char *kwnames[] = {
8369 (char *) "timerid",(char *) "interval", NULL
8370 };
8371
8372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8373 if (obj0) {
8374 {
8375 arg1 = (int)(SWIG_As_int(obj0));
8376 if (SWIG_arg_fail(1)) SWIG_fail;
8377 }
8378 }
8379 if (obj1) {
8380 {
8381 arg2 = (int)(SWIG_As_int(obj1));
8382 if (SWIG_arg_fail(2)) SWIG_fail;
8383 }
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8388
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8393 return resultobj;
8394 fail:
8395 return NULL;
8396 }
8397
8398
8399 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8400 PyObject *resultobj;
8401 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8402 int result;
8403 PyObject * obj0 = 0 ;
8404 char *kwnames[] = {
8405 (char *) "self", NULL
8406 };
8407
8408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8410 if (SWIG_arg_fail(1)) SWIG_fail;
8411 {
8412 PyThreadState* __tstate = wxPyBeginAllowThreads();
8413 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8414
8415 wxPyEndAllowThreads(__tstate);
8416 if (PyErr_Occurred()) SWIG_fail;
8417 }
8418 {
8419 resultobj = SWIG_From_int((int)(result));
8420 }
8421 return resultobj;
8422 fail:
8423 return NULL;
8424 }
8425
8426
8427 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8428 PyObject *obj;
8429 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8430 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8431 Py_INCREF(obj);
8432 return Py_BuildValue((char *)"");
8433 }
8434 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8435 PyObject *resultobj;
8436 wxTimer *arg1 = 0 ;
8437 wxTimerRunner *result;
8438 PyObject * obj0 = 0 ;
8439
8440 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8441 {
8442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8443 if (SWIG_arg_fail(1)) SWIG_fail;
8444 if (arg1 == NULL) {
8445 SWIG_null_ref("wxTimer");
8446 }
8447 if (SWIG_arg_fail(1)) SWIG_fail;
8448 }
8449 {
8450 if (!wxPyCheckForApp()) SWIG_fail;
8451 PyThreadState* __tstate = wxPyBeginAllowThreads();
8452 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8453
8454 wxPyEndAllowThreads(__tstate);
8455 if (PyErr_Occurred()) SWIG_fail;
8456 }
8457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8458 return resultobj;
8459 fail:
8460 return NULL;
8461 }
8462
8463
8464 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8465 PyObject *resultobj;
8466 wxTimer *arg1 = 0 ;
8467 int arg2 ;
8468 bool arg3 = (bool) false ;
8469 wxTimerRunner *result;
8470 PyObject * obj0 = 0 ;
8471 PyObject * obj1 = 0 ;
8472 PyObject * obj2 = 0 ;
8473
8474 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8475 {
8476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8477 if (SWIG_arg_fail(1)) SWIG_fail;
8478 if (arg1 == NULL) {
8479 SWIG_null_ref("wxTimer");
8480 }
8481 if (SWIG_arg_fail(1)) SWIG_fail;
8482 }
8483 {
8484 arg2 = (int)(SWIG_As_int(obj1));
8485 if (SWIG_arg_fail(2)) SWIG_fail;
8486 }
8487 if (obj2) {
8488 {
8489 arg3 = (bool)(SWIG_As_bool(obj2));
8490 if (SWIG_arg_fail(3)) SWIG_fail;
8491 }
8492 }
8493 {
8494 if (!wxPyCheckForApp()) SWIG_fail;
8495 PyThreadState* __tstate = wxPyBeginAllowThreads();
8496 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8497
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8502 return resultobj;
8503 fail:
8504 return NULL;
8505 }
8506
8507
8508 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8509 int argc;
8510 PyObject *argv[4];
8511 int ii;
8512
8513 argc = PyObject_Length(args);
8514 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8515 argv[ii] = PyTuple_GetItem(args,ii);
8516 }
8517 if (argc == 1) {
8518 int _v;
8519 {
8520 void *ptr = 0;
8521 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8522 _v = 0;
8523 PyErr_Clear();
8524 } else {
8525 _v = (ptr != 0);
8526 }
8527 }
8528 if (_v) {
8529 return _wrap_new_TimerRunner__SWIG_0(self,args);
8530 }
8531 }
8532 if ((argc >= 2) && (argc <= 3)) {
8533 int _v;
8534 {
8535 void *ptr = 0;
8536 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8537 _v = 0;
8538 PyErr_Clear();
8539 } else {
8540 _v = (ptr != 0);
8541 }
8542 }
8543 if (_v) {
8544 _v = SWIG_Check_int(argv[1]);
8545 if (_v) {
8546 if (argc <= 2) {
8547 return _wrap_new_TimerRunner__SWIG_1(self,args);
8548 }
8549 _v = SWIG_Check_bool(argv[2]);
8550 if (_v) {
8551 return _wrap_new_TimerRunner__SWIG_1(self,args);
8552 }
8553 }
8554 }
8555 }
8556
8557 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8558 return NULL;
8559 }
8560
8561
8562 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8563 PyObject *resultobj;
8564 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8565 PyObject * obj0 = 0 ;
8566 char *kwnames[] = {
8567 (char *) "self", NULL
8568 };
8569
8570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8572 if (SWIG_arg_fail(1)) SWIG_fail;
8573 {
8574 PyThreadState* __tstate = wxPyBeginAllowThreads();
8575 delete arg1;
8576
8577 wxPyEndAllowThreads(__tstate);
8578 if (PyErr_Occurred()) SWIG_fail;
8579 }
8580 Py_INCREF(Py_None); resultobj = Py_None;
8581 return resultobj;
8582 fail:
8583 return NULL;
8584 }
8585
8586
8587 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8588 PyObject *resultobj;
8589 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8590 int arg2 ;
8591 bool arg3 = (bool) false ;
8592 PyObject * obj0 = 0 ;
8593 PyObject * obj1 = 0 ;
8594 PyObject * obj2 = 0 ;
8595 char *kwnames[] = {
8596 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8597 };
8598
8599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8601 if (SWIG_arg_fail(1)) SWIG_fail;
8602 {
8603 arg2 = (int)(SWIG_As_int(obj1));
8604 if (SWIG_arg_fail(2)) SWIG_fail;
8605 }
8606 if (obj2) {
8607 {
8608 arg3 = (bool)(SWIG_As_bool(obj2));
8609 if (SWIG_arg_fail(3)) SWIG_fail;
8610 }
8611 }
8612 {
8613 PyThreadState* __tstate = wxPyBeginAllowThreads();
8614 (arg1)->Start(arg2,arg3);
8615
8616 wxPyEndAllowThreads(__tstate);
8617 if (PyErr_Occurred()) SWIG_fail;
8618 }
8619 Py_INCREF(Py_None); resultobj = Py_None;
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8627 PyObject *obj;
8628 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8629 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8630 Py_INCREF(obj);
8631 return Py_BuildValue((char *)"");
8632 }
8633 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8634 PyObject *resultobj;
8635 wxLog *result;
8636 char *kwnames[] = {
8637 NULL
8638 };
8639
8640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8641 {
8642 PyThreadState* __tstate = wxPyBeginAllowThreads();
8643 result = (wxLog *)new wxLog();
8644
8645 wxPyEndAllowThreads(__tstate);
8646 if (PyErr_Occurred()) SWIG_fail;
8647 }
8648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8649 return resultobj;
8650 fail:
8651 return NULL;
8652 }
8653
8654
8655 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8656 PyObject *resultobj;
8657 bool result;
8658 char *kwnames[] = {
8659 NULL
8660 };
8661
8662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8663 {
8664 PyThreadState* __tstate = wxPyBeginAllowThreads();
8665 result = (bool)wxLog::IsEnabled();
8666
8667 wxPyEndAllowThreads(__tstate);
8668 if (PyErr_Occurred()) SWIG_fail;
8669 }
8670 {
8671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8672 }
8673 return resultobj;
8674 fail:
8675 return NULL;
8676 }
8677
8678
8679 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj;
8681 bool arg1 = (bool) true ;
8682 bool result;
8683 PyObject * obj0 = 0 ;
8684 char *kwnames[] = {
8685 (char *) "doIt", NULL
8686 };
8687
8688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8689 if (obj0) {
8690 {
8691 arg1 = (bool)(SWIG_As_bool(obj0));
8692 if (SWIG_arg_fail(1)) SWIG_fail;
8693 }
8694 }
8695 {
8696 PyThreadState* __tstate = wxPyBeginAllowThreads();
8697 result = (bool)wxLog::EnableLogging(arg1);
8698
8699 wxPyEndAllowThreads(__tstate);
8700 if (PyErr_Occurred()) SWIG_fail;
8701 }
8702 {
8703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8704 }
8705 return resultobj;
8706 fail:
8707 return NULL;
8708 }
8709
8710
8711 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8712 PyObject *resultobj;
8713 wxLogLevel arg1 ;
8714 wxChar *arg2 = (wxChar *) 0 ;
8715 time_t arg3 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 PyObject * obj2 = 0 ;
8719 char *kwnames[] = {
8720 (char *) "level",(char *) "szString",(char *) "t", NULL
8721 };
8722
8723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8724 {
8725 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8726 if (SWIG_arg_fail(1)) SWIG_fail;
8727 }
8728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8729 if (SWIG_arg_fail(2)) SWIG_fail;
8730 {
8731 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8732 if (SWIG_arg_fail(3)) SWIG_fail;
8733 }
8734 {
8735 PyThreadState* __tstate = wxPyBeginAllowThreads();
8736 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8737
8738 wxPyEndAllowThreads(__tstate);
8739 if (PyErr_Occurred()) SWIG_fail;
8740 }
8741 Py_INCREF(Py_None); resultobj = Py_None;
8742 return resultobj;
8743 fail:
8744 return NULL;
8745 }
8746
8747
8748 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8749 PyObject *resultobj;
8750 wxLog *arg1 = (wxLog *) 0 ;
8751 PyObject * obj0 = 0 ;
8752 char *kwnames[] = {
8753 (char *) "self", NULL
8754 };
8755
8756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8758 if (SWIG_arg_fail(1)) SWIG_fail;
8759 {
8760 PyThreadState* __tstate = wxPyBeginAllowThreads();
8761 (arg1)->Flush();
8762
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 Py_INCREF(Py_None); resultobj = Py_None;
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8774 PyObject *resultobj;
8775 char *kwnames[] = {
8776 NULL
8777 };
8778
8779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8780 {
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 wxLog::FlushActive();
8783
8784 wxPyEndAllowThreads(__tstate);
8785 if (PyErr_Occurred()) SWIG_fail;
8786 }
8787 Py_INCREF(Py_None); resultobj = Py_None;
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8795 PyObject *resultobj;
8796 wxLog *result;
8797 char *kwnames[] = {
8798 NULL
8799 };
8800
8801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8802 {
8803 PyThreadState* __tstate = wxPyBeginAllowThreads();
8804 result = (wxLog *)wxLog::GetActiveTarget();
8805
8806 wxPyEndAllowThreads(__tstate);
8807 if (PyErr_Occurred()) SWIG_fail;
8808 }
8809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8810 return resultobj;
8811 fail:
8812 return NULL;
8813 }
8814
8815
8816 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8817 PyObject *resultobj;
8818 wxLog *arg1 = (wxLog *) 0 ;
8819 wxLog *result;
8820 PyObject * obj0 = 0 ;
8821 char *kwnames[] = {
8822 (char *) "pLogger", NULL
8823 };
8824
8825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8827 if (SWIG_arg_fail(1)) SWIG_fail;
8828 {
8829 PyThreadState* __tstate = wxPyBeginAllowThreads();
8830 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8831
8832 wxPyEndAllowThreads(__tstate);
8833 if (PyErr_Occurred()) SWIG_fail;
8834 }
8835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8836 return resultobj;
8837 fail:
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj;
8844 char *kwnames[] = {
8845 NULL
8846 };
8847
8848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 wxLog::Suspend();
8852
8853 wxPyEndAllowThreads(__tstate);
8854 if (PyErr_Occurred()) SWIG_fail;
8855 }
8856 Py_INCREF(Py_None); resultobj = Py_None;
8857 return resultobj;
8858 fail:
8859 return NULL;
8860 }
8861
8862
8863 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8864 PyObject *resultobj;
8865 char *kwnames[] = {
8866 NULL
8867 };
8868
8869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8870 {
8871 PyThreadState* __tstate = wxPyBeginAllowThreads();
8872 wxLog::Resume();
8873
8874 wxPyEndAllowThreads(__tstate);
8875 if (PyErr_Occurred()) SWIG_fail;
8876 }
8877 Py_INCREF(Py_None); resultobj = Py_None;
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj;
8886 bool arg1 = (bool) true ;
8887 PyObject * obj0 = 0 ;
8888 char *kwnames[] = {
8889 (char *) "bVerbose", NULL
8890 };
8891
8892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8893 if (obj0) {
8894 {
8895 arg1 = (bool)(SWIG_As_bool(obj0));
8896 if (SWIG_arg_fail(1)) SWIG_fail;
8897 }
8898 }
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 wxLog::SetVerbose(arg1);
8902
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 Py_INCREF(Py_None); resultobj = Py_None;
8907 return resultobj;
8908 fail:
8909 return NULL;
8910 }
8911
8912
8913 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj;
8915 wxLogLevel arg1 ;
8916 PyObject * obj0 = 0 ;
8917 char *kwnames[] = {
8918 (char *) "logLevel", NULL
8919 };
8920
8921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8922 {
8923 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8924 if (SWIG_arg_fail(1)) SWIG_fail;
8925 }
8926 {
8927 PyThreadState* __tstate = wxPyBeginAllowThreads();
8928 wxLog::SetLogLevel(arg1);
8929
8930 wxPyEndAllowThreads(__tstate);
8931 if (PyErr_Occurred()) SWIG_fail;
8932 }
8933 Py_INCREF(Py_None); resultobj = Py_None;
8934 return resultobj;
8935 fail:
8936 return NULL;
8937 }
8938
8939
8940 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8941 PyObject *resultobj;
8942 char *kwnames[] = {
8943 NULL
8944 };
8945
8946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8947 {
8948 PyThreadState* __tstate = wxPyBeginAllowThreads();
8949 wxLog::DontCreateOnDemand();
8950
8951 wxPyEndAllowThreads(__tstate);
8952 if (PyErr_Occurred()) SWIG_fail;
8953 }
8954 Py_INCREF(Py_None); resultobj = Py_None;
8955 return resultobj;
8956 fail:
8957 return NULL;
8958 }
8959
8960
8961 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8962 PyObject *resultobj;
8963 wxTraceMask arg1 ;
8964 PyObject * obj0 = 0 ;
8965 char *kwnames[] = {
8966 (char *) "ulMask", NULL
8967 };
8968
8969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8970 {
8971 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8972 if (SWIG_arg_fail(1)) SWIG_fail;
8973 }
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 wxLog::SetTraceMask(arg1);
8977
8978 wxPyEndAllowThreads(__tstate);
8979 if (PyErr_Occurred()) SWIG_fail;
8980 }
8981 Py_INCREF(Py_None); resultobj = Py_None;
8982 return resultobj;
8983 fail:
8984 return NULL;
8985 }
8986
8987
8988 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8989 PyObject *resultobj;
8990 wxString *arg1 = 0 ;
8991 bool temp1 = false ;
8992 PyObject * obj0 = 0 ;
8993 char *kwnames[] = {
8994 (char *) "str", NULL
8995 };
8996
8997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
8998 {
8999 arg1 = wxString_in_helper(obj0);
9000 if (arg1 == NULL) SWIG_fail;
9001 temp1 = true;
9002 }
9003 {
9004 PyThreadState* __tstate = wxPyBeginAllowThreads();
9005 wxLog::AddTraceMask((wxString const &)*arg1);
9006
9007 wxPyEndAllowThreads(__tstate);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 Py_INCREF(Py_None); resultobj = Py_None;
9011 {
9012 if (temp1)
9013 delete arg1;
9014 }
9015 return resultobj;
9016 fail:
9017 {
9018 if (temp1)
9019 delete arg1;
9020 }
9021 return NULL;
9022 }
9023
9024
9025 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9026 PyObject *resultobj;
9027 wxString *arg1 = 0 ;
9028 bool temp1 = false ;
9029 PyObject * obj0 = 0 ;
9030 char *kwnames[] = {
9031 (char *) "str", NULL
9032 };
9033
9034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9035 {
9036 arg1 = wxString_in_helper(obj0);
9037 if (arg1 == NULL) SWIG_fail;
9038 temp1 = true;
9039 }
9040 {
9041 PyThreadState* __tstate = wxPyBeginAllowThreads();
9042 wxLog::RemoveTraceMask((wxString const &)*arg1);
9043
9044 wxPyEndAllowThreads(__tstate);
9045 if (PyErr_Occurred()) SWIG_fail;
9046 }
9047 Py_INCREF(Py_None); resultobj = Py_None;
9048 {
9049 if (temp1)
9050 delete arg1;
9051 }
9052 return resultobj;
9053 fail:
9054 {
9055 if (temp1)
9056 delete arg1;
9057 }
9058 return NULL;
9059 }
9060
9061
9062 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj;
9064 char *kwnames[] = {
9065 NULL
9066 };
9067
9068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9069 {
9070 PyThreadState* __tstate = wxPyBeginAllowThreads();
9071 wxLog::ClearTraceMasks();
9072
9073 wxPyEndAllowThreads(__tstate);
9074 if (PyErr_Occurred()) SWIG_fail;
9075 }
9076 Py_INCREF(Py_None); resultobj = Py_None;
9077 return resultobj;
9078 fail:
9079 return NULL;
9080 }
9081
9082
9083 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9084 PyObject *resultobj;
9085 wxArrayString *result;
9086 char *kwnames[] = {
9087 NULL
9088 };
9089
9090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9091 {
9092 PyThreadState* __tstate = wxPyBeginAllowThreads();
9093 {
9094 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9095 result = (wxArrayString *) &_result_ref;
9096 }
9097
9098 wxPyEndAllowThreads(__tstate);
9099 if (PyErr_Occurred()) SWIG_fail;
9100 }
9101 {
9102 resultobj = wxArrayString2PyList_helper(*result);
9103 }
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj;
9112 wxChar *arg1 = (wxChar *) 0 ;
9113 PyObject * obj0 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "ts", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9120 if (SWIG_arg_fail(1)) SWIG_fail;
9121 {
9122 PyThreadState* __tstate = wxPyBeginAllowThreads();
9123 wxLog::SetTimestamp((wxChar const *)arg1);
9124
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 Py_INCREF(Py_None); resultobj = Py_None;
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj;
9137 bool result;
9138 char *kwnames[] = {
9139 NULL
9140 };
9141
9142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9143 {
9144 PyThreadState* __tstate = wxPyBeginAllowThreads();
9145 result = (bool)wxLog::GetVerbose();
9146
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 {
9151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9152 }
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj;
9161 wxTraceMask result;
9162 char *kwnames[] = {
9163 NULL
9164 };
9165
9166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9167 {
9168 PyThreadState* __tstate = wxPyBeginAllowThreads();
9169 result = (wxTraceMask)wxLog::GetTraceMask();
9170
9171 wxPyEndAllowThreads(__tstate);
9172 if (PyErr_Occurred()) SWIG_fail;
9173 }
9174 {
9175 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9176 }
9177 return resultobj;
9178 fail:
9179 return NULL;
9180 }
9181
9182
9183 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj;
9185 wxChar *arg1 = (wxChar *) 0 ;
9186 bool result;
9187 PyObject * obj0 = 0 ;
9188 char *kwnames[] = {
9189 (char *) "mask", NULL
9190 };
9191
9192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9194 if (SWIG_arg_fail(1)) SWIG_fail;
9195 {
9196 PyThreadState* __tstate = wxPyBeginAllowThreads();
9197 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9198
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 {
9203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9204 }
9205 return resultobj;
9206 fail:
9207 return NULL;
9208 }
9209
9210
9211 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9212 PyObject *resultobj;
9213 wxLogLevel result;
9214 char *kwnames[] = {
9215 NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 result = (wxLogLevel)wxLog::GetLogLevel();
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 {
9227 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9228 }
9229 return resultobj;
9230 fail:
9231 return NULL;
9232 }
9233
9234
9235 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9236 PyObject *resultobj;
9237 wxChar *result;
9238 char *kwnames[] = {
9239 NULL
9240 };
9241
9242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9243 {
9244 PyThreadState* __tstate = wxPyBeginAllowThreads();
9245 result = (wxChar *)wxLog::GetTimestamp();
9246
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9251 return resultobj;
9252 fail:
9253 return NULL;
9254 }
9255
9256
9257 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9258 PyObject *resultobj;
9259 wxString result;
9260 char *kwnames[] = {
9261 NULL
9262 };
9263
9264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9265 {
9266 PyThreadState* __tstate = wxPyBeginAllowThreads();
9267 result = Log_TimeStamp();
9268
9269 wxPyEndAllowThreads(__tstate);
9270 if (PyErr_Occurred()) SWIG_fail;
9271 }
9272 {
9273 #if wxUSE_UNICODE
9274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9275 #else
9276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9277 #endif
9278 }
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9286 PyObject *resultobj;
9287 wxLog *arg1 = (wxLog *) 0 ;
9288 PyObject * obj0 = 0 ;
9289 char *kwnames[] = {
9290 (char *) "self", NULL
9291 };
9292
9293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9295 if (SWIG_arg_fail(1)) SWIG_fail;
9296 {
9297 PyThreadState* __tstate = wxPyBeginAllowThreads();
9298 wxLog_Destroy(arg1);
9299
9300 wxPyEndAllowThreads(__tstate);
9301 if (PyErr_Occurred()) SWIG_fail;
9302 }
9303 Py_INCREF(Py_None); resultobj = Py_None;
9304 return resultobj;
9305 fail:
9306 return NULL;
9307 }
9308
9309
9310 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9311 PyObject *obj;
9312 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9313 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9314 Py_INCREF(obj);
9315 return Py_BuildValue((char *)"");
9316 }
9317 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9318 PyObject *resultobj;
9319 wxLogStderr *result;
9320 char *kwnames[] = {
9321 NULL
9322 };
9323
9324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 result = (wxLogStderr *)new wxLogStderr();
9328
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9340 PyObject *obj;
9341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9342 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9343 Py_INCREF(obj);
9344 return Py_BuildValue((char *)"");
9345 }
9346 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9347 PyObject *resultobj;
9348 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9349 wxLogTextCtrl *result;
9350 PyObject * obj0 = 0 ;
9351 char *kwnames[] = {
9352 (char *) "pTextCtrl", NULL
9353 };
9354
9355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9357 if (SWIG_arg_fail(1)) SWIG_fail;
9358 {
9359 PyThreadState* __tstate = wxPyBeginAllowThreads();
9360 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9361
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9373 PyObject *obj;
9374 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9375 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9376 Py_INCREF(obj);
9377 return Py_BuildValue((char *)"");
9378 }
9379 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9380 PyObject *resultobj;
9381 wxLogGui *result;
9382 char *kwnames[] = {
9383 NULL
9384 };
9385
9386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9387 {
9388 PyThreadState* __tstate = wxPyBeginAllowThreads();
9389 result = (wxLogGui *)new wxLogGui();
9390
9391 wxPyEndAllowThreads(__tstate);
9392 if (PyErr_Occurred()) SWIG_fail;
9393 }
9394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9395 return resultobj;
9396 fail:
9397 return NULL;
9398 }
9399
9400
9401 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9402 PyObject *obj;
9403 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9404 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9405 Py_INCREF(obj);
9406 return Py_BuildValue((char *)"");
9407 }
9408 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9409 PyObject *resultobj;
9410 wxFrame *arg1 = (wxFrame *) 0 ;
9411 wxString *arg2 = 0 ;
9412 bool arg3 = (bool) true ;
9413 bool arg4 = (bool) true ;
9414 wxLogWindow *result;
9415 bool temp2 = false ;
9416 PyObject * obj0 = 0 ;
9417 PyObject * obj1 = 0 ;
9418 PyObject * obj2 = 0 ;
9419 PyObject * obj3 = 0 ;
9420 char *kwnames[] = {
9421 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9422 };
9423
9424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9426 if (SWIG_arg_fail(1)) SWIG_fail;
9427 {
9428 arg2 = wxString_in_helper(obj1);
9429 if (arg2 == NULL) SWIG_fail;
9430 temp2 = true;
9431 }
9432 if (obj2) {
9433 {
9434 arg3 = (bool)(SWIG_As_bool(obj2));
9435 if (SWIG_arg_fail(3)) SWIG_fail;
9436 }
9437 }
9438 if (obj3) {
9439 {
9440 arg4 = (bool)(SWIG_As_bool(obj3));
9441 if (SWIG_arg_fail(4)) SWIG_fail;
9442 }
9443 }
9444 {
9445 PyThreadState* __tstate = wxPyBeginAllowThreads();
9446 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9447
9448 wxPyEndAllowThreads(__tstate);
9449 if (PyErr_Occurred()) SWIG_fail;
9450 }
9451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9452 {
9453 if (temp2)
9454 delete arg2;
9455 }
9456 return resultobj;
9457 fail:
9458 {
9459 if (temp2)
9460 delete arg2;
9461 }
9462 return NULL;
9463 }
9464
9465
9466 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9467 PyObject *resultobj;
9468 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9469 bool arg2 = (bool) true ;
9470 PyObject * obj0 = 0 ;
9471 PyObject * obj1 = 0 ;
9472 char *kwnames[] = {
9473 (char *) "self",(char *) "bShow", NULL
9474 };
9475
9476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9478 if (SWIG_arg_fail(1)) SWIG_fail;
9479 if (obj1) {
9480 {
9481 arg2 = (bool)(SWIG_As_bool(obj1));
9482 if (SWIG_arg_fail(2)) SWIG_fail;
9483 }
9484 }
9485 {
9486 PyThreadState* __tstate = wxPyBeginAllowThreads();
9487 (arg1)->Show(arg2);
9488
9489 wxPyEndAllowThreads(__tstate);
9490 if (PyErr_Occurred()) SWIG_fail;
9491 }
9492 Py_INCREF(Py_None); resultobj = Py_None;
9493 return resultobj;
9494 fail:
9495 return NULL;
9496 }
9497
9498
9499 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9500 PyObject *resultobj;
9501 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9502 wxFrame *result;
9503 PyObject * obj0 = 0 ;
9504 char *kwnames[] = {
9505 (char *) "self", NULL
9506 };
9507
9508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9510 if (SWIG_arg_fail(1)) SWIG_fail;
9511 {
9512 PyThreadState* __tstate = wxPyBeginAllowThreads();
9513 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9514
9515 wxPyEndAllowThreads(__tstate);
9516 if (PyErr_Occurred()) SWIG_fail;
9517 }
9518 {
9519 resultobj = wxPyMake_wxObject(result, 0);
9520 }
9521 return resultobj;
9522 fail:
9523 return NULL;
9524 }
9525
9526
9527 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9528 PyObject *resultobj;
9529 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9530 wxLog *result;
9531 PyObject * obj0 = 0 ;
9532 char *kwnames[] = {
9533 (char *) "self", NULL
9534 };
9535
9536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9538 if (SWIG_arg_fail(1)) SWIG_fail;
9539 {
9540 PyThreadState* __tstate = wxPyBeginAllowThreads();
9541 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9542
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9547 return resultobj;
9548 fail:
9549 return NULL;
9550 }
9551
9552
9553 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9554 PyObject *resultobj;
9555 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9556 bool result;
9557 PyObject * obj0 = 0 ;
9558 char *kwnames[] = {
9559 (char *) "self", NULL
9560 };
9561
9562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9564 if (SWIG_arg_fail(1)) SWIG_fail;
9565 {
9566 PyThreadState* __tstate = wxPyBeginAllowThreads();
9567 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9568
9569 wxPyEndAllowThreads(__tstate);
9570 if (PyErr_Occurred()) SWIG_fail;
9571 }
9572 {
9573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9574 }
9575 return resultobj;
9576 fail:
9577 return NULL;
9578 }
9579
9580
9581 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9582 PyObject *resultobj;
9583 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9584 bool arg2 ;
9585 PyObject * obj0 = 0 ;
9586 PyObject * obj1 = 0 ;
9587 char *kwnames[] = {
9588 (char *) "self",(char *) "bDoPass", NULL
9589 };
9590
9591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9593 if (SWIG_arg_fail(1)) SWIG_fail;
9594 {
9595 arg2 = (bool)(SWIG_As_bool(obj1));
9596 if (SWIG_arg_fail(2)) SWIG_fail;
9597 }
9598 {
9599 PyThreadState* __tstate = wxPyBeginAllowThreads();
9600 (arg1)->PassMessages(arg2);
9601
9602 wxPyEndAllowThreads(__tstate);
9603 if (PyErr_Occurred()) SWIG_fail;
9604 }
9605 Py_INCREF(Py_None); resultobj = Py_None;
9606 return resultobj;
9607 fail:
9608 return NULL;
9609 }
9610
9611
9612 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9613 PyObject *obj;
9614 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9615 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9616 Py_INCREF(obj);
9617 return Py_BuildValue((char *)"");
9618 }
9619 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj;
9621 wxLog *arg1 = (wxLog *) 0 ;
9622 wxLogChain *result;
9623 PyObject * obj0 = 0 ;
9624 char *kwnames[] = {
9625 (char *) "logger", NULL
9626 };
9627
9628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9630 if (SWIG_arg_fail(1)) SWIG_fail;
9631 {
9632 PyThreadState* __tstate = wxPyBeginAllowThreads();
9633 result = (wxLogChain *)new wxLogChain(arg1);
9634
9635 wxPyEndAllowThreads(__tstate);
9636 if (PyErr_Occurred()) SWIG_fail;
9637 }
9638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9639 return resultobj;
9640 fail:
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxLogChain *arg1 = (wxLogChain *) 0 ;
9648 wxLog *arg2 = (wxLog *) 0 ;
9649 PyObject * obj0 = 0 ;
9650 PyObject * obj1 = 0 ;
9651 char *kwnames[] = {
9652 (char *) "self",(char *) "logger", NULL
9653 };
9654
9655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9657 if (SWIG_arg_fail(1)) SWIG_fail;
9658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9659 if (SWIG_arg_fail(2)) SWIG_fail;
9660 {
9661 PyThreadState* __tstate = wxPyBeginAllowThreads();
9662 (arg1)->SetLog(arg2);
9663
9664 wxPyEndAllowThreads(__tstate);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 Py_INCREF(Py_None); resultobj = Py_None;
9668 return resultobj;
9669 fail:
9670 return NULL;
9671 }
9672
9673
9674 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9675 PyObject *resultobj;
9676 wxLogChain *arg1 = (wxLogChain *) 0 ;
9677 bool arg2 ;
9678 PyObject * obj0 = 0 ;
9679 PyObject * obj1 = 0 ;
9680 char *kwnames[] = {
9681 (char *) "self",(char *) "bDoPass", NULL
9682 };
9683
9684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9686 if (SWIG_arg_fail(1)) SWIG_fail;
9687 {
9688 arg2 = (bool)(SWIG_As_bool(obj1));
9689 if (SWIG_arg_fail(2)) SWIG_fail;
9690 }
9691 {
9692 PyThreadState* __tstate = wxPyBeginAllowThreads();
9693 (arg1)->PassMessages(arg2);
9694
9695 wxPyEndAllowThreads(__tstate);
9696 if (PyErr_Occurred()) SWIG_fail;
9697 }
9698 Py_INCREF(Py_None); resultobj = Py_None;
9699 return resultobj;
9700 fail:
9701 return NULL;
9702 }
9703
9704
9705 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9706 PyObject *resultobj;
9707 wxLogChain *arg1 = (wxLogChain *) 0 ;
9708 bool result;
9709 PyObject * obj0 = 0 ;
9710 char *kwnames[] = {
9711 (char *) "self", NULL
9712 };
9713
9714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9716 if (SWIG_arg_fail(1)) SWIG_fail;
9717 {
9718 PyThreadState* __tstate = wxPyBeginAllowThreads();
9719 result = (bool)(arg1)->IsPassingMessages();
9720
9721 wxPyEndAllowThreads(__tstate);
9722 if (PyErr_Occurred()) SWIG_fail;
9723 }
9724 {
9725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9726 }
9727 return resultobj;
9728 fail:
9729 return NULL;
9730 }
9731
9732
9733 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9734 PyObject *resultobj;
9735 wxLogChain *arg1 = (wxLogChain *) 0 ;
9736 wxLog *result;
9737 PyObject * obj0 = 0 ;
9738 char *kwnames[] = {
9739 (char *) "self", NULL
9740 };
9741
9742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9744 if (SWIG_arg_fail(1)) SWIG_fail;
9745 {
9746 PyThreadState* __tstate = wxPyBeginAllowThreads();
9747 result = (wxLog *)(arg1)->GetOldLog();
9748
9749 wxPyEndAllowThreads(__tstate);
9750 if (PyErr_Occurred()) SWIG_fail;
9751 }
9752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9753 return resultobj;
9754 fail:
9755 return NULL;
9756 }
9757
9758
9759 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9760 PyObject *obj;
9761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9762 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9763 Py_INCREF(obj);
9764 return Py_BuildValue((char *)"");
9765 }
9766 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9767 PyObject *resultobj;
9768 unsigned long result;
9769 char *kwnames[] = {
9770 NULL
9771 };
9772
9773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9774 {
9775 PyThreadState* __tstate = wxPyBeginAllowThreads();
9776 result = (unsigned long)wxSysErrorCode();
9777
9778 wxPyEndAllowThreads(__tstate);
9779 if (PyErr_Occurred()) SWIG_fail;
9780 }
9781 {
9782 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9783 }
9784 return resultobj;
9785 fail:
9786 return NULL;
9787 }
9788
9789
9790 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9791 PyObject *resultobj;
9792 unsigned long arg1 = (unsigned long) 0 ;
9793 wxString result;
9794 PyObject * obj0 = 0 ;
9795 char *kwnames[] = {
9796 (char *) "nErrCode", NULL
9797 };
9798
9799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9800 if (obj0) {
9801 {
9802 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9803 if (SWIG_arg_fail(1)) SWIG_fail;
9804 }
9805 }
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 result = wxSysErrorMsg(arg1);
9809
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 {
9814 #if wxUSE_UNICODE
9815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9816 #else
9817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9818 #endif
9819 }
9820 return resultobj;
9821 fail:
9822 return NULL;
9823 }
9824
9825
9826 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9827 PyObject *resultobj;
9828 wxString *arg1 = 0 ;
9829 bool temp1 = false ;
9830 PyObject * obj0 = 0 ;
9831 char *kwnames[] = {
9832 (char *) "msg", NULL
9833 };
9834
9835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9836 {
9837 arg1 = wxString_in_helper(obj0);
9838 if (arg1 == NULL) SWIG_fail;
9839 temp1 = true;
9840 }
9841 {
9842 PyThreadState* __tstate = wxPyBeginAllowThreads();
9843 wxPyLogFatalError((wxString const &)*arg1);
9844
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 Py_INCREF(Py_None); resultobj = Py_None;
9849 {
9850 if (temp1)
9851 delete arg1;
9852 }
9853 return resultobj;
9854 fail:
9855 {
9856 if (temp1)
9857 delete arg1;
9858 }
9859 return NULL;
9860 }
9861
9862
9863 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9864 PyObject *resultobj;
9865 wxString *arg1 = 0 ;
9866 bool temp1 = false ;
9867 PyObject * obj0 = 0 ;
9868 char *kwnames[] = {
9869 (char *) "msg", NULL
9870 };
9871
9872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9873 {
9874 arg1 = wxString_in_helper(obj0);
9875 if (arg1 == NULL) SWIG_fail;
9876 temp1 = true;
9877 }
9878 {
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 wxPyLogError((wxString const &)*arg1);
9881
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 Py_INCREF(Py_None); resultobj = Py_None;
9886 {
9887 if (temp1)
9888 delete arg1;
9889 }
9890 return resultobj;
9891 fail:
9892 {
9893 if (temp1)
9894 delete arg1;
9895 }
9896 return NULL;
9897 }
9898
9899
9900 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9901 PyObject *resultobj;
9902 wxString *arg1 = 0 ;
9903 bool temp1 = false ;
9904 PyObject * obj0 = 0 ;
9905 char *kwnames[] = {
9906 (char *) "msg", NULL
9907 };
9908
9909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9910 {
9911 arg1 = wxString_in_helper(obj0);
9912 if (arg1 == NULL) SWIG_fail;
9913 temp1 = true;
9914 }
9915 {
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 wxPyLogWarning((wxString const &)*arg1);
9918
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 Py_INCREF(Py_None); resultobj = Py_None;
9923 {
9924 if (temp1)
9925 delete arg1;
9926 }
9927 return resultobj;
9928 fail:
9929 {
9930 if (temp1)
9931 delete arg1;
9932 }
9933 return NULL;
9934 }
9935
9936
9937 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj;
9939 wxString *arg1 = 0 ;
9940 bool temp1 = false ;
9941 PyObject * obj0 = 0 ;
9942 char *kwnames[] = {
9943 (char *) "msg", NULL
9944 };
9945
9946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9947 {
9948 arg1 = wxString_in_helper(obj0);
9949 if (arg1 == NULL) SWIG_fail;
9950 temp1 = true;
9951 }
9952 {
9953 PyThreadState* __tstate = wxPyBeginAllowThreads();
9954 wxPyLogMessage((wxString const &)*arg1);
9955
9956 wxPyEndAllowThreads(__tstate);
9957 if (PyErr_Occurred()) SWIG_fail;
9958 }
9959 Py_INCREF(Py_None); resultobj = Py_None;
9960 {
9961 if (temp1)
9962 delete arg1;
9963 }
9964 return resultobj;
9965 fail:
9966 {
9967 if (temp1)
9968 delete arg1;
9969 }
9970 return NULL;
9971 }
9972
9973
9974 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9975 PyObject *resultobj;
9976 wxString *arg1 = 0 ;
9977 bool temp1 = false ;
9978 PyObject * obj0 = 0 ;
9979 char *kwnames[] = {
9980 (char *) "msg", NULL
9981 };
9982
9983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9984 {
9985 arg1 = wxString_in_helper(obj0);
9986 if (arg1 == NULL) SWIG_fail;
9987 temp1 = true;
9988 }
9989 {
9990 PyThreadState* __tstate = wxPyBeginAllowThreads();
9991 wxPyLogInfo((wxString const &)*arg1);
9992
9993 wxPyEndAllowThreads(__tstate);
9994 if (PyErr_Occurred()) SWIG_fail;
9995 }
9996 Py_INCREF(Py_None); resultobj = Py_None;
9997 {
9998 if (temp1)
9999 delete arg1;
10000 }
10001 return resultobj;
10002 fail:
10003 {
10004 if (temp1)
10005 delete arg1;
10006 }
10007 return NULL;
10008 }
10009
10010
10011 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10012 PyObject *resultobj;
10013 wxString *arg1 = 0 ;
10014 bool temp1 = false ;
10015 PyObject * obj0 = 0 ;
10016 char *kwnames[] = {
10017 (char *) "msg", NULL
10018 };
10019
10020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10021 {
10022 arg1 = wxString_in_helper(obj0);
10023 if (arg1 == NULL) SWIG_fail;
10024 temp1 = true;
10025 }
10026 {
10027 PyThreadState* __tstate = wxPyBeginAllowThreads();
10028 wxPyLogDebug((wxString const &)*arg1);
10029
10030 wxPyEndAllowThreads(__tstate);
10031 if (PyErr_Occurred()) SWIG_fail;
10032 }
10033 Py_INCREF(Py_None); resultobj = Py_None;
10034 {
10035 if (temp1)
10036 delete arg1;
10037 }
10038 return resultobj;
10039 fail:
10040 {
10041 if (temp1)
10042 delete arg1;
10043 }
10044 return NULL;
10045 }
10046
10047
10048 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10049 PyObject *resultobj;
10050 wxString *arg1 = 0 ;
10051 bool temp1 = false ;
10052 PyObject * obj0 = 0 ;
10053 char *kwnames[] = {
10054 (char *) "msg", NULL
10055 };
10056
10057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10058 {
10059 arg1 = wxString_in_helper(obj0);
10060 if (arg1 == NULL) SWIG_fail;
10061 temp1 = true;
10062 }
10063 {
10064 PyThreadState* __tstate = wxPyBeginAllowThreads();
10065 wxPyLogVerbose((wxString const &)*arg1);
10066
10067 wxPyEndAllowThreads(__tstate);
10068 if (PyErr_Occurred()) SWIG_fail;
10069 }
10070 Py_INCREF(Py_None); resultobj = Py_None;
10071 {
10072 if (temp1)
10073 delete arg1;
10074 }
10075 return resultobj;
10076 fail:
10077 {
10078 if (temp1)
10079 delete arg1;
10080 }
10081 return NULL;
10082 }
10083
10084
10085 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10086 PyObject *resultobj;
10087 wxString *arg1 = 0 ;
10088 bool temp1 = false ;
10089 PyObject * obj0 = 0 ;
10090 char *kwnames[] = {
10091 (char *) "msg", NULL
10092 };
10093
10094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10095 {
10096 arg1 = wxString_in_helper(obj0);
10097 if (arg1 == NULL) SWIG_fail;
10098 temp1 = true;
10099 }
10100 {
10101 PyThreadState* __tstate = wxPyBeginAllowThreads();
10102 wxPyLogStatus((wxString const &)*arg1);
10103
10104 wxPyEndAllowThreads(__tstate);
10105 if (PyErr_Occurred()) SWIG_fail;
10106 }
10107 Py_INCREF(Py_None); resultobj = Py_None;
10108 {
10109 if (temp1)
10110 delete arg1;
10111 }
10112 return resultobj;
10113 fail:
10114 {
10115 if (temp1)
10116 delete arg1;
10117 }
10118 return NULL;
10119 }
10120
10121
10122 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10123 PyObject *resultobj;
10124 wxFrame *arg1 = (wxFrame *) 0 ;
10125 wxString *arg2 = 0 ;
10126 bool temp2 = false ;
10127 PyObject * obj0 = 0 ;
10128 PyObject * obj1 = 0 ;
10129 char *kwnames[] = {
10130 (char *) "pFrame",(char *) "msg", NULL
10131 };
10132
10133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10135 if (SWIG_arg_fail(1)) SWIG_fail;
10136 {
10137 arg2 = wxString_in_helper(obj1);
10138 if (arg2 == NULL) SWIG_fail;
10139 temp2 = true;
10140 }
10141 {
10142 PyThreadState* __tstate = wxPyBeginAllowThreads();
10143 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10144
10145 wxPyEndAllowThreads(__tstate);
10146 if (PyErr_Occurred()) SWIG_fail;
10147 }
10148 Py_INCREF(Py_None); resultobj = Py_None;
10149 {
10150 if (temp2)
10151 delete arg2;
10152 }
10153 return resultobj;
10154 fail:
10155 {
10156 if (temp2)
10157 delete arg2;
10158 }
10159 return NULL;
10160 }
10161
10162
10163 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj;
10165 wxString *arg1 = 0 ;
10166 bool temp1 = false ;
10167 PyObject * obj0 = 0 ;
10168 char *kwnames[] = {
10169 (char *) "msg", NULL
10170 };
10171
10172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10173 {
10174 arg1 = wxString_in_helper(obj0);
10175 if (arg1 == NULL) SWIG_fail;
10176 temp1 = true;
10177 }
10178 {
10179 PyThreadState* __tstate = wxPyBeginAllowThreads();
10180 wxPyLogSysError((wxString const &)*arg1);
10181
10182 wxPyEndAllowThreads(__tstate);
10183 if (PyErr_Occurred()) SWIG_fail;
10184 }
10185 Py_INCREF(Py_None); resultobj = Py_None;
10186 {
10187 if (temp1)
10188 delete arg1;
10189 }
10190 return resultobj;
10191 fail:
10192 {
10193 if (temp1)
10194 delete arg1;
10195 }
10196 return NULL;
10197 }
10198
10199
10200 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10201 PyObject *resultobj;
10202 unsigned long arg1 ;
10203 wxString *arg2 = 0 ;
10204 bool temp2 = false ;
10205 PyObject * obj0 = 0 ;
10206 PyObject * obj1 = 0 ;
10207 char *kwnames[] = {
10208 (char *) "level",(char *) "msg", NULL
10209 };
10210
10211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10212 {
10213 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10214 if (SWIG_arg_fail(1)) SWIG_fail;
10215 }
10216 {
10217 arg2 = wxString_in_helper(obj1);
10218 if (arg2 == NULL) SWIG_fail;
10219 temp2 = true;
10220 }
10221 {
10222 PyThreadState* __tstate = wxPyBeginAllowThreads();
10223 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10224
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 Py_INCREF(Py_None); resultobj = Py_None;
10229 {
10230 if (temp2)
10231 delete arg2;
10232 }
10233 return resultobj;
10234 fail:
10235 {
10236 if (temp2)
10237 delete arg2;
10238 }
10239 return NULL;
10240 }
10241
10242
10243 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10244 PyObject *resultobj;
10245 unsigned long arg1 ;
10246 wxString *arg2 = 0 ;
10247 bool temp2 = false ;
10248 PyObject * obj0 = 0 ;
10249 PyObject * obj1 = 0 ;
10250
10251 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10252 {
10253 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10254 if (SWIG_arg_fail(1)) SWIG_fail;
10255 }
10256 {
10257 arg2 = wxString_in_helper(obj1);
10258 if (arg2 == NULL) SWIG_fail;
10259 temp2 = true;
10260 }
10261 {
10262 PyThreadState* __tstate = wxPyBeginAllowThreads();
10263 wxPyLogTrace(arg1,(wxString const &)*arg2);
10264
10265 wxPyEndAllowThreads(__tstate);
10266 if (PyErr_Occurred()) SWIG_fail;
10267 }
10268 Py_INCREF(Py_None); resultobj = Py_None;
10269 {
10270 if (temp2)
10271 delete arg2;
10272 }
10273 return resultobj;
10274 fail:
10275 {
10276 if (temp2)
10277 delete arg2;
10278 }
10279 return NULL;
10280 }
10281
10282
10283 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10284 PyObject *resultobj;
10285 wxString *arg1 = 0 ;
10286 wxString *arg2 = 0 ;
10287 bool temp1 = false ;
10288 bool temp2 = false ;
10289 PyObject * obj0 = 0 ;
10290 PyObject * obj1 = 0 ;
10291
10292 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10293 {
10294 arg1 = wxString_in_helper(obj0);
10295 if (arg1 == NULL) SWIG_fail;
10296 temp1 = true;
10297 }
10298 {
10299 arg2 = wxString_in_helper(obj1);
10300 if (arg2 == NULL) SWIG_fail;
10301 temp2 = true;
10302 }
10303 {
10304 PyThreadState* __tstate = wxPyBeginAllowThreads();
10305 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10306
10307 wxPyEndAllowThreads(__tstate);
10308 if (PyErr_Occurred()) SWIG_fail;
10309 }
10310 Py_INCREF(Py_None); resultobj = Py_None;
10311 {
10312 if (temp1)
10313 delete arg1;
10314 }
10315 {
10316 if (temp2)
10317 delete arg2;
10318 }
10319 return resultobj;
10320 fail:
10321 {
10322 if (temp1)
10323 delete arg1;
10324 }
10325 {
10326 if (temp2)
10327 delete arg2;
10328 }
10329 return NULL;
10330 }
10331
10332
10333 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10334 int argc;
10335 PyObject *argv[3];
10336 int ii;
10337
10338 argc = PyObject_Length(args);
10339 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10340 argv[ii] = PyTuple_GetItem(args,ii);
10341 }
10342 if (argc == 2) {
10343 int _v;
10344 {
10345 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10346 }
10347 if (_v) {
10348 {
10349 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10350 }
10351 if (_v) {
10352 return _wrap_LogTrace__SWIG_1(self,args);
10353 }
10354 }
10355 }
10356 if (argc == 2) {
10357 int _v;
10358 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10359 if (_v) {
10360 {
10361 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10362 }
10363 if (_v) {
10364 return _wrap_LogTrace__SWIG_0(self,args);
10365 }
10366 }
10367 }
10368
10369 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10370 return NULL;
10371 }
10372
10373
10374 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10375 PyObject *resultobj;
10376 wxString *arg1 = 0 ;
10377 wxString *arg2 = 0 ;
10378 bool temp1 = false ;
10379 bool temp2 = false ;
10380 PyObject * obj0 = 0 ;
10381 PyObject * obj1 = 0 ;
10382 char *kwnames[] = {
10383 (char *) "title",(char *) "text", NULL
10384 };
10385
10386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10387 {
10388 arg1 = wxString_in_helper(obj0);
10389 if (arg1 == NULL) SWIG_fail;
10390 temp1 = true;
10391 }
10392 {
10393 arg2 = wxString_in_helper(obj1);
10394 if (arg2 == NULL) SWIG_fail;
10395 temp2 = true;
10396 }
10397 {
10398 PyThreadState* __tstate = wxPyBeginAllowThreads();
10399 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10400
10401 wxPyEndAllowThreads(__tstate);
10402 if (PyErr_Occurred()) SWIG_fail;
10403 }
10404 Py_INCREF(Py_None); resultobj = Py_None;
10405 {
10406 if (temp1)
10407 delete arg1;
10408 }
10409 {
10410 if (temp2)
10411 delete arg2;
10412 }
10413 return resultobj;
10414 fail:
10415 {
10416 if (temp1)
10417 delete arg1;
10418 }
10419 {
10420 if (temp2)
10421 delete arg2;
10422 }
10423 return NULL;
10424 }
10425
10426
10427 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10428 PyObject *resultobj;
10429 wxLogNull *result;
10430 char *kwnames[] = {
10431 NULL
10432 };
10433
10434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10435 {
10436 PyThreadState* __tstate = wxPyBeginAllowThreads();
10437 result = (wxLogNull *)new wxLogNull();
10438
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10443 return resultobj;
10444 fail:
10445 return NULL;
10446 }
10447
10448
10449 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10450 PyObject *resultobj;
10451 wxLogNull *arg1 = (wxLogNull *) 0 ;
10452 PyObject * obj0 = 0 ;
10453 char *kwnames[] = {
10454 (char *) "self", NULL
10455 };
10456
10457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10459 if (SWIG_arg_fail(1)) SWIG_fail;
10460 {
10461 PyThreadState* __tstate = wxPyBeginAllowThreads();
10462 delete arg1;
10463
10464 wxPyEndAllowThreads(__tstate);
10465 if (PyErr_Occurred()) SWIG_fail;
10466 }
10467 Py_INCREF(Py_None); resultobj = Py_None;
10468 return resultobj;
10469 fail:
10470 return NULL;
10471 }
10472
10473
10474 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10475 PyObject *obj;
10476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10477 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10478 Py_INCREF(obj);
10479 return Py_BuildValue((char *)"");
10480 }
10481 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10482 PyObject *resultobj;
10483 wxPyLog *result;
10484 char *kwnames[] = {
10485 NULL
10486 };
10487
10488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = (wxPyLog *)new wxPyLog();
10492
10493 wxPyEndAllowThreads(__tstate);
10494 if (PyErr_Occurred()) SWIG_fail;
10495 }
10496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10497 return resultobj;
10498 fail:
10499 return NULL;
10500 }
10501
10502
10503 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10504 PyObject *resultobj;
10505 wxPyLog *arg1 = (wxPyLog *) 0 ;
10506 PyObject *arg2 = (PyObject *) 0 ;
10507 PyObject *arg3 = (PyObject *) 0 ;
10508 PyObject * obj0 = 0 ;
10509 PyObject * obj1 = 0 ;
10510 PyObject * obj2 = 0 ;
10511 char *kwnames[] = {
10512 (char *) "self",(char *) "self",(char *) "_class", NULL
10513 };
10514
10515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10517 if (SWIG_arg_fail(1)) SWIG_fail;
10518 arg2 = obj1;
10519 arg3 = obj2;
10520 {
10521 PyThreadState* __tstate = wxPyBeginAllowThreads();
10522 (arg1)->_setCallbackInfo(arg2,arg3);
10523
10524 wxPyEndAllowThreads(__tstate);
10525 if (PyErr_Occurred()) SWIG_fail;
10526 }
10527 Py_INCREF(Py_None); resultobj = Py_None;
10528 return resultobj;
10529 fail:
10530 return NULL;
10531 }
10532
10533
10534 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10535 PyObject *obj;
10536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10537 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10538 Py_INCREF(obj);
10539 return Py_BuildValue((char *)"");
10540 }
10541 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10542 PyObject *resultobj;
10543 int arg1 ;
10544 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10545 int arg3 = (int) wxKILL_NOCHILDREN ;
10546 wxKillError result;
10547 PyObject * obj0 = 0 ;
10548 PyObject * obj1 = 0 ;
10549 PyObject * obj2 = 0 ;
10550 char *kwnames[] = {
10551 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10552 };
10553
10554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10555 {
10556 arg1 = (int)(SWIG_As_int(obj0));
10557 if (SWIG_arg_fail(1)) SWIG_fail;
10558 }
10559 if (obj1) {
10560 {
10561 arg2 = (wxSignal)(SWIG_As_int(obj1));
10562 if (SWIG_arg_fail(2)) SWIG_fail;
10563 }
10564 }
10565 if (obj2) {
10566 {
10567 arg3 = (int)(SWIG_As_int(obj2));
10568 if (SWIG_arg_fail(3)) SWIG_fail;
10569 }
10570 }
10571 {
10572 PyThreadState* __tstate = wxPyBeginAllowThreads();
10573 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10574
10575 wxPyEndAllowThreads(__tstate);
10576 if (PyErr_Occurred()) SWIG_fail;
10577 }
10578 resultobj = SWIG_From_int((result));
10579 return resultobj;
10580 fail:
10581 return NULL;
10582 }
10583
10584
10585 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10586 PyObject *resultobj;
10587 int arg1 ;
10588 bool result;
10589 PyObject * obj0 = 0 ;
10590 char *kwnames[] = {
10591 (char *) "pid", NULL
10592 };
10593
10594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10595 {
10596 arg1 = (int)(SWIG_As_int(obj0));
10597 if (SWIG_arg_fail(1)) SWIG_fail;
10598 }
10599 {
10600 PyThreadState* __tstate = wxPyBeginAllowThreads();
10601 result = (bool)wxPyProcess::Exists(arg1);
10602
10603 wxPyEndAllowThreads(__tstate);
10604 if (PyErr_Occurred()) SWIG_fail;
10605 }
10606 {
10607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10608 }
10609 return resultobj;
10610 fail:
10611 return NULL;
10612 }
10613
10614
10615 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10616 PyObject *resultobj;
10617 wxString *arg1 = 0 ;
10618 int arg2 = (int) wxEXEC_ASYNC ;
10619 wxPyProcess *result;
10620 bool temp1 = false ;
10621 PyObject * obj0 = 0 ;
10622 PyObject * obj1 = 0 ;
10623 char *kwnames[] = {
10624 (char *) "cmd",(char *) "flags", NULL
10625 };
10626
10627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10628 {
10629 arg1 = wxString_in_helper(obj0);
10630 if (arg1 == NULL) SWIG_fail;
10631 temp1 = true;
10632 }
10633 if (obj1) {
10634 {
10635 arg2 = (int)(SWIG_As_int(obj1));
10636 if (SWIG_arg_fail(2)) SWIG_fail;
10637 }
10638 }
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10642
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10647 {
10648 if (temp1)
10649 delete arg1;
10650 }
10651 return resultobj;
10652 fail:
10653 {
10654 if (temp1)
10655 delete arg1;
10656 }
10657 return NULL;
10658 }
10659
10660
10661 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10662 PyObject *resultobj;
10663 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10664 int arg2 = (int) -1 ;
10665 wxPyProcess *result;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 char *kwnames[] = {
10669 (char *) "parent",(char *) "id", NULL
10670 };
10671
10672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10673 if (obj0) {
10674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10675 if (SWIG_arg_fail(1)) SWIG_fail;
10676 }
10677 if (obj1) {
10678 {
10679 arg2 = (int)(SWIG_As_int(obj1));
10680 if (SWIG_arg_fail(2)) SWIG_fail;
10681 }
10682 }
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10686
10687 wxPyEndAllowThreads(__tstate);
10688 if (PyErr_Occurred()) SWIG_fail;
10689 }
10690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10691 return resultobj;
10692 fail:
10693 return NULL;
10694 }
10695
10696
10697 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10698 PyObject *resultobj;
10699 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10700 PyObject *arg2 = (PyObject *) 0 ;
10701 PyObject *arg3 = (PyObject *) 0 ;
10702 PyObject * obj0 = 0 ;
10703 PyObject * obj1 = 0 ;
10704 PyObject * obj2 = 0 ;
10705 char *kwnames[] = {
10706 (char *) "self",(char *) "self",(char *) "_class", NULL
10707 };
10708
10709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10711 if (SWIG_arg_fail(1)) SWIG_fail;
10712 arg2 = obj1;
10713 arg3 = obj2;
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 (arg1)->_setCallbackInfo(arg2,arg3);
10717
10718 wxPyEndAllowThreads(__tstate);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 Py_INCREF(Py_None); resultobj = Py_None;
10722 return resultobj;
10723 fail:
10724 return NULL;
10725 }
10726
10727
10728 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10729 PyObject *resultobj;
10730 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10731 int arg2 ;
10732 int arg3 ;
10733 PyObject * obj0 = 0 ;
10734 PyObject * obj1 = 0 ;
10735 PyObject * obj2 = 0 ;
10736 char *kwnames[] = {
10737 (char *) "self",(char *) "pid",(char *) "status", NULL
10738 };
10739
10740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10742 if (SWIG_arg_fail(1)) SWIG_fail;
10743 {
10744 arg2 = (int)(SWIG_As_int(obj1));
10745 if (SWIG_arg_fail(2)) SWIG_fail;
10746 }
10747 {
10748 arg3 = (int)(SWIG_As_int(obj2));
10749 if (SWIG_arg_fail(3)) SWIG_fail;
10750 }
10751 {
10752 PyThreadState* __tstate = wxPyBeginAllowThreads();
10753 (arg1)->base_OnTerminate(arg2,arg3);
10754
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 Py_INCREF(Py_None); resultobj = Py_None;
10759 return resultobj;
10760 fail:
10761 return NULL;
10762 }
10763
10764
10765 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj;
10767 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10768 PyObject * obj0 = 0 ;
10769 char *kwnames[] = {
10770 (char *) "self", NULL
10771 };
10772
10773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10775 if (SWIG_arg_fail(1)) SWIG_fail;
10776 {
10777 PyThreadState* __tstate = wxPyBeginAllowThreads();
10778 (arg1)->Redirect();
10779
10780 wxPyEndAllowThreads(__tstate);
10781 if (PyErr_Occurred()) SWIG_fail;
10782 }
10783 Py_INCREF(Py_None); resultobj = Py_None;
10784 return resultobj;
10785 fail:
10786 return NULL;
10787 }
10788
10789
10790 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10791 PyObject *resultobj;
10792 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10793 bool result;
10794 PyObject * obj0 = 0 ;
10795 char *kwnames[] = {
10796 (char *) "self", NULL
10797 };
10798
10799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10801 if (SWIG_arg_fail(1)) SWIG_fail;
10802 {
10803 PyThreadState* __tstate = wxPyBeginAllowThreads();
10804 result = (bool)(arg1)->IsRedirected();
10805
10806 wxPyEndAllowThreads(__tstate);
10807 if (PyErr_Occurred()) SWIG_fail;
10808 }
10809 {
10810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10811 }
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10819 PyObject *resultobj;
10820 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10821 PyObject * obj0 = 0 ;
10822 char *kwnames[] = {
10823 (char *) "self", NULL
10824 };
10825
10826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10828 if (SWIG_arg_fail(1)) SWIG_fail;
10829 {
10830 PyThreadState* __tstate = wxPyBeginAllowThreads();
10831 (arg1)->Detach();
10832
10833 wxPyEndAllowThreads(__tstate);
10834 if (PyErr_Occurred()) SWIG_fail;
10835 }
10836 Py_INCREF(Py_None); resultobj = Py_None;
10837 return resultobj;
10838 fail:
10839 return NULL;
10840 }
10841
10842
10843 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10844 PyObject *resultobj;
10845 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10846 wxInputStream *result;
10847 PyObject * obj0 = 0 ;
10848 char *kwnames[] = {
10849 (char *) "self", NULL
10850 };
10851
10852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10854 if (SWIG_arg_fail(1)) SWIG_fail;
10855 {
10856 PyThreadState* __tstate = wxPyBeginAllowThreads();
10857 result = (wxInputStream *)(arg1)->GetInputStream();
10858
10859 wxPyEndAllowThreads(__tstate);
10860 if (PyErr_Occurred()) SWIG_fail;
10861 }
10862 {
10863 wxPyInputStream * _ptr = NULL;
10864
10865 if (result) {
10866 _ptr = new wxPyInputStream(result);
10867 }
10868 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10869 }
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10877 PyObject *resultobj;
10878 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10879 wxInputStream *result;
10880 PyObject * obj0 = 0 ;
10881 char *kwnames[] = {
10882 (char *) "self", NULL
10883 };
10884
10885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10887 if (SWIG_arg_fail(1)) SWIG_fail;
10888 {
10889 PyThreadState* __tstate = wxPyBeginAllowThreads();
10890 result = (wxInputStream *)(arg1)->GetErrorStream();
10891
10892 wxPyEndAllowThreads(__tstate);
10893 if (PyErr_Occurred()) SWIG_fail;
10894 }
10895 {
10896 wxPyInputStream * _ptr = NULL;
10897
10898 if (result) {
10899 _ptr = new wxPyInputStream(result);
10900 }
10901 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10902 }
10903 return resultobj;
10904 fail:
10905 return NULL;
10906 }
10907
10908
10909 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10910 PyObject *resultobj;
10911 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10912 wxOutputStream *result;
10913 PyObject * obj0 = 0 ;
10914 char *kwnames[] = {
10915 (char *) "self", NULL
10916 };
10917
10918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10920 if (SWIG_arg_fail(1)) SWIG_fail;
10921 {
10922 PyThreadState* __tstate = wxPyBeginAllowThreads();
10923 result = (wxOutputStream *)(arg1)->GetOutputStream();
10924
10925 wxPyEndAllowThreads(__tstate);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10929 return resultobj;
10930 fail:
10931 return NULL;
10932 }
10933
10934
10935 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10936 PyObject *resultobj;
10937 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10938 PyObject * obj0 = 0 ;
10939 char *kwnames[] = {
10940 (char *) "self", NULL
10941 };
10942
10943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10945 if (SWIG_arg_fail(1)) SWIG_fail;
10946 {
10947 PyThreadState* __tstate = wxPyBeginAllowThreads();
10948 (arg1)->CloseOutput();
10949
10950 wxPyEndAllowThreads(__tstate);
10951 if (PyErr_Occurred()) SWIG_fail;
10952 }
10953 Py_INCREF(Py_None); resultobj = Py_None;
10954 return resultobj;
10955 fail:
10956 return NULL;
10957 }
10958
10959
10960 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10961 PyObject *resultobj;
10962 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10963 bool result;
10964 PyObject * obj0 = 0 ;
10965 char *kwnames[] = {
10966 (char *) "self", NULL
10967 };
10968
10969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10971 if (SWIG_arg_fail(1)) SWIG_fail;
10972 {
10973 PyThreadState* __tstate = wxPyBeginAllowThreads();
10974 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10975
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 {
10980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10981 }
10982 return resultobj;
10983 fail:
10984 return NULL;
10985 }
10986
10987
10988 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10989 PyObject *resultobj;
10990 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10991 bool result;
10992 PyObject * obj0 = 0 ;
10993 char *kwnames[] = {
10994 (char *) "self", NULL
10995 };
10996
10997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
10998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10999 if (SWIG_arg_fail(1)) SWIG_fail;
11000 {
11001 PyThreadState* __tstate = wxPyBeginAllowThreads();
11002 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11003
11004 wxPyEndAllowThreads(__tstate);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 {
11008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11009 }
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11017 PyObject *resultobj;
11018 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11019 bool result;
11020 PyObject * obj0 = 0 ;
11021 char *kwnames[] = {
11022 (char *) "self", NULL
11023 };
11024
11025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11027 if (SWIG_arg_fail(1)) SWIG_fail;
11028 {
11029 PyThreadState* __tstate = wxPyBeginAllowThreads();
11030 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11031
11032 wxPyEndAllowThreads(__tstate);
11033 if (PyErr_Occurred()) SWIG_fail;
11034 }
11035 {
11036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11037 }
11038 return resultobj;
11039 fail:
11040 return NULL;
11041 }
11042
11043
11044 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11045 PyObject *obj;
11046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11047 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11048 Py_INCREF(obj);
11049 return Py_BuildValue((char *)"");
11050 }
11051 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11052 PyObject *resultobj;
11053 int arg1 = (int) 0 ;
11054 int arg2 = (int) 0 ;
11055 int arg3 = (int) 0 ;
11056 wxProcessEvent *result;
11057 PyObject * obj0 = 0 ;
11058 PyObject * obj1 = 0 ;
11059 PyObject * obj2 = 0 ;
11060 char *kwnames[] = {
11061 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11062 };
11063
11064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11065 if (obj0) {
11066 {
11067 arg1 = (int)(SWIG_As_int(obj0));
11068 if (SWIG_arg_fail(1)) SWIG_fail;
11069 }
11070 }
11071 if (obj1) {
11072 {
11073 arg2 = (int)(SWIG_As_int(obj1));
11074 if (SWIG_arg_fail(2)) SWIG_fail;
11075 }
11076 }
11077 if (obj2) {
11078 {
11079 arg3 = (int)(SWIG_As_int(obj2));
11080 if (SWIG_arg_fail(3)) SWIG_fail;
11081 }
11082 }
11083 {
11084 PyThreadState* __tstate = wxPyBeginAllowThreads();
11085 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11086
11087 wxPyEndAllowThreads(__tstate);
11088 if (PyErr_Occurred()) SWIG_fail;
11089 }
11090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11091 return resultobj;
11092 fail:
11093 return NULL;
11094 }
11095
11096
11097 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11098 PyObject *resultobj;
11099 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11100 int result;
11101 PyObject * obj0 = 0 ;
11102 char *kwnames[] = {
11103 (char *) "self", NULL
11104 };
11105
11106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11108 if (SWIG_arg_fail(1)) SWIG_fail;
11109 {
11110 PyThreadState* __tstate = wxPyBeginAllowThreads();
11111 result = (int)(arg1)->GetPid();
11112
11113 wxPyEndAllowThreads(__tstate);
11114 if (PyErr_Occurred()) SWIG_fail;
11115 }
11116 {
11117 resultobj = SWIG_From_int((int)(result));
11118 }
11119 return resultobj;
11120 fail:
11121 return NULL;
11122 }
11123
11124
11125 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11126 PyObject *resultobj;
11127 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11128 int result;
11129 PyObject * obj0 = 0 ;
11130 char *kwnames[] = {
11131 (char *) "self", NULL
11132 };
11133
11134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11136 if (SWIG_arg_fail(1)) SWIG_fail;
11137 {
11138 PyThreadState* __tstate = wxPyBeginAllowThreads();
11139 result = (int)(arg1)->GetExitCode();
11140
11141 wxPyEndAllowThreads(__tstate);
11142 if (PyErr_Occurred()) SWIG_fail;
11143 }
11144 {
11145 resultobj = SWIG_From_int((int)(result));
11146 }
11147 return resultobj;
11148 fail:
11149 return NULL;
11150 }
11151
11152
11153 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11154 PyObject *resultobj;
11155 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11156 int arg2 ;
11157 PyObject * obj0 = 0 ;
11158 PyObject * obj1 = 0 ;
11159 char *kwnames[] = {
11160 (char *) "self",(char *) "m_pid", NULL
11161 };
11162
11163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11165 if (SWIG_arg_fail(1)) SWIG_fail;
11166 {
11167 arg2 = (int)(SWIG_As_int(obj1));
11168 if (SWIG_arg_fail(2)) SWIG_fail;
11169 }
11170 if (arg1) (arg1)->m_pid = arg2;
11171
11172 Py_INCREF(Py_None); resultobj = Py_None;
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11180 PyObject *resultobj;
11181 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11182 int result;
11183 PyObject * obj0 = 0 ;
11184 char *kwnames[] = {
11185 (char *) "self", NULL
11186 };
11187
11188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11190 if (SWIG_arg_fail(1)) SWIG_fail;
11191 result = (int) ((arg1)->m_pid);
11192
11193 {
11194 resultobj = SWIG_From_int((int)(result));
11195 }
11196 return resultobj;
11197 fail:
11198 return NULL;
11199 }
11200
11201
11202 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11203 PyObject *resultobj;
11204 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11205 int arg2 ;
11206 PyObject * obj0 = 0 ;
11207 PyObject * obj1 = 0 ;
11208 char *kwnames[] = {
11209 (char *) "self",(char *) "m_exitcode", NULL
11210 };
11211
11212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11214 if (SWIG_arg_fail(1)) SWIG_fail;
11215 {
11216 arg2 = (int)(SWIG_As_int(obj1));
11217 if (SWIG_arg_fail(2)) SWIG_fail;
11218 }
11219 if (arg1) (arg1)->m_exitcode = arg2;
11220
11221 Py_INCREF(Py_None); resultobj = Py_None;
11222 return resultobj;
11223 fail:
11224 return NULL;
11225 }
11226
11227
11228 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11229 PyObject *resultobj;
11230 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11231 int result;
11232 PyObject * obj0 = 0 ;
11233 char *kwnames[] = {
11234 (char *) "self", NULL
11235 };
11236
11237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11239 if (SWIG_arg_fail(1)) SWIG_fail;
11240 result = (int) ((arg1)->m_exitcode);
11241
11242 {
11243 resultobj = SWIG_From_int((int)(result));
11244 }
11245 return resultobj;
11246 fail:
11247 return NULL;
11248 }
11249
11250
11251 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11252 PyObject *obj;
11253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11254 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11255 Py_INCREF(obj);
11256 return Py_BuildValue((char *)"");
11257 }
11258 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj;
11260 wxString *arg1 = 0 ;
11261 int arg2 = (int) wxEXEC_ASYNC ;
11262 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11263 long result;
11264 bool temp1 = false ;
11265 PyObject * obj0 = 0 ;
11266 PyObject * obj1 = 0 ;
11267 PyObject * obj2 = 0 ;
11268 char *kwnames[] = {
11269 (char *) "command",(char *) "flags",(char *) "process", NULL
11270 };
11271
11272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11273 {
11274 arg1 = wxString_in_helper(obj0);
11275 if (arg1 == NULL) SWIG_fail;
11276 temp1 = true;
11277 }
11278 if (obj1) {
11279 {
11280 arg2 = (int)(SWIG_As_int(obj1));
11281 if (SWIG_arg_fail(2)) SWIG_fail;
11282 }
11283 }
11284 if (obj2) {
11285 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11286 if (SWIG_arg_fail(3)) SWIG_fail;
11287 }
11288 {
11289 if (!wxPyCheckForApp()) SWIG_fail;
11290 PyThreadState* __tstate = wxPyBeginAllowThreads();
11291 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11292
11293 wxPyEndAllowThreads(__tstate);
11294 if (PyErr_Occurred()) SWIG_fail;
11295 }
11296 {
11297 resultobj = SWIG_From_long((long)(result));
11298 }
11299 {
11300 if (temp1)
11301 delete arg1;
11302 }
11303 return resultobj;
11304 fail:
11305 {
11306 if (temp1)
11307 delete arg1;
11308 }
11309 return NULL;
11310 }
11311
11312
11313 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11314 PyObject *resultobj;
11315 long arg1 ;
11316 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11317 wxKillError *arg3 = (wxKillError *) 0 ;
11318 int arg4 = (int) wxKILL_NOCHILDREN ;
11319 int result;
11320 wxKillError temp3 ;
11321 PyObject * obj0 = 0 ;
11322 PyObject * obj1 = 0 ;
11323 PyObject * obj2 = 0 ;
11324 char *kwnames[] = {
11325 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11326 };
11327
11328 {
11329 arg3 = &temp3;
11330 }
11331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11332 {
11333 arg1 = (long)(SWIG_As_long(obj0));
11334 if (SWIG_arg_fail(1)) SWIG_fail;
11335 }
11336 if (obj1) {
11337 {
11338 arg2 = (wxSignal)(SWIG_As_int(obj1));
11339 if (SWIG_arg_fail(2)) SWIG_fail;
11340 }
11341 }
11342 if (obj2) {
11343 {
11344 arg4 = (int)(SWIG_As_int(obj2));
11345 if (SWIG_arg_fail(4)) SWIG_fail;
11346 }
11347 }
11348 {
11349 PyThreadState* __tstate = wxPyBeginAllowThreads();
11350 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11351
11352 wxPyEndAllowThreads(__tstate);
11353 if (PyErr_Occurred()) SWIG_fail;
11354 }
11355 {
11356 resultobj = SWIG_From_int((int)(result));
11357 }
11358 {
11359 PyObject* o;
11360 o = PyInt_FromLong((long) (*arg3));
11361 resultobj = t_output_helper(resultobj, o);
11362 }
11363 return resultobj;
11364 fail:
11365 return NULL;
11366 }
11367
11368
11369 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11370 PyObject *resultobj;
11371 int arg1 = (int) wxJOYSTICK1 ;
11372 wxJoystick *result;
11373 PyObject * obj0 = 0 ;
11374 char *kwnames[] = {
11375 (char *) "joystick", NULL
11376 };
11377
11378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11379 if (obj0) {
11380 {
11381 arg1 = (int)(SWIG_As_int(obj0));
11382 if (SWIG_arg_fail(1)) SWIG_fail;
11383 }
11384 }
11385 {
11386 if (!wxPyCheckForApp()) SWIG_fail;
11387 PyThreadState* __tstate = wxPyBeginAllowThreads();
11388 result = (wxJoystick *)new wxJoystick(arg1);
11389
11390 wxPyEndAllowThreads(__tstate);
11391 if (PyErr_Occurred()) SWIG_fail;
11392 }
11393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11394 return resultobj;
11395 fail:
11396 return NULL;
11397 }
11398
11399
11400 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11401 PyObject *resultobj;
11402 wxJoystick *arg1 = (wxJoystick *) 0 ;
11403 PyObject * obj0 = 0 ;
11404 char *kwnames[] = {
11405 (char *) "self", NULL
11406 };
11407
11408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11410 if (SWIG_arg_fail(1)) SWIG_fail;
11411 {
11412 PyThreadState* __tstate = wxPyBeginAllowThreads();
11413 delete arg1;
11414
11415 wxPyEndAllowThreads(__tstate);
11416 if (PyErr_Occurred()) SWIG_fail;
11417 }
11418 Py_INCREF(Py_None); resultobj = Py_None;
11419 return resultobj;
11420 fail:
11421 return NULL;
11422 }
11423
11424
11425 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11426 PyObject *resultobj;
11427 wxJoystick *arg1 = (wxJoystick *) 0 ;
11428 wxPoint result;
11429 PyObject * obj0 = 0 ;
11430 char *kwnames[] = {
11431 (char *) "self", NULL
11432 };
11433
11434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11436 if (SWIG_arg_fail(1)) SWIG_fail;
11437 {
11438 PyThreadState* __tstate = wxPyBeginAllowThreads();
11439 result = (arg1)->GetPosition();
11440
11441 wxPyEndAllowThreads(__tstate);
11442 if (PyErr_Occurred()) SWIG_fail;
11443 }
11444 {
11445 wxPoint * resultptr;
11446 resultptr = new wxPoint((wxPoint &)(result));
11447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11448 }
11449 return resultobj;
11450 fail:
11451 return NULL;
11452 }
11453
11454
11455 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11456 PyObject *resultobj;
11457 wxJoystick *arg1 = (wxJoystick *) 0 ;
11458 int result;
11459 PyObject * obj0 = 0 ;
11460 char *kwnames[] = {
11461 (char *) "self", NULL
11462 };
11463
11464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11466 if (SWIG_arg_fail(1)) SWIG_fail;
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 result = (int)(arg1)->GetZPosition();
11470
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 {
11475 resultobj = SWIG_From_int((int)(result));
11476 }
11477 return resultobj;
11478 fail:
11479 return NULL;
11480 }
11481
11482
11483 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11484 PyObject *resultobj;
11485 wxJoystick *arg1 = (wxJoystick *) 0 ;
11486 int result;
11487 PyObject * obj0 = 0 ;
11488 char *kwnames[] = {
11489 (char *) "self", NULL
11490 };
11491
11492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11494 if (SWIG_arg_fail(1)) SWIG_fail;
11495 {
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 result = (int)(arg1)->GetButtonState();
11498
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 {
11503 resultobj = SWIG_From_int((int)(result));
11504 }
11505 return resultobj;
11506 fail:
11507 return NULL;
11508 }
11509
11510
11511 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11512 PyObject *resultobj;
11513 wxJoystick *arg1 = (wxJoystick *) 0 ;
11514 int result;
11515 PyObject * obj0 = 0 ;
11516 char *kwnames[] = {
11517 (char *) "self", NULL
11518 };
11519
11520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11522 if (SWIG_arg_fail(1)) SWIG_fail;
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 result = (int)(arg1)->GetPOVPosition();
11526
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 {
11531 resultobj = SWIG_From_int((int)(result));
11532 }
11533 return resultobj;
11534 fail:
11535 return NULL;
11536 }
11537
11538
11539 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11540 PyObject *resultobj;
11541 wxJoystick *arg1 = (wxJoystick *) 0 ;
11542 int result;
11543 PyObject * obj0 = 0 ;
11544 char *kwnames[] = {
11545 (char *) "self", NULL
11546 };
11547
11548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11550 if (SWIG_arg_fail(1)) SWIG_fail;
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 result = (int)(arg1)->GetPOVCTSPosition();
11554
11555 wxPyEndAllowThreads(__tstate);
11556 if (PyErr_Occurred()) SWIG_fail;
11557 }
11558 {
11559 resultobj = SWIG_From_int((int)(result));
11560 }
11561 return resultobj;
11562 fail:
11563 return NULL;
11564 }
11565
11566
11567 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11568 PyObject *resultobj;
11569 wxJoystick *arg1 = (wxJoystick *) 0 ;
11570 int result;
11571 PyObject * obj0 = 0 ;
11572 char *kwnames[] = {
11573 (char *) "self", NULL
11574 };
11575
11576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11578 if (SWIG_arg_fail(1)) SWIG_fail;
11579 {
11580 PyThreadState* __tstate = wxPyBeginAllowThreads();
11581 result = (int)(arg1)->GetRudderPosition();
11582
11583 wxPyEndAllowThreads(__tstate);
11584 if (PyErr_Occurred()) SWIG_fail;
11585 }
11586 {
11587 resultobj = SWIG_From_int((int)(result));
11588 }
11589 return resultobj;
11590 fail:
11591 return NULL;
11592 }
11593
11594
11595 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11596 PyObject *resultobj;
11597 wxJoystick *arg1 = (wxJoystick *) 0 ;
11598 int result;
11599 PyObject * obj0 = 0 ;
11600 char *kwnames[] = {
11601 (char *) "self", NULL
11602 };
11603
11604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11606 if (SWIG_arg_fail(1)) SWIG_fail;
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (int)(arg1)->GetUPosition();
11610
11611 wxPyEndAllowThreads(__tstate);
11612 if (PyErr_Occurred()) SWIG_fail;
11613 }
11614 {
11615 resultobj = SWIG_From_int((int)(result));
11616 }
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11624 PyObject *resultobj;
11625 wxJoystick *arg1 = (wxJoystick *) 0 ;
11626 int result;
11627 PyObject * obj0 = 0 ;
11628 char *kwnames[] = {
11629 (char *) "self", NULL
11630 };
11631
11632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11634 if (SWIG_arg_fail(1)) SWIG_fail;
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 result = (int)(arg1)->GetVPosition();
11638
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 {
11643 resultobj = SWIG_From_int((int)(result));
11644 }
11645 return resultobj;
11646 fail:
11647 return NULL;
11648 }
11649
11650
11651 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11652 PyObject *resultobj;
11653 wxJoystick *arg1 = (wxJoystick *) 0 ;
11654 int result;
11655 PyObject * obj0 = 0 ;
11656 char *kwnames[] = {
11657 (char *) "self", NULL
11658 };
11659
11660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11662 if (SWIG_arg_fail(1)) SWIG_fail;
11663 {
11664 PyThreadState* __tstate = wxPyBeginAllowThreads();
11665 result = (int)(arg1)->GetMovementThreshold();
11666
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 {
11671 resultobj = SWIG_From_int((int)(result));
11672 }
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxJoystick *arg1 = (wxJoystick *) 0 ;
11682 int arg2 ;
11683 PyObject * obj0 = 0 ;
11684 PyObject * obj1 = 0 ;
11685 char *kwnames[] = {
11686 (char *) "self",(char *) "threshold", NULL
11687 };
11688
11689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11691 if (SWIG_arg_fail(1)) SWIG_fail;
11692 {
11693 arg2 = (int)(SWIG_As_int(obj1));
11694 if (SWIG_arg_fail(2)) SWIG_fail;
11695 }
11696 {
11697 PyThreadState* __tstate = wxPyBeginAllowThreads();
11698 (arg1)->SetMovementThreshold(arg2);
11699
11700 wxPyEndAllowThreads(__tstate);
11701 if (PyErr_Occurred()) SWIG_fail;
11702 }
11703 Py_INCREF(Py_None); resultobj = Py_None;
11704 return resultobj;
11705 fail:
11706 return NULL;
11707 }
11708
11709
11710 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11711 PyObject *resultobj;
11712 wxJoystick *arg1 = (wxJoystick *) 0 ;
11713 bool result;
11714 PyObject * obj0 = 0 ;
11715 char *kwnames[] = {
11716 (char *) "self", NULL
11717 };
11718
11719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11721 if (SWIG_arg_fail(1)) SWIG_fail;
11722 {
11723 PyThreadState* __tstate = wxPyBeginAllowThreads();
11724 result = (bool)(arg1)->IsOk();
11725
11726 wxPyEndAllowThreads(__tstate);
11727 if (PyErr_Occurred()) SWIG_fail;
11728 }
11729 {
11730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11731 }
11732 return resultobj;
11733 fail:
11734 return NULL;
11735 }
11736
11737
11738 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11739 PyObject *resultobj;
11740 wxJoystick *arg1 = (wxJoystick *) 0 ;
11741 int result;
11742 PyObject * obj0 = 0 ;
11743 char *kwnames[] = {
11744 (char *) "self", NULL
11745 };
11746
11747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11749 if (SWIG_arg_fail(1)) SWIG_fail;
11750 {
11751 PyThreadState* __tstate = wxPyBeginAllowThreads();
11752 result = (int)(arg1)->GetNumberJoysticks();
11753
11754 wxPyEndAllowThreads(__tstate);
11755 if (PyErr_Occurred()) SWIG_fail;
11756 }
11757 {
11758 resultobj = SWIG_From_int((int)(result));
11759 }
11760 return resultobj;
11761 fail:
11762 return NULL;
11763 }
11764
11765
11766 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11767 PyObject *resultobj;
11768 wxJoystick *arg1 = (wxJoystick *) 0 ;
11769 int result;
11770 PyObject * obj0 = 0 ;
11771 char *kwnames[] = {
11772 (char *) "self", NULL
11773 };
11774
11775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11777 if (SWIG_arg_fail(1)) SWIG_fail;
11778 {
11779 PyThreadState* __tstate = wxPyBeginAllowThreads();
11780 result = (int)(arg1)->GetManufacturerId();
11781
11782 wxPyEndAllowThreads(__tstate);
11783 if (PyErr_Occurred()) SWIG_fail;
11784 }
11785 {
11786 resultobj = SWIG_From_int((int)(result));
11787 }
11788 return resultobj;
11789 fail:
11790 return NULL;
11791 }
11792
11793
11794 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11795 PyObject *resultobj;
11796 wxJoystick *arg1 = (wxJoystick *) 0 ;
11797 int result;
11798 PyObject * obj0 = 0 ;
11799 char *kwnames[] = {
11800 (char *) "self", NULL
11801 };
11802
11803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11805 if (SWIG_arg_fail(1)) SWIG_fail;
11806 {
11807 PyThreadState* __tstate = wxPyBeginAllowThreads();
11808 result = (int)(arg1)->GetProductId();
11809
11810 wxPyEndAllowThreads(__tstate);
11811 if (PyErr_Occurred()) SWIG_fail;
11812 }
11813 {
11814 resultobj = SWIG_From_int((int)(result));
11815 }
11816 return resultobj;
11817 fail:
11818 return NULL;
11819 }
11820
11821
11822 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11823 PyObject *resultobj;
11824 wxJoystick *arg1 = (wxJoystick *) 0 ;
11825 wxString result;
11826 PyObject * obj0 = 0 ;
11827 char *kwnames[] = {
11828 (char *) "self", NULL
11829 };
11830
11831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11833 if (SWIG_arg_fail(1)) SWIG_fail;
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (arg1)->GetProductName();
11837
11838 wxPyEndAllowThreads(__tstate);
11839 if (PyErr_Occurred()) SWIG_fail;
11840 }
11841 {
11842 #if wxUSE_UNICODE
11843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11844 #else
11845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11846 #endif
11847 }
11848 return resultobj;
11849 fail:
11850 return NULL;
11851 }
11852
11853
11854 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11855 PyObject *resultobj;
11856 wxJoystick *arg1 = (wxJoystick *) 0 ;
11857 int result;
11858 PyObject * obj0 = 0 ;
11859 char *kwnames[] = {
11860 (char *) "self", NULL
11861 };
11862
11863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11865 if (SWIG_arg_fail(1)) SWIG_fail;
11866 {
11867 PyThreadState* __tstate = wxPyBeginAllowThreads();
11868 result = (int)(arg1)->GetXMin();
11869
11870 wxPyEndAllowThreads(__tstate);
11871 if (PyErr_Occurred()) SWIG_fail;
11872 }
11873 {
11874 resultobj = SWIG_From_int((int)(result));
11875 }
11876 return resultobj;
11877 fail:
11878 return NULL;
11879 }
11880
11881
11882 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11883 PyObject *resultobj;
11884 wxJoystick *arg1 = (wxJoystick *) 0 ;
11885 int result;
11886 PyObject * obj0 = 0 ;
11887 char *kwnames[] = {
11888 (char *) "self", NULL
11889 };
11890
11891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11893 if (SWIG_arg_fail(1)) SWIG_fail;
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (int)(arg1)->GetYMin();
11897
11898 wxPyEndAllowThreads(__tstate);
11899 if (PyErr_Occurred()) SWIG_fail;
11900 }
11901 {
11902 resultobj = SWIG_From_int((int)(result));
11903 }
11904 return resultobj;
11905 fail:
11906 return NULL;
11907 }
11908
11909
11910 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11911 PyObject *resultobj;
11912 wxJoystick *arg1 = (wxJoystick *) 0 ;
11913 int result;
11914 PyObject * obj0 = 0 ;
11915 char *kwnames[] = {
11916 (char *) "self", NULL
11917 };
11918
11919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11921 if (SWIG_arg_fail(1)) SWIG_fail;
11922 {
11923 PyThreadState* __tstate = wxPyBeginAllowThreads();
11924 result = (int)(arg1)->GetZMin();
11925
11926 wxPyEndAllowThreads(__tstate);
11927 if (PyErr_Occurred()) SWIG_fail;
11928 }
11929 {
11930 resultobj = SWIG_From_int((int)(result));
11931 }
11932 return resultobj;
11933 fail:
11934 return NULL;
11935 }
11936
11937
11938 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11939 PyObject *resultobj;
11940 wxJoystick *arg1 = (wxJoystick *) 0 ;
11941 int result;
11942 PyObject * obj0 = 0 ;
11943 char *kwnames[] = {
11944 (char *) "self", NULL
11945 };
11946
11947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11949 if (SWIG_arg_fail(1)) SWIG_fail;
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 result = (int)(arg1)->GetXMax();
11953
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 {
11958 resultobj = SWIG_From_int((int)(result));
11959 }
11960 return resultobj;
11961 fail:
11962 return NULL;
11963 }
11964
11965
11966 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11967 PyObject *resultobj;
11968 wxJoystick *arg1 = (wxJoystick *) 0 ;
11969 int result;
11970 PyObject * obj0 = 0 ;
11971 char *kwnames[] = {
11972 (char *) "self", NULL
11973 };
11974
11975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11977 if (SWIG_arg_fail(1)) SWIG_fail;
11978 {
11979 PyThreadState* __tstate = wxPyBeginAllowThreads();
11980 result = (int)(arg1)->GetYMax();
11981
11982 wxPyEndAllowThreads(__tstate);
11983 if (PyErr_Occurred()) SWIG_fail;
11984 }
11985 {
11986 resultobj = SWIG_From_int((int)(result));
11987 }
11988 return resultobj;
11989 fail:
11990 return NULL;
11991 }
11992
11993
11994 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
11995 PyObject *resultobj;
11996 wxJoystick *arg1 = (wxJoystick *) 0 ;
11997 int result;
11998 PyObject * obj0 = 0 ;
11999 char *kwnames[] = {
12000 (char *) "self", NULL
12001 };
12002
12003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12005 if (SWIG_arg_fail(1)) SWIG_fail;
12006 {
12007 PyThreadState* __tstate = wxPyBeginAllowThreads();
12008 result = (int)(arg1)->GetZMax();
12009
12010 wxPyEndAllowThreads(__tstate);
12011 if (PyErr_Occurred()) SWIG_fail;
12012 }
12013 {
12014 resultobj = SWIG_From_int((int)(result));
12015 }
12016 return resultobj;
12017 fail:
12018 return NULL;
12019 }
12020
12021
12022 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj;
12024 wxJoystick *arg1 = (wxJoystick *) 0 ;
12025 int result;
12026 PyObject * obj0 = 0 ;
12027 char *kwnames[] = {
12028 (char *) "self", NULL
12029 };
12030
12031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12033 if (SWIG_arg_fail(1)) SWIG_fail;
12034 {
12035 PyThreadState* __tstate = wxPyBeginAllowThreads();
12036 result = (int)(arg1)->GetNumberButtons();
12037
12038 wxPyEndAllowThreads(__tstate);
12039 if (PyErr_Occurred()) SWIG_fail;
12040 }
12041 {
12042 resultobj = SWIG_From_int((int)(result));
12043 }
12044 return resultobj;
12045 fail:
12046 return NULL;
12047 }
12048
12049
12050 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12051 PyObject *resultobj;
12052 wxJoystick *arg1 = (wxJoystick *) 0 ;
12053 int result;
12054 PyObject * obj0 = 0 ;
12055 char *kwnames[] = {
12056 (char *) "self", NULL
12057 };
12058
12059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12061 if (SWIG_arg_fail(1)) SWIG_fail;
12062 {
12063 PyThreadState* __tstate = wxPyBeginAllowThreads();
12064 result = (int)(arg1)->GetNumberAxes();
12065
12066 wxPyEndAllowThreads(__tstate);
12067 if (PyErr_Occurred()) SWIG_fail;
12068 }
12069 {
12070 resultobj = SWIG_From_int((int)(result));
12071 }
12072 return resultobj;
12073 fail:
12074 return NULL;
12075 }
12076
12077
12078 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12079 PyObject *resultobj;
12080 wxJoystick *arg1 = (wxJoystick *) 0 ;
12081 int result;
12082 PyObject * obj0 = 0 ;
12083 char *kwnames[] = {
12084 (char *) "self", NULL
12085 };
12086
12087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12089 if (SWIG_arg_fail(1)) SWIG_fail;
12090 {
12091 PyThreadState* __tstate = wxPyBeginAllowThreads();
12092 result = (int)(arg1)->GetMaxButtons();
12093
12094 wxPyEndAllowThreads(__tstate);
12095 if (PyErr_Occurred()) SWIG_fail;
12096 }
12097 {
12098 resultobj = SWIG_From_int((int)(result));
12099 }
12100 return resultobj;
12101 fail:
12102 return NULL;
12103 }
12104
12105
12106 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12107 PyObject *resultobj;
12108 wxJoystick *arg1 = (wxJoystick *) 0 ;
12109 int result;
12110 PyObject * obj0 = 0 ;
12111 char *kwnames[] = {
12112 (char *) "self", NULL
12113 };
12114
12115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12117 if (SWIG_arg_fail(1)) SWIG_fail;
12118 {
12119 PyThreadState* __tstate = wxPyBeginAllowThreads();
12120 result = (int)(arg1)->GetMaxAxes();
12121
12122 wxPyEndAllowThreads(__tstate);
12123 if (PyErr_Occurred()) SWIG_fail;
12124 }
12125 {
12126 resultobj = SWIG_From_int((int)(result));
12127 }
12128 return resultobj;
12129 fail:
12130 return NULL;
12131 }
12132
12133
12134 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj;
12136 wxJoystick *arg1 = (wxJoystick *) 0 ;
12137 int result;
12138 PyObject * obj0 = 0 ;
12139 char *kwnames[] = {
12140 (char *) "self", NULL
12141 };
12142
12143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12145 if (SWIG_arg_fail(1)) SWIG_fail;
12146 {
12147 PyThreadState* __tstate = wxPyBeginAllowThreads();
12148 result = (int)(arg1)->GetPollingMin();
12149
12150 wxPyEndAllowThreads(__tstate);
12151 if (PyErr_Occurred()) SWIG_fail;
12152 }
12153 {
12154 resultobj = SWIG_From_int((int)(result));
12155 }
12156 return resultobj;
12157 fail:
12158 return NULL;
12159 }
12160
12161
12162 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12163 PyObject *resultobj;
12164 wxJoystick *arg1 = (wxJoystick *) 0 ;
12165 int result;
12166 PyObject * obj0 = 0 ;
12167 char *kwnames[] = {
12168 (char *) "self", NULL
12169 };
12170
12171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12173 if (SWIG_arg_fail(1)) SWIG_fail;
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 result = (int)(arg1)->GetPollingMax();
12177
12178 wxPyEndAllowThreads(__tstate);
12179 if (PyErr_Occurred()) SWIG_fail;
12180 }
12181 {
12182 resultobj = SWIG_From_int((int)(result));
12183 }
12184 return resultobj;
12185 fail:
12186 return NULL;
12187 }
12188
12189
12190 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12191 PyObject *resultobj;
12192 wxJoystick *arg1 = (wxJoystick *) 0 ;
12193 int result;
12194 PyObject * obj0 = 0 ;
12195 char *kwnames[] = {
12196 (char *) "self", NULL
12197 };
12198
12199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12201 if (SWIG_arg_fail(1)) SWIG_fail;
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 result = (int)(arg1)->GetRudderMin();
12205
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 {
12210 resultobj = SWIG_From_int((int)(result));
12211 }
12212 return resultobj;
12213 fail:
12214 return NULL;
12215 }
12216
12217
12218 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12219 PyObject *resultobj;
12220 wxJoystick *arg1 = (wxJoystick *) 0 ;
12221 int result;
12222 PyObject * obj0 = 0 ;
12223 char *kwnames[] = {
12224 (char *) "self", NULL
12225 };
12226
12227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12229 if (SWIG_arg_fail(1)) SWIG_fail;
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 result = (int)(arg1)->GetRudderMax();
12233
12234 wxPyEndAllowThreads(__tstate);
12235 if (PyErr_Occurred()) SWIG_fail;
12236 }
12237 {
12238 resultobj = SWIG_From_int((int)(result));
12239 }
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj;
12248 wxJoystick *arg1 = (wxJoystick *) 0 ;
12249 int result;
12250 PyObject * obj0 = 0 ;
12251 char *kwnames[] = {
12252 (char *) "self", NULL
12253 };
12254
12255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12257 if (SWIG_arg_fail(1)) SWIG_fail;
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (int)(arg1)->GetUMin();
12261
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 {
12266 resultobj = SWIG_From_int((int)(result));
12267 }
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj;
12276 wxJoystick *arg1 = (wxJoystick *) 0 ;
12277 int result;
12278 PyObject * obj0 = 0 ;
12279 char *kwnames[] = {
12280 (char *) "self", NULL
12281 };
12282
12283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12285 if (SWIG_arg_fail(1)) SWIG_fail;
12286 {
12287 PyThreadState* __tstate = wxPyBeginAllowThreads();
12288 result = (int)(arg1)->GetUMax();
12289
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 {
12294 resultobj = SWIG_From_int((int)(result));
12295 }
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12303 PyObject *resultobj;
12304 wxJoystick *arg1 = (wxJoystick *) 0 ;
12305 int result;
12306 PyObject * obj0 = 0 ;
12307 char *kwnames[] = {
12308 (char *) "self", NULL
12309 };
12310
12311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12313 if (SWIG_arg_fail(1)) SWIG_fail;
12314 {
12315 PyThreadState* __tstate = wxPyBeginAllowThreads();
12316 result = (int)(arg1)->GetVMin();
12317
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 {
12322 resultobj = SWIG_From_int((int)(result));
12323 }
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12331 PyObject *resultobj;
12332 wxJoystick *arg1 = (wxJoystick *) 0 ;
12333 int result;
12334 PyObject * obj0 = 0 ;
12335 char *kwnames[] = {
12336 (char *) "self", NULL
12337 };
12338
12339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12341 if (SWIG_arg_fail(1)) SWIG_fail;
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = (int)(arg1)->GetVMax();
12345
12346 wxPyEndAllowThreads(__tstate);
12347 if (PyErr_Occurred()) SWIG_fail;
12348 }
12349 {
12350 resultobj = SWIG_From_int((int)(result));
12351 }
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12359 PyObject *resultobj;
12360 wxJoystick *arg1 = (wxJoystick *) 0 ;
12361 bool result;
12362 PyObject * obj0 = 0 ;
12363 char *kwnames[] = {
12364 (char *) "self", NULL
12365 };
12366
12367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12369 if (SWIG_arg_fail(1)) SWIG_fail;
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 result = (bool)(arg1)->HasRudder();
12373
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 {
12378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12379 }
12380 return resultobj;
12381 fail:
12382 return NULL;
12383 }
12384
12385
12386 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12387 PyObject *resultobj;
12388 wxJoystick *arg1 = (wxJoystick *) 0 ;
12389 bool result;
12390 PyObject * obj0 = 0 ;
12391 char *kwnames[] = {
12392 (char *) "self", NULL
12393 };
12394
12395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12397 if (SWIG_arg_fail(1)) SWIG_fail;
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 result = (bool)(arg1)->HasZ();
12401
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 {
12406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12407 }
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj;
12416 wxJoystick *arg1 = (wxJoystick *) 0 ;
12417 bool result;
12418 PyObject * obj0 = 0 ;
12419 char *kwnames[] = {
12420 (char *) "self", NULL
12421 };
12422
12423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12425 if (SWIG_arg_fail(1)) SWIG_fail;
12426 {
12427 PyThreadState* __tstate = wxPyBeginAllowThreads();
12428 result = (bool)(arg1)->HasU();
12429
12430 wxPyEndAllowThreads(__tstate);
12431 if (PyErr_Occurred()) SWIG_fail;
12432 }
12433 {
12434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12435 }
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12443 PyObject *resultobj;
12444 wxJoystick *arg1 = (wxJoystick *) 0 ;
12445 bool result;
12446 PyObject * obj0 = 0 ;
12447 char *kwnames[] = {
12448 (char *) "self", NULL
12449 };
12450
12451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12453 if (SWIG_arg_fail(1)) SWIG_fail;
12454 {
12455 PyThreadState* __tstate = wxPyBeginAllowThreads();
12456 result = (bool)(arg1)->HasV();
12457
12458 wxPyEndAllowThreads(__tstate);
12459 if (PyErr_Occurred()) SWIG_fail;
12460 }
12461 {
12462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12463 }
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj;
12472 wxJoystick *arg1 = (wxJoystick *) 0 ;
12473 bool result;
12474 PyObject * obj0 = 0 ;
12475 char *kwnames[] = {
12476 (char *) "self", NULL
12477 };
12478
12479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12481 if (SWIG_arg_fail(1)) SWIG_fail;
12482 {
12483 PyThreadState* __tstate = wxPyBeginAllowThreads();
12484 result = (bool)(arg1)->HasPOV();
12485
12486 wxPyEndAllowThreads(__tstate);
12487 if (PyErr_Occurred()) SWIG_fail;
12488 }
12489 {
12490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12491 }
12492 return resultobj;
12493 fail:
12494 return NULL;
12495 }
12496
12497
12498 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12499 PyObject *resultobj;
12500 wxJoystick *arg1 = (wxJoystick *) 0 ;
12501 bool result;
12502 PyObject * obj0 = 0 ;
12503 char *kwnames[] = {
12504 (char *) "self", NULL
12505 };
12506
12507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12509 if (SWIG_arg_fail(1)) SWIG_fail;
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 result = (bool)(arg1)->HasPOV4Dir();
12513
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 {
12518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12519 }
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12527 PyObject *resultobj;
12528 wxJoystick *arg1 = (wxJoystick *) 0 ;
12529 bool result;
12530 PyObject * obj0 = 0 ;
12531 char *kwnames[] = {
12532 (char *) "self", NULL
12533 };
12534
12535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12537 if (SWIG_arg_fail(1)) SWIG_fail;
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 result = (bool)(arg1)->HasPOVCTS();
12541
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 {
12546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12547 }
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj;
12556 wxJoystick *arg1 = (wxJoystick *) 0 ;
12557 wxWindow *arg2 = (wxWindow *) 0 ;
12558 int arg3 = (int) 0 ;
12559 bool result;
12560 PyObject * obj0 = 0 ;
12561 PyObject * obj1 = 0 ;
12562 PyObject * obj2 = 0 ;
12563 char *kwnames[] = {
12564 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12565 };
12566
12567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12569 if (SWIG_arg_fail(1)) SWIG_fail;
12570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12571 if (SWIG_arg_fail(2)) SWIG_fail;
12572 if (obj2) {
12573 {
12574 arg3 = (int)(SWIG_As_int(obj2));
12575 if (SWIG_arg_fail(3)) SWIG_fail;
12576 }
12577 }
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 result = (bool)(arg1)->SetCapture(arg2,arg3);
12581
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 {
12586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12587 }
12588 return resultobj;
12589 fail:
12590 return NULL;
12591 }
12592
12593
12594 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12595 PyObject *resultobj;
12596 wxJoystick *arg1 = (wxJoystick *) 0 ;
12597 bool result;
12598 PyObject * obj0 = 0 ;
12599 char *kwnames[] = {
12600 (char *) "self", NULL
12601 };
12602
12603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12605 if (SWIG_arg_fail(1)) SWIG_fail;
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 result = (bool)(arg1)->ReleaseCapture();
12609
12610 wxPyEndAllowThreads(__tstate);
12611 if (PyErr_Occurred()) SWIG_fail;
12612 }
12613 {
12614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12615 }
12616 return resultobj;
12617 fail:
12618 return NULL;
12619 }
12620
12621
12622 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12623 PyObject *obj;
12624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12625 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12626 Py_INCREF(obj);
12627 return Py_BuildValue((char *)"");
12628 }
12629 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12630 PyObject *resultobj;
12631 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12632 int arg2 = (int) 0 ;
12633 int arg3 = (int) wxJOYSTICK1 ;
12634 int arg4 = (int) 0 ;
12635 wxJoystickEvent *result;
12636 PyObject * obj0 = 0 ;
12637 PyObject * obj1 = 0 ;
12638 PyObject * obj2 = 0 ;
12639 PyObject * obj3 = 0 ;
12640 char *kwnames[] = {
12641 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12642 };
12643
12644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12645 if (obj0) {
12646 {
12647 arg1 = (wxEventType)(SWIG_As_int(obj0));
12648 if (SWIG_arg_fail(1)) SWIG_fail;
12649 }
12650 }
12651 if (obj1) {
12652 {
12653 arg2 = (int)(SWIG_As_int(obj1));
12654 if (SWIG_arg_fail(2)) SWIG_fail;
12655 }
12656 }
12657 if (obj2) {
12658 {
12659 arg3 = (int)(SWIG_As_int(obj2));
12660 if (SWIG_arg_fail(3)) SWIG_fail;
12661 }
12662 }
12663 if (obj3) {
12664 {
12665 arg4 = (int)(SWIG_As_int(obj3));
12666 if (SWIG_arg_fail(4)) SWIG_fail;
12667 }
12668 }
12669 {
12670 PyThreadState* __tstate = wxPyBeginAllowThreads();
12671 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12672
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12684 PyObject *resultobj;
12685 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12686 wxPoint result;
12687 PyObject * obj0 = 0 ;
12688 char *kwnames[] = {
12689 (char *) "self", NULL
12690 };
12691
12692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12694 if (SWIG_arg_fail(1)) SWIG_fail;
12695 {
12696 PyThreadState* __tstate = wxPyBeginAllowThreads();
12697 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12698
12699 wxPyEndAllowThreads(__tstate);
12700 if (PyErr_Occurred()) SWIG_fail;
12701 }
12702 {
12703 wxPoint * resultptr;
12704 resultptr = new wxPoint((wxPoint &)(result));
12705 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12706 }
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12714 PyObject *resultobj;
12715 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12716 int result;
12717 PyObject * obj0 = 0 ;
12718 char *kwnames[] = {
12719 (char *) "self", NULL
12720 };
12721
12722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12724 if (SWIG_arg_fail(1)) SWIG_fail;
12725 {
12726 PyThreadState* __tstate = wxPyBeginAllowThreads();
12727 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12728
12729 wxPyEndAllowThreads(__tstate);
12730 if (PyErr_Occurred()) SWIG_fail;
12731 }
12732 {
12733 resultobj = SWIG_From_int((int)(result));
12734 }
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj;
12743 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12744 int result;
12745 PyObject * obj0 = 0 ;
12746 char *kwnames[] = {
12747 (char *) "self", NULL
12748 };
12749
12750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12752 if (SWIG_arg_fail(1)) SWIG_fail;
12753 {
12754 PyThreadState* __tstate = wxPyBeginAllowThreads();
12755 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12756
12757 wxPyEndAllowThreads(__tstate);
12758 if (PyErr_Occurred()) SWIG_fail;
12759 }
12760 {
12761 resultobj = SWIG_From_int((int)(result));
12762 }
12763 return resultobj;
12764 fail:
12765 return NULL;
12766 }
12767
12768
12769 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12770 PyObject *resultobj;
12771 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12772 int result;
12773 PyObject * obj0 = 0 ;
12774 char *kwnames[] = {
12775 (char *) "self", NULL
12776 };
12777
12778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12780 if (SWIG_arg_fail(1)) SWIG_fail;
12781 {
12782 PyThreadState* __tstate = wxPyBeginAllowThreads();
12783 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12784
12785 wxPyEndAllowThreads(__tstate);
12786 if (PyErr_Occurred()) SWIG_fail;
12787 }
12788 {
12789 resultobj = SWIG_From_int((int)(result));
12790 }
12791 return resultobj;
12792 fail:
12793 return NULL;
12794 }
12795
12796
12797 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12798 PyObject *resultobj;
12799 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12800 int result;
12801 PyObject * obj0 = 0 ;
12802 char *kwnames[] = {
12803 (char *) "self", NULL
12804 };
12805
12806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12808 if (SWIG_arg_fail(1)) SWIG_fail;
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12812
12813 wxPyEndAllowThreads(__tstate);
12814 if (PyErr_Occurred()) SWIG_fail;
12815 }
12816 {
12817 resultobj = SWIG_From_int((int)(result));
12818 }
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12826 PyObject *resultobj;
12827 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12828 int arg2 ;
12829 PyObject * obj0 = 0 ;
12830 PyObject * obj1 = 0 ;
12831 char *kwnames[] = {
12832 (char *) "self",(char *) "stick", NULL
12833 };
12834
12835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12837 if (SWIG_arg_fail(1)) SWIG_fail;
12838 {
12839 arg2 = (int)(SWIG_As_int(obj1));
12840 if (SWIG_arg_fail(2)) SWIG_fail;
12841 }
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 (arg1)->SetJoystick(arg2);
12845
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 Py_INCREF(Py_None); resultobj = Py_None;
12850 return resultobj;
12851 fail:
12852 return NULL;
12853 }
12854
12855
12856 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12857 PyObject *resultobj;
12858 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12859 int arg2 ;
12860 PyObject * obj0 = 0 ;
12861 PyObject * obj1 = 0 ;
12862 char *kwnames[] = {
12863 (char *) "self",(char *) "state", NULL
12864 };
12865
12866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
12867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12868 if (SWIG_arg_fail(1)) SWIG_fail;
12869 {
12870 arg2 = (int)(SWIG_As_int(obj1));
12871 if (SWIG_arg_fail(2)) SWIG_fail;
12872 }
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 (arg1)->SetButtonState(arg2);
12876
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 Py_INCREF(Py_None); resultobj = Py_None;
12881 return resultobj;
12882 fail:
12883 return NULL;
12884 }
12885
12886
12887 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12888 PyObject *resultobj;
12889 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12890 int arg2 ;
12891 PyObject * obj0 = 0 ;
12892 PyObject * obj1 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "self",(char *) "change", NULL
12895 };
12896
12897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
12898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12899 if (SWIG_arg_fail(1)) SWIG_fail;
12900 {
12901 arg2 = (int)(SWIG_As_int(obj1));
12902 if (SWIG_arg_fail(2)) SWIG_fail;
12903 }
12904 {
12905 PyThreadState* __tstate = wxPyBeginAllowThreads();
12906 (arg1)->SetButtonChange(arg2);
12907
12908 wxPyEndAllowThreads(__tstate);
12909 if (PyErr_Occurred()) SWIG_fail;
12910 }
12911 Py_INCREF(Py_None); resultobj = Py_None;
12912 return resultobj;
12913 fail:
12914 return NULL;
12915 }
12916
12917
12918 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj;
12920 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12921 wxPoint *arg2 = 0 ;
12922 wxPoint temp2 ;
12923 PyObject * obj0 = 0 ;
12924 PyObject * obj1 = 0 ;
12925 char *kwnames[] = {
12926 (char *) "self",(char *) "pos", NULL
12927 };
12928
12929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
12930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12931 if (SWIG_arg_fail(1)) SWIG_fail;
12932 {
12933 arg2 = &temp2;
12934 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12935 }
12936 {
12937 PyThreadState* __tstate = wxPyBeginAllowThreads();
12938 (arg1)->SetPosition((wxPoint const &)*arg2);
12939
12940 wxPyEndAllowThreads(__tstate);
12941 if (PyErr_Occurred()) SWIG_fail;
12942 }
12943 Py_INCREF(Py_None); resultobj = Py_None;
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12951 PyObject *resultobj;
12952 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12953 int arg2 ;
12954 PyObject * obj0 = 0 ;
12955 PyObject * obj1 = 0 ;
12956 char *kwnames[] = {
12957 (char *) "self",(char *) "zPos", NULL
12958 };
12959
12960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
12961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12962 if (SWIG_arg_fail(1)) SWIG_fail;
12963 {
12964 arg2 = (int)(SWIG_As_int(obj1));
12965 if (SWIG_arg_fail(2)) SWIG_fail;
12966 }
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 (arg1)->SetZPosition(arg2);
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 Py_INCREF(Py_None); resultobj = Py_None;
12975 return resultobj;
12976 fail:
12977 return NULL;
12978 }
12979
12980
12981 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
12982 PyObject *resultobj;
12983 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12984 bool result;
12985 PyObject * obj0 = 0 ;
12986 char *kwnames[] = {
12987 (char *) "self", NULL
12988 };
12989
12990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
12991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12992 if (SWIG_arg_fail(1)) SWIG_fail;
12993 {
12994 PyThreadState* __tstate = wxPyBeginAllowThreads();
12995 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
12996
12997 wxPyEndAllowThreads(__tstate);
12998 if (PyErr_Occurred()) SWIG_fail;
12999 }
13000 {
13001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13002 }
13003 return resultobj;
13004 fail:
13005 return NULL;
13006 }
13007
13008
13009 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13010 PyObject *resultobj;
13011 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13012 bool result;
13013 PyObject * obj0 = 0 ;
13014 char *kwnames[] = {
13015 (char *) "self", NULL
13016 };
13017
13018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13020 if (SWIG_arg_fail(1)) SWIG_fail;
13021 {
13022 PyThreadState* __tstate = wxPyBeginAllowThreads();
13023 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13024
13025 wxPyEndAllowThreads(__tstate);
13026 if (PyErr_Occurred()) SWIG_fail;
13027 }
13028 {
13029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13030 }
13031 return resultobj;
13032 fail:
13033 return NULL;
13034 }
13035
13036
13037 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13038 PyObject *resultobj;
13039 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13040 bool result;
13041 PyObject * obj0 = 0 ;
13042 char *kwnames[] = {
13043 (char *) "self", NULL
13044 };
13045
13046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13048 if (SWIG_arg_fail(1)) SWIG_fail;
13049 {
13050 PyThreadState* __tstate = wxPyBeginAllowThreads();
13051 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13052
13053 wxPyEndAllowThreads(__tstate);
13054 if (PyErr_Occurred()) SWIG_fail;
13055 }
13056 {
13057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13058 }
13059 return resultobj;
13060 fail:
13061 return NULL;
13062 }
13063
13064
13065 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13066 PyObject *resultobj;
13067 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13068 int arg2 = (int) wxJOY_BUTTON_ANY ;
13069 bool result;
13070 PyObject * obj0 = 0 ;
13071 PyObject * obj1 = 0 ;
13072 char *kwnames[] = {
13073 (char *) "self",(char *) "but", NULL
13074 };
13075
13076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13078 if (SWIG_arg_fail(1)) SWIG_fail;
13079 if (obj1) {
13080 {
13081 arg2 = (int)(SWIG_As_int(obj1));
13082 if (SWIG_arg_fail(2)) SWIG_fail;
13083 }
13084 }
13085 {
13086 PyThreadState* __tstate = wxPyBeginAllowThreads();
13087 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13088
13089 wxPyEndAllowThreads(__tstate);
13090 if (PyErr_Occurred()) SWIG_fail;
13091 }
13092 {
13093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13094 }
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13104 int arg2 = (int) wxJOY_BUTTON_ANY ;
13105 bool result;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 char *kwnames[] = {
13109 (char *) "self",(char *) "but", NULL
13110 };
13111
13112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13114 if (SWIG_arg_fail(1)) SWIG_fail;
13115 if (obj1) {
13116 {
13117 arg2 = (int)(SWIG_As_int(obj1));
13118 if (SWIG_arg_fail(2)) SWIG_fail;
13119 }
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13124
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 {
13129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13130 }
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13138 PyObject *resultobj;
13139 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13140 int arg2 = (int) wxJOY_BUTTON_ANY ;
13141 bool result;
13142 PyObject * obj0 = 0 ;
13143 PyObject * obj1 = 0 ;
13144 char *kwnames[] = {
13145 (char *) "self",(char *) "but", NULL
13146 };
13147
13148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13150 if (SWIG_arg_fail(1)) SWIG_fail;
13151 if (obj1) {
13152 {
13153 arg2 = (int)(SWIG_As_int(obj1));
13154 if (SWIG_arg_fail(2)) SWIG_fail;
13155 }
13156 }
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13160
13161 wxPyEndAllowThreads(__tstate);
13162 if (PyErr_Occurred()) SWIG_fail;
13163 }
13164 {
13165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13166 }
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13174 PyObject *obj;
13175 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13176 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13177 Py_INCREF(obj);
13178 return Py_BuildValue((char *)"");
13179 }
13180 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13181 PyObject *resultobj;
13182 wxString const &arg1_defvalue = wxPyEmptyString ;
13183 wxString *arg1 = (wxString *) &arg1_defvalue ;
13184 wxSound *result;
13185 bool temp1 = false ;
13186 PyObject * obj0 = 0 ;
13187 char *kwnames[] = {
13188 (char *) "fileName", NULL
13189 };
13190
13191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13192 if (obj0) {
13193 {
13194 arg1 = wxString_in_helper(obj0);
13195 if (arg1 == NULL) SWIG_fail;
13196 temp1 = true;
13197 }
13198 }
13199 {
13200 if (!wxPyCheckForApp()) SWIG_fail;
13201 PyThreadState* __tstate = wxPyBeginAllowThreads();
13202 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13203
13204 wxPyEndAllowThreads(__tstate);
13205 if (PyErr_Occurred()) SWIG_fail;
13206 }
13207 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13208 {
13209 if (temp1)
13210 delete arg1;
13211 }
13212 return resultobj;
13213 fail:
13214 {
13215 if (temp1)
13216 delete arg1;
13217 }
13218 return NULL;
13219 }
13220
13221
13222 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13223 PyObject *resultobj;
13224 PyObject *arg1 = (PyObject *) 0 ;
13225 wxSound *result;
13226 PyObject * obj0 = 0 ;
13227 char *kwnames[] = {
13228 (char *) "data", NULL
13229 };
13230
13231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13232 arg1 = obj0;
13233 {
13234 if (!wxPyCheckForApp()) SWIG_fail;
13235 PyThreadState* __tstate = wxPyBeginAllowThreads();
13236 result = (wxSound *)new_wxSound(arg1);
13237
13238 wxPyEndAllowThreads(__tstate);
13239 if (PyErr_Occurred()) SWIG_fail;
13240 }
13241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13242 return resultobj;
13243 fail:
13244 return NULL;
13245 }
13246
13247
13248 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13249 PyObject *resultobj;
13250 wxSound *arg1 = (wxSound *) 0 ;
13251 PyObject * obj0 = 0 ;
13252 char *kwnames[] = {
13253 (char *) "self", NULL
13254 };
13255
13256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13258 if (SWIG_arg_fail(1)) SWIG_fail;
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 delete arg1;
13262
13263 wxPyEndAllowThreads(__tstate);
13264 if (PyErr_Occurred()) SWIG_fail;
13265 }
13266 Py_INCREF(Py_None); resultobj = Py_None;
13267 return resultobj;
13268 fail:
13269 return NULL;
13270 }
13271
13272
13273 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13274 PyObject *resultobj;
13275 wxSound *arg1 = (wxSound *) 0 ;
13276 wxString *arg2 = 0 ;
13277 bool result;
13278 bool temp2 = false ;
13279 PyObject * obj0 = 0 ;
13280 PyObject * obj1 = 0 ;
13281 char *kwnames[] = {
13282 (char *) "self",(char *) "fileName", NULL
13283 };
13284
13285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13287 if (SWIG_arg_fail(1)) SWIG_fail;
13288 {
13289 arg2 = wxString_in_helper(obj1);
13290 if (arg2 == NULL) SWIG_fail;
13291 temp2 = true;
13292 }
13293 {
13294 PyThreadState* __tstate = wxPyBeginAllowThreads();
13295 result = (bool)(arg1)->Create((wxString const &)*arg2);
13296
13297 wxPyEndAllowThreads(__tstate);
13298 if (PyErr_Occurred()) SWIG_fail;
13299 }
13300 {
13301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13302 }
13303 {
13304 if (temp2)
13305 delete arg2;
13306 }
13307 return resultobj;
13308 fail:
13309 {
13310 if (temp2)
13311 delete arg2;
13312 }
13313 return NULL;
13314 }
13315
13316
13317 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13318 PyObject *resultobj;
13319 wxSound *arg1 = (wxSound *) 0 ;
13320 PyObject *arg2 = (PyObject *) 0 ;
13321 bool result;
13322 PyObject * obj0 = 0 ;
13323 PyObject * obj1 = 0 ;
13324 char *kwnames[] = {
13325 (char *) "self",(char *) "data", NULL
13326 };
13327
13328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13330 if (SWIG_arg_fail(1)) SWIG_fail;
13331 arg2 = obj1;
13332 {
13333 PyThreadState* __tstate = wxPyBeginAllowThreads();
13334 result = (bool)wxSound_CreateFromData(arg1,arg2);
13335
13336 wxPyEndAllowThreads(__tstate);
13337 if (PyErr_Occurred()) SWIG_fail;
13338 }
13339 {
13340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13341 }
13342 return resultobj;
13343 fail:
13344 return NULL;
13345 }
13346
13347
13348 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13349 PyObject *resultobj;
13350 wxSound *arg1 = (wxSound *) 0 ;
13351 bool result;
13352 PyObject * obj0 = 0 ;
13353 char *kwnames[] = {
13354 (char *) "self", NULL
13355 };
13356
13357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13359 if (SWIG_arg_fail(1)) SWIG_fail;
13360 {
13361 PyThreadState* __tstate = wxPyBeginAllowThreads();
13362 result = (bool)(arg1)->IsOk();
13363
13364 wxPyEndAllowThreads(__tstate);
13365 if (PyErr_Occurred()) SWIG_fail;
13366 }
13367 {
13368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13369 }
13370 return resultobj;
13371 fail:
13372 return NULL;
13373 }
13374
13375
13376 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13377 PyObject *resultobj;
13378 wxSound *arg1 = (wxSound *) 0 ;
13379 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13380 bool result;
13381 PyObject * obj0 = 0 ;
13382 PyObject * obj1 = 0 ;
13383 char *kwnames[] = {
13384 (char *) "self",(char *) "flags", NULL
13385 };
13386
13387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13389 if (SWIG_arg_fail(1)) SWIG_fail;
13390 if (obj1) {
13391 {
13392 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13393 if (SWIG_arg_fail(2)) SWIG_fail;
13394 }
13395 }
13396 {
13397 if (!wxPyCheckForApp()) SWIG_fail;
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 result = (bool)((wxSound const *)arg1)->Play(arg2);
13400
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 {
13405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13406 }
13407 return resultobj;
13408 fail:
13409 return NULL;
13410 }
13411
13412
13413 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13414 PyObject *resultobj;
13415 wxString *arg1 = 0 ;
13416 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13417 bool result;
13418 bool temp1 = false ;
13419 PyObject * obj0 = 0 ;
13420 PyObject * obj1 = 0 ;
13421 char *kwnames[] = {
13422 (char *) "filename",(char *) "flags", NULL
13423 };
13424
13425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13426 {
13427 arg1 = wxString_in_helper(obj0);
13428 if (arg1 == NULL) SWIG_fail;
13429 temp1 = true;
13430 }
13431 if (obj1) {
13432 {
13433 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13434 if (SWIG_arg_fail(2)) SWIG_fail;
13435 }
13436 }
13437 {
13438 if (!wxPyCheckForApp()) SWIG_fail;
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13441
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 {
13446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13447 }
13448 {
13449 if (temp1)
13450 delete arg1;
13451 }
13452 return resultobj;
13453 fail:
13454 {
13455 if (temp1)
13456 delete arg1;
13457 }
13458 return NULL;
13459 }
13460
13461
13462 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj;
13464 char *kwnames[] = {
13465 NULL
13466 };
13467
13468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13469 {
13470 if (!wxPyCheckForApp()) SWIG_fail;
13471 PyThreadState* __tstate = wxPyBeginAllowThreads();
13472 wxSound::Stop();
13473
13474 wxPyEndAllowThreads(__tstate);
13475 if (PyErr_Occurred()) SWIG_fail;
13476 }
13477 Py_INCREF(Py_None); resultobj = Py_None;
13478 return resultobj;
13479 fail:
13480 return NULL;
13481 }
13482
13483
13484 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13485 PyObject *obj;
13486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13487 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13488 Py_INCREF(obj);
13489 return Py_BuildValue((char *)"");
13490 }
13491 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13492 PyObject *resultobj;
13493 wxString *arg1 = 0 ;
13494 wxString *arg2 = 0 ;
13495 wxString *arg3 = 0 ;
13496 wxString *arg4 = 0 ;
13497 wxFileTypeInfo *result;
13498 bool temp1 = false ;
13499 bool temp2 = false ;
13500 bool temp3 = false ;
13501 bool temp4 = false ;
13502 PyObject * obj0 = 0 ;
13503 PyObject * obj1 = 0 ;
13504 PyObject * obj2 = 0 ;
13505 PyObject * obj3 = 0 ;
13506 char *kwnames[] = {
13507 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13508 };
13509
13510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13511 {
13512 arg1 = wxString_in_helper(obj0);
13513 if (arg1 == NULL) SWIG_fail;
13514 temp1 = true;
13515 }
13516 {
13517 arg2 = wxString_in_helper(obj1);
13518 if (arg2 == NULL) SWIG_fail;
13519 temp2 = true;
13520 }
13521 {
13522 arg3 = wxString_in_helper(obj2);
13523 if (arg3 == NULL) SWIG_fail;
13524 temp3 = true;
13525 }
13526 {
13527 arg4 = wxString_in_helper(obj3);
13528 if (arg4 == NULL) SWIG_fail;
13529 temp4 = true;
13530 }
13531 {
13532 PyThreadState* __tstate = wxPyBeginAllowThreads();
13533 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13534
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13539 {
13540 if (temp1)
13541 delete arg1;
13542 }
13543 {
13544 if (temp2)
13545 delete arg2;
13546 }
13547 {
13548 if (temp3)
13549 delete arg3;
13550 }
13551 {
13552 if (temp4)
13553 delete arg4;
13554 }
13555 return resultobj;
13556 fail:
13557 {
13558 if (temp1)
13559 delete arg1;
13560 }
13561 {
13562 if (temp2)
13563 delete arg2;
13564 }
13565 {
13566 if (temp3)
13567 delete arg3;
13568 }
13569 {
13570 if (temp4)
13571 delete arg4;
13572 }
13573 return NULL;
13574 }
13575
13576
13577 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj;
13579 wxArrayString *arg1 = 0 ;
13580 wxFileTypeInfo *result;
13581 bool temp1 = false ;
13582 PyObject * obj0 = 0 ;
13583 char *kwnames[] = {
13584 (char *) "sArray", NULL
13585 };
13586
13587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13588 {
13589 if (! PySequence_Check(obj0)) {
13590 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13591 SWIG_fail;
13592 }
13593 arg1 = new wxArrayString;
13594 temp1 = true;
13595 int i, len=PySequence_Length(obj0);
13596 for (i=0; i<len; i++) {
13597 PyObject* item = PySequence_GetItem(obj0, i);
13598 #if wxUSE_UNICODE
13599 PyObject* str = PyObject_Unicode(item);
13600 #else
13601 PyObject* str = PyObject_Str(item);
13602 #endif
13603 if (PyErr_Occurred()) SWIG_fail;
13604 arg1->Add(Py2wxString(str));
13605 Py_DECREF(item);
13606 Py_DECREF(str);
13607 }
13608 }
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13612
13613 wxPyEndAllowThreads(__tstate);
13614 if (PyErr_Occurred()) SWIG_fail;
13615 }
13616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13617 {
13618 if (temp1) delete arg1;
13619 }
13620 return resultobj;
13621 fail:
13622 {
13623 if (temp1) delete arg1;
13624 }
13625 return NULL;
13626 }
13627
13628
13629 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13630 PyObject *resultobj;
13631 wxFileTypeInfo *result;
13632 char *kwnames[] = {
13633 NULL
13634 };
13635
13636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13637 {
13638 PyThreadState* __tstate = wxPyBeginAllowThreads();
13639 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13640
13641 wxPyEndAllowThreads(__tstate);
13642 if (PyErr_Occurred()) SWIG_fail;
13643 }
13644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13645 return resultobj;
13646 fail:
13647 return NULL;
13648 }
13649
13650
13651 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13652 PyObject *resultobj;
13653 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13654 bool result;
13655 PyObject * obj0 = 0 ;
13656 char *kwnames[] = {
13657 (char *) "self", NULL
13658 };
13659
13660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13662 if (SWIG_arg_fail(1)) SWIG_fail;
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13666
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 {
13671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13672 }
13673 return resultobj;
13674 fail:
13675 return NULL;
13676 }
13677
13678
13679 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13680 PyObject *resultobj;
13681 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13682 wxString *arg2 = 0 ;
13683 int arg3 = (int) 0 ;
13684 bool temp2 = false ;
13685 PyObject * obj0 = 0 ;
13686 PyObject * obj1 = 0 ;
13687 PyObject * obj2 = 0 ;
13688 char *kwnames[] = {
13689 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13690 };
13691
13692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13694 if (SWIG_arg_fail(1)) SWIG_fail;
13695 {
13696 arg2 = wxString_in_helper(obj1);
13697 if (arg2 == NULL) SWIG_fail;
13698 temp2 = true;
13699 }
13700 if (obj2) {
13701 {
13702 arg3 = (int)(SWIG_As_int(obj2));
13703 if (SWIG_arg_fail(3)) SWIG_fail;
13704 }
13705 }
13706 {
13707 PyThreadState* __tstate = wxPyBeginAllowThreads();
13708 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13709
13710 wxPyEndAllowThreads(__tstate);
13711 if (PyErr_Occurred()) SWIG_fail;
13712 }
13713 Py_INCREF(Py_None); resultobj = Py_None;
13714 {
13715 if (temp2)
13716 delete arg2;
13717 }
13718 return resultobj;
13719 fail:
13720 {
13721 if (temp2)
13722 delete arg2;
13723 }
13724 return NULL;
13725 }
13726
13727
13728 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13729 PyObject *resultobj;
13730 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13731 wxString *arg2 = 0 ;
13732 bool temp2 = false ;
13733 PyObject * obj0 = 0 ;
13734 PyObject * obj1 = 0 ;
13735 char *kwnames[] = {
13736 (char *) "self",(char *) "shortDesc", NULL
13737 };
13738
13739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13741 if (SWIG_arg_fail(1)) SWIG_fail;
13742 {
13743 arg2 = wxString_in_helper(obj1);
13744 if (arg2 == NULL) SWIG_fail;
13745 temp2 = true;
13746 }
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 (arg1)->SetShortDesc((wxString const &)*arg2);
13750
13751 wxPyEndAllowThreads(__tstate);
13752 if (PyErr_Occurred()) SWIG_fail;
13753 }
13754 Py_INCREF(Py_None); resultobj = Py_None;
13755 {
13756 if (temp2)
13757 delete arg2;
13758 }
13759 return resultobj;
13760 fail:
13761 {
13762 if (temp2)
13763 delete arg2;
13764 }
13765 return NULL;
13766 }
13767
13768
13769 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13770 PyObject *resultobj;
13771 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13772 wxString *result;
13773 PyObject * obj0 = 0 ;
13774 char *kwnames[] = {
13775 (char *) "self", NULL
13776 };
13777
13778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13780 if (SWIG_arg_fail(1)) SWIG_fail;
13781 {
13782 PyThreadState* __tstate = wxPyBeginAllowThreads();
13783 {
13784 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13785 result = (wxString *) &_result_ref;
13786 }
13787
13788 wxPyEndAllowThreads(__tstate);
13789 if (PyErr_Occurred()) SWIG_fail;
13790 }
13791 {
13792 #if wxUSE_UNICODE
13793 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13794 #else
13795 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13796 #endif
13797 }
13798 return resultobj;
13799 fail:
13800 return NULL;
13801 }
13802
13803
13804 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj;
13806 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13807 wxString *result;
13808 PyObject * obj0 = 0 ;
13809 char *kwnames[] = {
13810 (char *) "self", NULL
13811 };
13812
13813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13815 if (SWIG_arg_fail(1)) SWIG_fail;
13816 {
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 {
13819 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13820 result = (wxString *) &_result_ref;
13821 }
13822
13823 wxPyEndAllowThreads(__tstate);
13824 if (PyErr_Occurred()) SWIG_fail;
13825 }
13826 {
13827 #if wxUSE_UNICODE
13828 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13829 #else
13830 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13831 #endif
13832 }
13833 return resultobj;
13834 fail:
13835 return NULL;
13836 }
13837
13838
13839 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13840 PyObject *resultobj;
13841 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13842 wxString *result;
13843 PyObject * obj0 = 0 ;
13844 char *kwnames[] = {
13845 (char *) "self", NULL
13846 };
13847
13848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13850 if (SWIG_arg_fail(1)) SWIG_fail;
13851 {
13852 PyThreadState* __tstate = wxPyBeginAllowThreads();
13853 {
13854 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13855 result = (wxString *) &_result_ref;
13856 }
13857
13858 wxPyEndAllowThreads(__tstate);
13859 if (PyErr_Occurred()) SWIG_fail;
13860 }
13861 {
13862 #if wxUSE_UNICODE
13863 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13864 #else
13865 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13866 #endif
13867 }
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj;
13876 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13877 wxString *result;
13878 PyObject * obj0 = 0 ;
13879 char *kwnames[] = {
13880 (char *) "self", NULL
13881 };
13882
13883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
13884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13885 if (SWIG_arg_fail(1)) SWIG_fail;
13886 {
13887 PyThreadState* __tstate = wxPyBeginAllowThreads();
13888 {
13889 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
13890 result = (wxString *) &_result_ref;
13891 }
13892
13893 wxPyEndAllowThreads(__tstate);
13894 if (PyErr_Occurred()) SWIG_fail;
13895 }
13896 {
13897 #if wxUSE_UNICODE
13898 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13899 #else
13900 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13901 #endif
13902 }
13903 return resultobj;
13904 fail:
13905 return NULL;
13906 }
13907
13908
13909 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
13910 PyObject *resultobj;
13911 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13912 wxString *result;
13913 PyObject * obj0 = 0 ;
13914 char *kwnames[] = {
13915 (char *) "self", NULL
13916 };
13917
13918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
13919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13920 if (SWIG_arg_fail(1)) SWIG_fail;
13921 {
13922 PyThreadState* __tstate = wxPyBeginAllowThreads();
13923 {
13924 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
13925 result = (wxString *) &_result_ref;
13926 }
13927
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 {
13932 #if wxUSE_UNICODE
13933 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13934 #else
13935 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13936 #endif
13937 }
13938 return resultobj;
13939 fail:
13940 return NULL;
13941 }
13942
13943
13944 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
13945 PyObject *resultobj;
13946 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13947 wxArrayString *result;
13948 PyObject * obj0 = 0 ;
13949 char *kwnames[] = {
13950 (char *) "self", NULL
13951 };
13952
13953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
13954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13955 if (SWIG_arg_fail(1)) SWIG_fail;
13956 {
13957 PyThreadState* __tstate = wxPyBeginAllowThreads();
13958 {
13959 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
13960 result = (wxArrayString *) &_result_ref;
13961 }
13962
13963 wxPyEndAllowThreads(__tstate);
13964 if (PyErr_Occurred()) SWIG_fail;
13965 }
13966 {
13967 resultobj = wxArrayString2PyList_helper(*result);
13968 }
13969 return resultobj;
13970 fail:
13971 return NULL;
13972 }
13973
13974
13975 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
13976 PyObject *resultobj;
13977 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13978 int result;
13979 PyObject * obj0 = 0 ;
13980 char *kwnames[] = {
13981 (char *) "self", NULL
13982 };
13983
13984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
13985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13986 if (SWIG_arg_fail(1)) SWIG_fail;
13987 {
13988 PyThreadState* __tstate = wxPyBeginAllowThreads();
13989 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
13990
13991 wxPyEndAllowThreads(__tstate);
13992 if (PyErr_Occurred()) SWIG_fail;
13993 }
13994 {
13995 resultobj = SWIG_From_int((int)(result));
13996 }
13997 return resultobj;
13998 fail:
13999 return NULL;
14000 }
14001
14002
14003 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14004 PyObject *resultobj;
14005 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14006 wxString *result;
14007 PyObject * obj0 = 0 ;
14008 char *kwnames[] = {
14009 (char *) "self", NULL
14010 };
14011
14012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14014 if (SWIG_arg_fail(1)) SWIG_fail;
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 {
14018 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14019 result = (wxString *) &_result_ref;
14020 }
14021
14022 wxPyEndAllowThreads(__tstate);
14023 if (PyErr_Occurred()) SWIG_fail;
14024 }
14025 {
14026 #if wxUSE_UNICODE
14027 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14028 #else
14029 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14030 #endif
14031 }
14032 return resultobj;
14033 fail:
14034 return NULL;
14035 }
14036
14037
14038 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14039 PyObject *resultobj;
14040 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14041 int result;
14042 PyObject * obj0 = 0 ;
14043 char *kwnames[] = {
14044 (char *) "self", NULL
14045 };
14046
14047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14049 if (SWIG_arg_fail(1)) SWIG_fail;
14050 {
14051 PyThreadState* __tstate = wxPyBeginAllowThreads();
14052 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14053
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 {
14058 resultobj = SWIG_From_int((int)(result));
14059 }
14060 return resultobj;
14061 fail:
14062 return NULL;
14063 }
14064
14065
14066 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14067 PyObject *obj;
14068 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14069 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14070 Py_INCREF(obj);
14071 return Py_BuildValue((char *)"");
14072 }
14073 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14074 PyObject *resultobj;
14075 wxFileTypeInfo *arg1 = 0 ;
14076 wxFileType *result;
14077 PyObject * obj0 = 0 ;
14078 char *kwnames[] = {
14079 (char *) "ftInfo", NULL
14080 };
14081
14082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14083 {
14084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14085 if (SWIG_arg_fail(1)) SWIG_fail;
14086 if (arg1 == NULL) {
14087 SWIG_null_ref("wxFileTypeInfo");
14088 }
14089 if (SWIG_arg_fail(1)) SWIG_fail;
14090 }
14091 {
14092 PyThreadState* __tstate = wxPyBeginAllowThreads();
14093 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14094
14095 wxPyEndAllowThreads(__tstate);
14096 if (PyErr_Occurred()) SWIG_fail;
14097 }
14098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14099 return resultobj;
14100 fail:
14101 return NULL;
14102 }
14103
14104
14105 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14106 PyObject *resultobj;
14107 wxFileType *arg1 = (wxFileType *) 0 ;
14108 PyObject * obj0 = 0 ;
14109 char *kwnames[] = {
14110 (char *) "self", NULL
14111 };
14112
14113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14115 if (SWIG_arg_fail(1)) SWIG_fail;
14116 {
14117 PyThreadState* __tstate = wxPyBeginAllowThreads();
14118 delete arg1;
14119
14120 wxPyEndAllowThreads(__tstate);
14121 if (PyErr_Occurred()) SWIG_fail;
14122 }
14123 Py_INCREF(Py_None); resultobj = Py_None;
14124 return resultobj;
14125 fail:
14126 return NULL;
14127 }
14128
14129
14130 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14131 PyObject *resultobj;
14132 wxFileType *arg1 = (wxFileType *) 0 ;
14133 PyObject *result;
14134 PyObject * obj0 = 0 ;
14135 char *kwnames[] = {
14136 (char *) "self", NULL
14137 };
14138
14139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14141 if (SWIG_arg_fail(1)) SWIG_fail;
14142 {
14143 PyThreadState* __tstate = wxPyBeginAllowThreads();
14144 result = (PyObject *)wxFileType_GetMimeType(arg1);
14145
14146 wxPyEndAllowThreads(__tstate);
14147 if (PyErr_Occurred()) SWIG_fail;
14148 }
14149 resultobj = result;
14150 return resultobj;
14151 fail:
14152 return NULL;
14153 }
14154
14155
14156 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14157 PyObject *resultobj;
14158 wxFileType *arg1 = (wxFileType *) 0 ;
14159 PyObject *result;
14160 PyObject * obj0 = 0 ;
14161 char *kwnames[] = {
14162 (char *) "self", NULL
14163 };
14164
14165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14167 if (SWIG_arg_fail(1)) SWIG_fail;
14168 {
14169 PyThreadState* __tstate = wxPyBeginAllowThreads();
14170 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14171
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 resultobj = result;
14176 return resultobj;
14177 fail:
14178 return NULL;
14179 }
14180
14181
14182 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14183 PyObject *resultobj;
14184 wxFileType *arg1 = (wxFileType *) 0 ;
14185 PyObject *result;
14186 PyObject * obj0 = 0 ;
14187 char *kwnames[] = {
14188 (char *) "self", NULL
14189 };
14190
14191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14193 if (SWIG_arg_fail(1)) SWIG_fail;
14194 {
14195 PyThreadState* __tstate = wxPyBeginAllowThreads();
14196 result = (PyObject *)wxFileType_GetExtensions(arg1);
14197
14198 wxPyEndAllowThreads(__tstate);
14199 if (PyErr_Occurred()) SWIG_fail;
14200 }
14201 resultobj = result;
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj;
14210 wxFileType *arg1 = (wxFileType *) 0 ;
14211 wxIcon *result;
14212 PyObject * obj0 = 0 ;
14213 char *kwnames[] = {
14214 (char *) "self", NULL
14215 };
14216
14217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14219 if (SWIG_arg_fail(1)) SWIG_fail;
14220 {
14221 PyThreadState* __tstate = wxPyBeginAllowThreads();
14222 result = (wxIcon *)wxFileType_GetIcon(arg1);
14223
14224 wxPyEndAllowThreads(__tstate);
14225 if (PyErr_Occurred()) SWIG_fail;
14226 }
14227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14228 return resultobj;
14229 fail:
14230 return NULL;
14231 }
14232
14233
14234 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14235 PyObject *resultobj;
14236 wxFileType *arg1 = (wxFileType *) 0 ;
14237 PyObject *result;
14238 PyObject * obj0 = 0 ;
14239 char *kwnames[] = {
14240 (char *) "self", NULL
14241 };
14242
14243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14245 if (SWIG_arg_fail(1)) SWIG_fail;
14246 {
14247 PyThreadState* __tstate = wxPyBeginAllowThreads();
14248 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14249
14250 wxPyEndAllowThreads(__tstate);
14251 if (PyErr_Occurred()) SWIG_fail;
14252 }
14253 resultobj = result;
14254 return resultobj;
14255 fail:
14256 return NULL;
14257 }
14258
14259
14260 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14261 PyObject *resultobj;
14262 wxFileType *arg1 = (wxFileType *) 0 ;
14263 PyObject *result;
14264 PyObject * obj0 = 0 ;
14265 char *kwnames[] = {
14266 (char *) "self", NULL
14267 };
14268
14269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14271 if (SWIG_arg_fail(1)) SWIG_fail;
14272 {
14273 PyThreadState* __tstate = wxPyBeginAllowThreads();
14274 result = (PyObject *)wxFileType_GetDescription(arg1);
14275
14276 wxPyEndAllowThreads(__tstate);
14277 if (PyErr_Occurred()) SWIG_fail;
14278 }
14279 resultobj = result;
14280 return resultobj;
14281 fail:
14282 return NULL;
14283 }
14284
14285
14286 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14287 PyObject *resultobj;
14288 wxFileType *arg1 = (wxFileType *) 0 ;
14289 wxString *arg2 = 0 ;
14290 wxString const &arg3_defvalue = wxPyEmptyString ;
14291 wxString *arg3 = (wxString *) &arg3_defvalue ;
14292 PyObject *result;
14293 bool temp2 = false ;
14294 bool temp3 = false ;
14295 PyObject * obj0 = 0 ;
14296 PyObject * obj1 = 0 ;
14297 PyObject * obj2 = 0 ;
14298 char *kwnames[] = {
14299 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14300 };
14301
14302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14304 if (SWIG_arg_fail(1)) SWIG_fail;
14305 {
14306 arg2 = wxString_in_helper(obj1);
14307 if (arg2 == NULL) SWIG_fail;
14308 temp2 = true;
14309 }
14310 if (obj2) {
14311 {
14312 arg3 = wxString_in_helper(obj2);
14313 if (arg3 == NULL) SWIG_fail;
14314 temp3 = true;
14315 }
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14320
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 resultobj = result;
14325 {
14326 if (temp2)
14327 delete arg2;
14328 }
14329 {
14330 if (temp3)
14331 delete arg3;
14332 }
14333 return resultobj;
14334 fail:
14335 {
14336 if (temp2)
14337 delete arg2;
14338 }
14339 {
14340 if (temp3)
14341 delete arg3;
14342 }
14343 return NULL;
14344 }
14345
14346
14347 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj;
14349 wxFileType *arg1 = (wxFileType *) 0 ;
14350 wxString *arg2 = 0 ;
14351 wxString const &arg3_defvalue = wxPyEmptyString ;
14352 wxString *arg3 = (wxString *) &arg3_defvalue ;
14353 PyObject *result;
14354 bool temp2 = false ;
14355 bool temp3 = false ;
14356 PyObject * obj0 = 0 ;
14357 PyObject * obj1 = 0 ;
14358 PyObject * obj2 = 0 ;
14359 char *kwnames[] = {
14360 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14361 };
14362
14363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14365 if (SWIG_arg_fail(1)) SWIG_fail;
14366 {
14367 arg2 = wxString_in_helper(obj1);
14368 if (arg2 == NULL) SWIG_fail;
14369 temp2 = true;
14370 }
14371 if (obj2) {
14372 {
14373 arg3 = wxString_in_helper(obj2);
14374 if (arg3 == NULL) SWIG_fail;
14375 temp3 = true;
14376 }
14377 }
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14381
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 resultobj = result;
14386 {
14387 if (temp2)
14388 delete arg2;
14389 }
14390 {
14391 if (temp3)
14392 delete arg3;
14393 }
14394 return resultobj;
14395 fail:
14396 {
14397 if (temp2)
14398 delete arg2;
14399 }
14400 {
14401 if (temp3)
14402 delete arg3;
14403 }
14404 return NULL;
14405 }
14406
14407
14408 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj;
14410 wxFileType *arg1 = (wxFileType *) 0 ;
14411 wxString *arg2 = 0 ;
14412 wxString const &arg3_defvalue = wxPyEmptyString ;
14413 wxString *arg3 = (wxString *) &arg3_defvalue ;
14414 PyObject *result;
14415 bool temp2 = false ;
14416 bool temp3 = false ;
14417 PyObject * obj0 = 0 ;
14418 PyObject * obj1 = 0 ;
14419 PyObject * obj2 = 0 ;
14420 char *kwnames[] = {
14421 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14422 };
14423
14424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14426 if (SWIG_arg_fail(1)) SWIG_fail;
14427 {
14428 arg2 = wxString_in_helper(obj1);
14429 if (arg2 == NULL) SWIG_fail;
14430 temp2 = true;
14431 }
14432 if (obj2) {
14433 {
14434 arg3 = wxString_in_helper(obj2);
14435 if (arg3 == NULL) SWIG_fail;
14436 temp3 = true;
14437 }
14438 }
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14442
14443 wxPyEndAllowThreads(__tstate);
14444 if (PyErr_Occurred()) SWIG_fail;
14445 }
14446 resultobj = result;
14447 {
14448 if (temp2)
14449 delete arg2;
14450 }
14451 {
14452 if (temp3)
14453 delete arg3;
14454 }
14455 return resultobj;
14456 fail:
14457 {
14458 if (temp2)
14459 delete arg2;
14460 }
14461 {
14462 if (temp3)
14463 delete arg3;
14464 }
14465 return NULL;
14466 }
14467
14468
14469 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14470 PyObject *resultobj;
14471 wxFileType *arg1 = (wxFileType *) 0 ;
14472 wxString *arg2 = 0 ;
14473 wxString *arg3 = 0 ;
14474 bool arg4 = (bool) true ;
14475 bool result;
14476 bool temp2 = false ;
14477 bool temp3 = false ;
14478 PyObject * obj0 = 0 ;
14479 PyObject * obj1 = 0 ;
14480 PyObject * obj2 = 0 ;
14481 PyObject * obj3 = 0 ;
14482 char *kwnames[] = {
14483 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14484 };
14485
14486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14488 if (SWIG_arg_fail(1)) SWIG_fail;
14489 {
14490 arg2 = wxString_in_helper(obj1);
14491 if (arg2 == NULL) SWIG_fail;
14492 temp2 = true;
14493 }
14494 {
14495 arg3 = wxString_in_helper(obj2);
14496 if (arg3 == NULL) SWIG_fail;
14497 temp3 = true;
14498 }
14499 if (obj3) {
14500 {
14501 arg4 = (bool)(SWIG_As_bool(obj3));
14502 if (SWIG_arg_fail(4)) SWIG_fail;
14503 }
14504 }
14505 {
14506 PyThreadState* __tstate = wxPyBeginAllowThreads();
14507 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14508
14509 wxPyEndAllowThreads(__tstate);
14510 if (PyErr_Occurred()) SWIG_fail;
14511 }
14512 {
14513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14514 }
14515 {
14516 if (temp2)
14517 delete arg2;
14518 }
14519 {
14520 if (temp3)
14521 delete arg3;
14522 }
14523 return resultobj;
14524 fail:
14525 {
14526 if (temp2)
14527 delete arg2;
14528 }
14529 {
14530 if (temp3)
14531 delete arg3;
14532 }
14533 return NULL;
14534 }
14535
14536
14537 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14538 PyObject *resultobj;
14539 wxFileType *arg1 = (wxFileType *) 0 ;
14540 wxString const &arg2_defvalue = wxPyEmptyString ;
14541 wxString *arg2 = (wxString *) &arg2_defvalue ;
14542 int arg3 = (int) 0 ;
14543 bool result;
14544 bool temp2 = false ;
14545 PyObject * obj0 = 0 ;
14546 PyObject * obj1 = 0 ;
14547 PyObject * obj2 = 0 ;
14548 char *kwnames[] = {
14549 (char *) "self",(char *) "cmd",(char *) "index", NULL
14550 };
14551
14552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14554 if (SWIG_arg_fail(1)) SWIG_fail;
14555 if (obj1) {
14556 {
14557 arg2 = wxString_in_helper(obj1);
14558 if (arg2 == NULL) SWIG_fail;
14559 temp2 = true;
14560 }
14561 }
14562 if (obj2) {
14563 {
14564 arg3 = (int)(SWIG_As_int(obj2));
14565 if (SWIG_arg_fail(3)) SWIG_fail;
14566 }
14567 }
14568 {
14569 PyThreadState* __tstate = wxPyBeginAllowThreads();
14570 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14571
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 {
14576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14577 }
14578 {
14579 if (temp2)
14580 delete arg2;
14581 }
14582 return resultobj;
14583 fail:
14584 {
14585 if (temp2)
14586 delete arg2;
14587 }
14588 return NULL;
14589 }
14590
14591
14592 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14593 PyObject *resultobj;
14594 wxFileType *arg1 = (wxFileType *) 0 ;
14595 bool result;
14596 PyObject * obj0 = 0 ;
14597 char *kwnames[] = {
14598 (char *) "self", NULL
14599 };
14600
14601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14603 if (SWIG_arg_fail(1)) SWIG_fail;
14604 {
14605 PyThreadState* __tstate = wxPyBeginAllowThreads();
14606 result = (bool)(arg1)->Unassociate();
14607
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 {
14612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14613 }
14614 return resultobj;
14615 fail:
14616 return NULL;
14617 }
14618
14619
14620 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14621 PyObject *resultobj;
14622 wxString *arg1 = 0 ;
14623 wxString *arg2 = 0 ;
14624 wxString const &arg3_defvalue = wxPyEmptyString ;
14625 wxString *arg3 = (wxString *) &arg3_defvalue ;
14626 wxString result;
14627 bool temp1 = false ;
14628 bool temp2 = false ;
14629 bool temp3 = false ;
14630 PyObject * obj0 = 0 ;
14631 PyObject * obj1 = 0 ;
14632 PyObject * obj2 = 0 ;
14633 char *kwnames[] = {
14634 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14635 };
14636
14637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14638 {
14639 arg1 = wxString_in_helper(obj0);
14640 if (arg1 == NULL) SWIG_fail;
14641 temp1 = true;
14642 }
14643 {
14644 arg2 = wxString_in_helper(obj1);
14645 if (arg2 == NULL) SWIG_fail;
14646 temp2 = true;
14647 }
14648 if (obj2) {
14649 {
14650 arg3 = wxString_in_helper(obj2);
14651 if (arg3 == NULL) SWIG_fail;
14652 temp3 = true;
14653 }
14654 }
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14658
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 {
14663 #if wxUSE_UNICODE
14664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14665 #else
14666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14667 #endif
14668 }
14669 {
14670 if (temp1)
14671 delete arg1;
14672 }
14673 {
14674 if (temp2)
14675 delete arg2;
14676 }
14677 {
14678 if (temp3)
14679 delete arg3;
14680 }
14681 return resultobj;
14682 fail:
14683 {
14684 if (temp1)
14685 delete arg1;
14686 }
14687 {
14688 if (temp2)
14689 delete arg2;
14690 }
14691 {
14692 if (temp3)
14693 delete arg3;
14694 }
14695 return NULL;
14696 }
14697
14698
14699 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14700 PyObject *obj;
14701 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14702 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14703 Py_INCREF(obj);
14704 return Py_BuildValue((char *)"");
14705 }
14706 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14707 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14708 return 1;
14709 }
14710
14711
14712 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14713 PyObject *pyobj;
14714
14715 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14716 return pyobj;
14717 }
14718
14719
14720 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14721 PyObject *resultobj;
14722 wxString *arg1 = 0 ;
14723 wxString *arg2 = 0 ;
14724 bool result;
14725 bool temp1 = false ;
14726 bool temp2 = false ;
14727 PyObject * obj0 = 0 ;
14728 PyObject * obj1 = 0 ;
14729 char *kwnames[] = {
14730 (char *) "mimeType",(char *) "wildcard", NULL
14731 };
14732
14733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14734 {
14735 arg1 = wxString_in_helper(obj0);
14736 if (arg1 == NULL) SWIG_fail;
14737 temp1 = true;
14738 }
14739 {
14740 arg2 = wxString_in_helper(obj1);
14741 if (arg2 == NULL) SWIG_fail;
14742 temp2 = true;
14743 }
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14747
14748 wxPyEndAllowThreads(__tstate);
14749 if (PyErr_Occurred()) SWIG_fail;
14750 }
14751 {
14752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14753 }
14754 {
14755 if (temp1)
14756 delete arg1;
14757 }
14758 {
14759 if (temp2)
14760 delete arg2;
14761 }
14762 return resultobj;
14763 fail:
14764 {
14765 if (temp1)
14766 delete arg1;
14767 }
14768 {
14769 if (temp2)
14770 delete arg2;
14771 }
14772 return NULL;
14773 }
14774
14775
14776 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14777 PyObject *resultobj;
14778 wxMimeTypesManager *result;
14779 char *kwnames[] = {
14780 NULL
14781 };
14782
14783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14787
14788 wxPyEndAllowThreads(__tstate);
14789 if (PyErr_Occurred()) SWIG_fail;
14790 }
14791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14792 return resultobj;
14793 fail:
14794 return NULL;
14795 }
14796
14797
14798 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14799 PyObject *resultobj;
14800 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14801 int arg2 = (int) wxMAILCAP_ALL ;
14802 wxString const &arg3_defvalue = wxPyEmptyString ;
14803 wxString *arg3 = (wxString *) &arg3_defvalue ;
14804 bool temp3 = false ;
14805 PyObject * obj0 = 0 ;
14806 PyObject * obj1 = 0 ;
14807 PyObject * obj2 = 0 ;
14808 char *kwnames[] = {
14809 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14810 };
14811
14812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14814 if (SWIG_arg_fail(1)) SWIG_fail;
14815 if (obj1) {
14816 {
14817 arg2 = (int)(SWIG_As_int(obj1));
14818 if (SWIG_arg_fail(2)) SWIG_fail;
14819 }
14820 }
14821 if (obj2) {
14822 {
14823 arg3 = wxString_in_helper(obj2);
14824 if (arg3 == NULL) SWIG_fail;
14825 temp3 = true;
14826 }
14827 }
14828 {
14829 PyThreadState* __tstate = wxPyBeginAllowThreads();
14830 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14831
14832 wxPyEndAllowThreads(__tstate);
14833 if (PyErr_Occurred()) SWIG_fail;
14834 }
14835 Py_INCREF(Py_None); resultobj = Py_None;
14836 {
14837 if (temp3)
14838 delete arg3;
14839 }
14840 return resultobj;
14841 fail:
14842 {
14843 if (temp3)
14844 delete arg3;
14845 }
14846 return NULL;
14847 }
14848
14849
14850 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14851 PyObject *resultobj;
14852 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14853 PyObject * obj0 = 0 ;
14854 char *kwnames[] = {
14855 (char *) "self", NULL
14856 };
14857
14858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14860 if (SWIG_arg_fail(1)) SWIG_fail;
14861 {
14862 PyThreadState* __tstate = wxPyBeginAllowThreads();
14863 (arg1)->ClearData();
14864
14865 wxPyEndAllowThreads(__tstate);
14866 if (PyErr_Occurred()) SWIG_fail;
14867 }
14868 Py_INCREF(Py_None); resultobj = Py_None;
14869 return resultobj;
14870 fail:
14871 return NULL;
14872 }
14873
14874
14875 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
14876 PyObject *resultobj;
14877 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14878 wxString *arg2 = 0 ;
14879 wxFileType *result;
14880 bool temp2 = false ;
14881 PyObject * obj0 = 0 ;
14882 PyObject * obj1 = 0 ;
14883 char *kwnames[] = {
14884 (char *) "self",(char *) "ext", NULL
14885 };
14886
14887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
14888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14889 if (SWIG_arg_fail(1)) SWIG_fail;
14890 {
14891 arg2 = wxString_in_helper(obj1);
14892 if (arg2 == NULL) SWIG_fail;
14893 temp2 = true;
14894 }
14895 {
14896 PyThreadState* __tstate = wxPyBeginAllowThreads();
14897 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
14898
14899 wxPyEndAllowThreads(__tstate);
14900 if (PyErr_Occurred()) SWIG_fail;
14901 }
14902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14903 {
14904 if (temp2)
14905 delete arg2;
14906 }
14907 return resultobj;
14908 fail:
14909 {
14910 if (temp2)
14911 delete arg2;
14912 }
14913 return NULL;
14914 }
14915
14916
14917 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj;
14919 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14920 wxString *arg2 = 0 ;
14921 wxFileType *result;
14922 bool temp2 = false ;
14923 PyObject * obj0 = 0 ;
14924 PyObject * obj1 = 0 ;
14925 char *kwnames[] = {
14926 (char *) "self",(char *) "mimeType", NULL
14927 };
14928
14929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
14930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14931 if (SWIG_arg_fail(1)) SWIG_fail;
14932 {
14933 arg2 = wxString_in_helper(obj1);
14934 if (arg2 == NULL) SWIG_fail;
14935 temp2 = true;
14936 }
14937 {
14938 PyThreadState* __tstate = wxPyBeginAllowThreads();
14939 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
14940
14941 wxPyEndAllowThreads(__tstate);
14942 if (PyErr_Occurred()) SWIG_fail;
14943 }
14944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14945 {
14946 if (temp2)
14947 delete arg2;
14948 }
14949 return resultobj;
14950 fail:
14951 {
14952 if (temp2)
14953 delete arg2;
14954 }
14955 return NULL;
14956 }
14957
14958
14959 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
14960 PyObject *resultobj;
14961 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14962 wxString *arg2 = 0 ;
14963 bool arg3 = (bool) false ;
14964 bool result;
14965 bool temp2 = false ;
14966 PyObject * obj0 = 0 ;
14967 PyObject * obj1 = 0 ;
14968 PyObject * obj2 = 0 ;
14969 char *kwnames[] = {
14970 (char *) "self",(char *) "filename",(char *) "fallback", NULL
14971 };
14972
14973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
14974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14975 if (SWIG_arg_fail(1)) SWIG_fail;
14976 {
14977 arg2 = wxString_in_helper(obj1);
14978 if (arg2 == NULL) SWIG_fail;
14979 temp2 = true;
14980 }
14981 if (obj2) {
14982 {
14983 arg3 = (bool)(SWIG_As_bool(obj2));
14984 if (SWIG_arg_fail(3)) SWIG_fail;
14985 }
14986 }
14987 {
14988 PyThreadState* __tstate = wxPyBeginAllowThreads();
14989 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
14990
14991 wxPyEndAllowThreads(__tstate);
14992 if (PyErr_Occurred()) SWIG_fail;
14993 }
14994 {
14995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14996 }
14997 {
14998 if (temp2)
14999 delete arg2;
15000 }
15001 return resultobj;
15002 fail:
15003 {
15004 if (temp2)
15005 delete arg2;
15006 }
15007 return NULL;
15008 }
15009
15010
15011 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15012 PyObject *resultobj;
15013 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15014 wxString *arg2 = 0 ;
15015 bool result;
15016 bool temp2 = false ;
15017 PyObject * obj0 = 0 ;
15018 PyObject * obj1 = 0 ;
15019 char *kwnames[] = {
15020 (char *) "self",(char *) "filename", NULL
15021 };
15022
15023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15025 if (SWIG_arg_fail(1)) SWIG_fail;
15026 {
15027 arg2 = wxString_in_helper(obj1);
15028 if (arg2 == NULL) SWIG_fail;
15029 temp2 = true;
15030 }
15031 {
15032 PyThreadState* __tstate = wxPyBeginAllowThreads();
15033 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15034
15035 wxPyEndAllowThreads(__tstate);
15036 if (PyErr_Occurred()) SWIG_fail;
15037 }
15038 {
15039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15040 }
15041 {
15042 if (temp2)
15043 delete arg2;
15044 }
15045 return resultobj;
15046 fail:
15047 {
15048 if (temp2)
15049 delete arg2;
15050 }
15051 return NULL;
15052 }
15053
15054
15055 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15056 PyObject *resultobj;
15057 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15058 PyObject *result;
15059 PyObject * obj0 = 0 ;
15060 char *kwnames[] = {
15061 (char *) "self", NULL
15062 };
15063
15064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15066 if (SWIG_arg_fail(1)) SWIG_fail;
15067 {
15068 PyThreadState* __tstate = wxPyBeginAllowThreads();
15069 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15070
15071 wxPyEndAllowThreads(__tstate);
15072 if (PyErr_Occurred()) SWIG_fail;
15073 }
15074 resultobj = result;
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15082 PyObject *resultobj;
15083 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15084 wxFileTypeInfo *arg2 = 0 ;
15085 PyObject * obj0 = 0 ;
15086 PyObject * obj1 = 0 ;
15087 char *kwnames[] = {
15088 (char *) "self",(char *) "ft", NULL
15089 };
15090
15091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15093 if (SWIG_arg_fail(1)) SWIG_fail;
15094 {
15095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15096 if (SWIG_arg_fail(2)) SWIG_fail;
15097 if (arg2 == NULL) {
15098 SWIG_null_ref("wxFileTypeInfo");
15099 }
15100 if (SWIG_arg_fail(2)) SWIG_fail;
15101 }
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15105
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 Py_INCREF(Py_None); resultobj = Py_None;
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj;
15118 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15119 wxFileTypeInfo *arg2 = 0 ;
15120 wxFileType *result;
15121 PyObject * obj0 = 0 ;
15122 PyObject * obj1 = 0 ;
15123 char *kwnames[] = {
15124 (char *) "self",(char *) "ftInfo", NULL
15125 };
15126
15127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15129 if (SWIG_arg_fail(1)) SWIG_fail;
15130 {
15131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15132 if (SWIG_arg_fail(2)) SWIG_fail;
15133 if (arg2 == NULL) {
15134 SWIG_null_ref("wxFileTypeInfo");
15135 }
15136 if (SWIG_arg_fail(2)) SWIG_fail;
15137 }
15138 {
15139 PyThreadState* __tstate = wxPyBeginAllowThreads();
15140 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15141
15142 wxPyEndAllowThreads(__tstate);
15143 if (PyErr_Occurred()) SWIG_fail;
15144 }
15145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15146 return resultobj;
15147 fail:
15148 return NULL;
15149 }
15150
15151
15152 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15153 PyObject *resultobj;
15154 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15155 wxFileType *arg2 = (wxFileType *) 0 ;
15156 bool result;
15157 PyObject * obj0 = 0 ;
15158 PyObject * obj1 = 0 ;
15159 char *kwnames[] = {
15160 (char *) "self",(char *) "ft", NULL
15161 };
15162
15163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15165 if (SWIG_arg_fail(1)) SWIG_fail;
15166 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15167 if (SWIG_arg_fail(2)) SWIG_fail;
15168 {
15169 PyThreadState* __tstate = wxPyBeginAllowThreads();
15170 result = (bool)(arg1)->Unassociate(arg2);
15171
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 {
15176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15177 }
15178 return resultobj;
15179 fail:
15180 return NULL;
15181 }
15182
15183
15184 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15185 PyObject *resultobj;
15186 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15187 PyObject * obj0 = 0 ;
15188 char *kwnames[] = {
15189 (char *) "self", NULL
15190 };
15191
15192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15194 if (SWIG_arg_fail(1)) SWIG_fail;
15195 {
15196 PyThreadState* __tstate = wxPyBeginAllowThreads();
15197 delete arg1;
15198
15199 wxPyEndAllowThreads(__tstate);
15200 if (PyErr_Occurred()) SWIG_fail;
15201 }
15202 Py_INCREF(Py_None); resultobj = Py_None;
15203 return resultobj;
15204 fail:
15205 return NULL;
15206 }
15207
15208
15209 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15210 PyObject *obj;
15211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15212 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15213 Py_INCREF(obj);
15214 return Py_BuildValue((char *)"");
15215 }
15216 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15217 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15218 return 1;
15219 }
15220
15221
15222 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15223 PyObject *pyobj;
15224
15225 {
15226 #if wxUSE_UNICODE
15227 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15228 #else
15229 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15230 #endif
15231 }
15232 return pyobj;
15233 }
15234
15235
15236 static int _wrap_ART_MENU_set(PyObject *) {
15237 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15238 return 1;
15239 }
15240
15241
15242 static PyObject *_wrap_ART_MENU_get(void) {
15243 PyObject *pyobj;
15244
15245 {
15246 #if wxUSE_UNICODE
15247 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15248 #else
15249 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15250 #endif
15251 }
15252 return pyobj;
15253 }
15254
15255
15256 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15257 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15258 return 1;
15259 }
15260
15261
15262 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15263 PyObject *pyobj;
15264
15265 {
15266 #if wxUSE_UNICODE
15267 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15268 #else
15269 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15270 #endif
15271 }
15272 return pyobj;
15273 }
15274
15275
15276 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15277 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15278 return 1;
15279 }
15280
15281
15282 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15283 PyObject *pyobj;
15284
15285 {
15286 #if wxUSE_UNICODE
15287 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15288 #else
15289 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15290 #endif
15291 }
15292 return pyobj;
15293 }
15294
15295
15296 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15297 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15298 return 1;
15299 }
15300
15301
15302 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15303 PyObject *pyobj;
15304
15305 {
15306 #if wxUSE_UNICODE
15307 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15308 #else
15309 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15310 #endif
15311 }
15312 return pyobj;
15313 }
15314
15315
15316 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15317 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15318 return 1;
15319 }
15320
15321
15322 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15323 PyObject *pyobj;
15324
15325 {
15326 #if wxUSE_UNICODE
15327 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15328 #else
15329 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15330 #endif
15331 }
15332 return pyobj;
15333 }
15334
15335
15336 static int _wrap_ART_BUTTON_set(PyObject *) {
15337 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15338 return 1;
15339 }
15340
15341
15342 static PyObject *_wrap_ART_BUTTON_get(void) {
15343 PyObject *pyobj;
15344
15345 {
15346 #if wxUSE_UNICODE
15347 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15348 #else
15349 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15350 #endif
15351 }
15352 return pyobj;
15353 }
15354
15355
15356 static int _wrap_ART_OTHER_set(PyObject *) {
15357 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15358 return 1;
15359 }
15360
15361
15362 static PyObject *_wrap_ART_OTHER_get(void) {
15363 PyObject *pyobj;
15364
15365 {
15366 #if wxUSE_UNICODE
15367 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15368 #else
15369 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15370 #endif
15371 }
15372 return pyobj;
15373 }
15374
15375
15376 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15377 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15378 return 1;
15379 }
15380
15381
15382 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15383 PyObject *pyobj;
15384
15385 {
15386 #if wxUSE_UNICODE
15387 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15388 #else
15389 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15390 #endif
15391 }
15392 return pyobj;
15393 }
15394
15395
15396 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15397 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15398 return 1;
15399 }
15400
15401
15402 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15403 PyObject *pyobj;
15404
15405 {
15406 #if wxUSE_UNICODE
15407 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15408 #else
15409 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15410 #endif
15411 }
15412 return pyobj;
15413 }
15414
15415
15416 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15417 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15418 return 1;
15419 }
15420
15421
15422 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15423 PyObject *pyobj;
15424
15425 {
15426 #if wxUSE_UNICODE
15427 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15428 #else
15429 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15430 #endif
15431 }
15432 return pyobj;
15433 }
15434
15435
15436 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15437 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15438 return 1;
15439 }
15440
15441
15442 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15443 PyObject *pyobj;
15444
15445 {
15446 #if wxUSE_UNICODE
15447 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15448 #else
15449 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15450 #endif
15451 }
15452 return pyobj;
15453 }
15454
15455
15456 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15457 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15458 return 1;
15459 }
15460
15461
15462 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15463 PyObject *pyobj;
15464
15465 {
15466 #if wxUSE_UNICODE
15467 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15468 #else
15469 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15470 #endif
15471 }
15472 return pyobj;
15473 }
15474
15475
15476 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15477 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15478 return 1;
15479 }
15480
15481
15482 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15483 PyObject *pyobj;
15484
15485 {
15486 #if wxUSE_UNICODE
15487 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15488 #else
15489 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15490 #endif
15491 }
15492 return pyobj;
15493 }
15494
15495
15496 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15497 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15498 return 1;
15499 }
15500
15501
15502 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15503 PyObject *pyobj;
15504
15505 {
15506 #if wxUSE_UNICODE
15507 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15508 #else
15509 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15510 #endif
15511 }
15512 return pyobj;
15513 }
15514
15515
15516 static int _wrap_ART_GO_BACK_set(PyObject *) {
15517 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15518 return 1;
15519 }
15520
15521
15522 static PyObject *_wrap_ART_GO_BACK_get(void) {
15523 PyObject *pyobj;
15524
15525 {
15526 #if wxUSE_UNICODE
15527 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15528 #else
15529 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15530 #endif
15531 }
15532 return pyobj;
15533 }
15534
15535
15536 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15537 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15538 return 1;
15539 }
15540
15541
15542 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15543 PyObject *pyobj;
15544
15545 {
15546 #if wxUSE_UNICODE
15547 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15548 #else
15549 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15550 #endif
15551 }
15552 return pyobj;
15553 }
15554
15555
15556 static int _wrap_ART_GO_UP_set(PyObject *) {
15557 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15558 return 1;
15559 }
15560
15561
15562 static PyObject *_wrap_ART_GO_UP_get(void) {
15563 PyObject *pyobj;
15564
15565 {
15566 #if wxUSE_UNICODE
15567 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15568 #else
15569 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15570 #endif
15571 }
15572 return pyobj;
15573 }
15574
15575
15576 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15577 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15578 return 1;
15579 }
15580
15581
15582 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15583 PyObject *pyobj;
15584
15585 {
15586 #if wxUSE_UNICODE
15587 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15588 #else
15589 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15590 #endif
15591 }
15592 return pyobj;
15593 }
15594
15595
15596 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15597 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15598 return 1;
15599 }
15600
15601
15602 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15603 PyObject *pyobj;
15604
15605 {
15606 #if wxUSE_UNICODE
15607 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15608 #else
15609 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15610 #endif
15611 }
15612 return pyobj;
15613 }
15614
15615
15616 static int _wrap_ART_GO_HOME_set(PyObject *) {
15617 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15618 return 1;
15619 }
15620
15621
15622 static PyObject *_wrap_ART_GO_HOME_get(void) {
15623 PyObject *pyobj;
15624
15625 {
15626 #if wxUSE_UNICODE
15627 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15628 #else
15629 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15630 #endif
15631 }
15632 return pyobj;
15633 }
15634
15635
15636 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15637 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15638 return 1;
15639 }
15640
15641
15642 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15643 PyObject *pyobj;
15644
15645 {
15646 #if wxUSE_UNICODE
15647 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15648 #else
15649 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15650 #endif
15651 }
15652 return pyobj;
15653 }
15654
15655
15656 static int _wrap_ART_PRINT_set(PyObject *) {
15657 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15658 return 1;
15659 }
15660
15661
15662 static PyObject *_wrap_ART_PRINT_get(void) {
15663 PyObject *pyobj;
15664
15665 {
15666 #if wxUSE_UNICODE
15667 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15668 #else
15669 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15670 #endif
15671 }
15672 return pyobj;
15673 }
15674
15675
15676 static int _wrap_ART_HELP_set(PyObject *) {
15677 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15678 return 1;
15679 }
15680
15681
15682 static PyObject *_wrap_ART_HELP_get(void) {
15683 PyObject *pyobj;
15684
15685 {
15686 #if wxUSE_UNICODE
15687 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15688 #else
15689 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15690 #endif
15691 }
15692 return pyobj;
15693 }
15694
15695
15696 static int _wrap_ART_TIP_set(PyObject *) {
15697 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15698 return 1;
15699 }
15700
15701
15702 static PyObject *_wrap_ART_TIP_get(void) {
15703 PyObject *pyobj;
15704
15705 {
15706 #if wxUSE_UNICODE
15707 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15708 #else
15709 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15710 #endif
15711 }
15712 return pyobj;
15713 }
15714
15715
15716 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15717 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15718 return 1;
15719 }
15720
15721
15722 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15723 PyObject *pyobj;
15724
15725 {
15726 #if wxUSE_UNICODE
15727 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15728 #else
15729 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15730 #endif
15731 }
15732 return pyobj;
15733 }
15734
15735
15736 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15737 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15738 return 1;
15739 }
15740
15741
15742 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15743 PyObject *pyobj;
15744
15745 {
15746 #if wxUSE_UNICODE
15747 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15748 #else
15749 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15750 #endif
15751 }
15752 return pyobj;
15753 }
15754
15755
15756 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15757 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15758 return 1;
15759 }
15760
15761
15762 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15763 PyObject *pyobj;
15764
15765 {
15766 #if wxUSE_UNICODE
15767 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15768 #else
15769 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15770 #endif
15771 }
15772 return pyobj;
15773 }
15774
15775
15776 static int _wrap_ART_HARDDISK_set(PyObject *) {
15777 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15778 return 1;
15779 }
15780
15781
15782 static PyObject *_wrap_ART_HARDDISK_get(void) {
15783 PyObject *pyobj;
15784
15785 {
15786 #if wxUSE_UNICODE
15787 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15788 #else
15789 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15790 #endif
15791 }
15792 return pyobj;
15793 }
15794
15795
15796 static int _wrap_ART_FLOPPY_set(PyObject *) {
15797 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15798 return 1;
15799 }
15800
15801
15802 static PyObject *_wrap_ART_FLOPPY_get(void) {
15803 PyObject *pyobj;
15804
15805 {
15806 #if wxUSE_UNICODE
15807 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15808 #else
15809 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15810 #endif
15811 }
15812 return pyobj;
15813 }
15814
15815
15816 static int _wrap_ART_CDROM_set(PyObject *) {
15817 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15818 return 1;
15819 }
15820
15821
15822 static PyObject *_wrap_ART_CDROM_get(void) {
15823 PyObject *pyobj;
15824
15825 {
15826 #if wxUSE_UNICODE
15827 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15828 #else
15829 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15830 #endif
15831 }
15832 return pyobj;
15833 }
15834
15835
15836 static int _wrap_ART_REMOVABLE_set(PyObject *) {
15837 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
15838 return 1;
15839 }
15840
15841
15842 static PyObject *_wrap_ART_REMOVABLE_get(void) {
15843 PyObject *pyobj;
15844
15845 {
15846 #if wxUSE_UNICODE
15847 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15848 #else
15849 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15850 #endif
15851 }
15852 return pyobj;
15853 }
15854
15855
15856 static int _wrap_ART_FOLDER_set(PyObject *) {
15857 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
15858 return 1;
15859 }
15860
15861
15862 static PyObject *_wrap_ART_FOLDER_get(void) {
15863 PyObject *pyobj;
15864
15865 {
15866 #if wxUSE_UNICODE
15867 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15868 #else
15869 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15870 #endif
15871 }
15872 return pyobj;
15873 }
15874
15875
15876 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
15877 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
15878 return 1;
15879 }
15880
15881
15882 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
15883 PyObject *pyobj;
15884
15885 {
15886 #if wxUSE_UNICODE
15887 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15888 #else
15889 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15890 #endif
15891 }
15892 return pyobj;
15893 }
15894
15895
15896 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
15897 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
15898 return 1;
15899 }
15900
15901
15902 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
15903 PyObject *pyobj;
15904
15905 {
15906 #if wxUSE_UNICODE
15907 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15908 #else
15909 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15910 #endif
15911 }
15912 return pyobj;
15913 }
15914
15915
15916 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
15917 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
15918 return 1;
15919 }
15920
15921
15922 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
15923 PyObject *pyobj;
15924
15925 {
15926 #if wxUSE_UNICODE
15927 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15928 #else
15929 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15930 #endif
15931 }
15932 return pyobj;
15933 }
15934
15935
15936 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
15937 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
15938 return 1;
15939 }
15940
15941
15942 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
15943 PyObject *pyobj;
15944
15945 {
15946 #if wxUSE_UNICODE
15947 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15948 #else
15949 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15950 #endif
15951 }
15952 return pyobj;
15953 }
15954
15955
15956 static int _wrap_ART_TICK_MARK_set(PyObject *) {
15957 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
15958 return 1;
15959 }
15960
15961
15962 static PyObject *_wrap_ART_TICK_MARK_get(void) {
15963 PyObject *pyobj;
15964
15965 {
15966 #if wxUSE_UNICODE
15967 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15968 #else
15969 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15970 #endif
15971 }
15972 return pyobj;
15973 }
15974
15975
15976 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
15977 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
15978 return 1;
15979 }
15980
15981
15982 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
15983 PyObject *pyobj;
15984
15985 {
15986 #if wxUSE_UNICODE
15987 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15988 #else
15989 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15990 #endif
15991 }
15992 return pyobj;
15993 }
15994
15995
15996 static int _wrap_ART_ERROR_set(PyObject *) {
15997 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
15998 return 1;
15999 }
16000
16001
16002 static PyObject *_wrap_ART_ERROR_get(void) {
16003 PyObject *pyobj;
16004
16005 {
16006 #if wxUSE_UNICODE
16007 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16008 #else
16009 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16010 #endif
16011 }
16012 return pyobj;
16013 }
16014
16015
16016 static int _wrap_ART_QUESTION_set(PyObject *) {
16017 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16018 return 1;
16019 }
16020
16021
16022 static PyObject *_wrap_ART_QUESTION_get(void) {
16023 PyObject *pyobj;
16024
16025 {
16026 #if wxUSE_UNICODE
16027 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16028 #else
16029 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16030 #endif
16031 }
16032 return pyobj;
16033 }
16034
16035
16036 static int _wrap_ART_WARNING_set(PyObject *) {
16037 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16038 return 1;
16039 }
16040
16041
16042 static PyObject *_wrap_ART_WARNING_get(void) {
16043 PyObject *pyobj;
16044
16045 {
16046 #if wxUSE_UNICODE
16047 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16048 #else
16049 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16050 #endif
16051 }
16052 return pyobj;
16053 }
16054
16055
16056 static int _wrap_ART_INFORMATION_set(PyObject *) {
16057 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16058 return 1;
16059 }
16060
16061
16062 static PyObject *_wrap_ART_INFORMATION_get(void) {
16063 PyObject *pyobj;
16064
16065 {
16066 #if wxUSE_UNICODE
16067 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16068 #else
16069 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16070 #endif
16071 }
16072 return pyobj;
16073 }
16074
16075
16076 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16077 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16078 return 1;
16079 }
16080
16081
16082 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16083 PyObject *pyobj;
16084
16085 {
16086 #if wxUSE_UNICODE
16087 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16088 #else
16089 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16090 #endif
16091 }
16092 return pyobj;
16093 }
16094
16095
16096 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16097 PyObject *resultobj;
16098 wxPyArtProvider *result;
16099 char *kwnames[] = {
16100 NULL
16101 };
16102
16103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16104 {
16105 if (!wxPyCheckForApp()) SWIG_fail;
16106 PyThreadState* __tstate = wxPyBeginAllowThreads();
16107 result = (wxPyArtProvider *)new wxPyArtProvider();
16108
16109 wxPyEndAllowThreads(__tstate);
16110 if (PyErr_Occurred()) SWIG_fail;
16111 }
16112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16113 return resultobj;
16114 fail:
16115 return NULL;
16116 }
16117
16118
16119 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16120 PyObject *resultobj;
16121 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16122 PyObject *arg2 = (PyObject *) 0 ;
16123 PyObject *arg3 = (PyObject *) 0 ;
16124 PyObject * obj0 = 0 ;
16125 PyObject * obj1 = 0 ;
16126 PyObject * obj2 = 0 ;
16127 char *kwnames[] = {
16128 (char *) "self",(char *) "self",(char *) "_class", NULL
16129 };
16130
16131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16133 if (SWIG_arg_fail(1)) SWIG_fail;
16134 arg2 = obj1;
16135 arg3 = obj2;
16136 {
16137 PyThreadState* __tstate = wxPyBeginAllowThreads();
16138 (arg1)->_setCallbackInfo(arg2,arg3);
16139
16140 wxPyEndAllowThreads(__tstate);
16141 if (PyErr_Occurred()) SWIG_fail;
16142 }
16143 Py_INCREF(Py_None); resultobj = Py_None;
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj;
16152 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16153 PyObject * obj0 = 0 ;
16154 char *kwnames[] = {
16155 (char *) "provider", NULL
16156 };
16157
16158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16160 if (SWIG_arg_fail(1)) SWIG_fail;
16161 {
16162 PyThreadState* __tstate = wxPyBeginAllowThreads();
16163 wxPyArtProvider::PushProvider(arg1);
16164
16165 wxPyEndAllowThreads(__tstate);
16166 if (PyErr_Occurred()) SWIG_fail;
16167 }
16168 Py_INCREF(Py_None); resultobj = Py_None;
16169 return resultobj;
16170 fail:
16171 return NULL;
16172 }
16173
16174
16175 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16176 PyObject *resultobj;
16177 bool result;
16178 char *kwnames[] = {
16179 NULL
16180 };
16181
16182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16183 {
16184 PyThreadState* __tstate = wxPyBeginAllowThreads();
16185 result = (bool)wxPyArtProvider::PopProvider();
16186
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 {
16191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16192 }
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj;
16201 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16202 bool result;
16203 PyObject * obj0 = 0 ;
16204 char *kwnames[] = {
16205 (char *) "provider", NULL
16206 };
16207
16208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16210 if (SWIG_arg_fail(1)) SWIG_fail;
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16214
16215 wxPyEndAllowThreads(__tstate);
16216 if (PyErr_Occurred()) SWIG_fail;
16217 }
16218 {
16219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16220 }
16221 return resultobj;
16222 fail:
16223 return NULL;
16224 }
16225
16226
16227 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16228 PyObject *resultobj;
16229 wxString *arg1 = 0 ;
16230 wxString const &arg2_defvalue = wxPyART_OTHER ;
16231 wxString *arg2 = (wxString *) &arg2_defvalue ;
16232 wxSize const &arg3_defvalue = wxDefaultSize ;
16233 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16234 wxBitmap result;
16235 bool temp1 = false ;
16236 bool temp2 = false ;
16237 wxSize temp3 ;
16238 PyObject * obj0 = 0 ;
16239 PyObject * obj1 = 0 ;
16240 PyObject * obj2 = 0 ;
16241 char *kwnames[] = {
16242 (char *) "id",(char *) "client",(char *) "size", NULL
16243 };
16244
16245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16246 {
16247 arg1 = wxString_in_helper(obj0);
16248 if (arg1 == NULL) SWIG_fail;
16249 temp1 = true;
16250 }
16251 if (obj1) {
16252 {
16253 arg2 = wxString_in_helper(obj1);
16254 if (arg2 == NULL) SWIG_fail;
16255 temp2 = true;
16256 }
16257 }
16258 if (obj2) {
16259 {
16260 arg3 = &temp3;
16261 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16262 }
16263 }
16264 {
16265 if (!wxPyCheckForApp()) SWIG_fail;
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16268
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 {
16273 wxBitmap * resultptr;
16274 resultptr = new wxBitmap((wxBitmap &)(result));
16275 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16276 }
16277 {
16278 if (temp1)
16279 delete arg1;
16280 }
16281 {
16282 if (temp2)
16283 delete arg2;
16284 }
16285 return resultobj;
16286 fail:
16287 {
16288 if (temp1)
16289 delete arg1;
16290 }
16291 {
16292 if (temp2)
16293 delete arg2;
16294 }
16295 return NULL;
16296 }
16297
16298
16299 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16300 PyObject *resultobj;
16301 wxString *arg1 = 0 ;
16302 wxString const &arg2_defvalue = wxPyART_OTHER ;
16303 wxString *arg2 = (wxString *) &arg2_defvalue ;
16304 wxSize const &arg3_defvalue = wxDefaultSize ;
16305 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16306 wxIcon result;
16307 bool temp1 = false ;
16308 bool temp2 = false ;
16309 wxSize temp3 ;
16310 PyObject * obj0 = 0 ;
16311 PyObject * obj1 = 0 ;
16312 PyObject * obj2 = 0 ;
16313 char *kwnames[] = {
16314 (char *) "id",(char *) "client",(char *) "size", NULL
16315 };
16316
16317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16318 {
16319 arg1 = wxString_in_helper(obj0);
16320 if (arg1 == NULL) SWIG_fail;
16321 temp1 = true;
16322 }
16323 if (obj1) {
16324 {
16325 arg2 = wxString_in_helper(obj1);
16326 if (arg2 == NULL) SWIG_fail;
16327 temp2 = true;
16328 }
16329 }
16330 if (obj2) {
16331 {
16332 arg3 = &temp3;
16333 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16334 }
16335 }
16336 {
16337 if (!wxPyCheckForApp()) SWIG_fail;
16338 PyThreadState* __tstate = wxPyBeginAllowThreads();
16339 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16340
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 {
16345 wxIcon * resultptr;
16346 resultptr = new wxIcon((wxIcon &)(result));
16347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16348 }
16349 {
16350 if (temp1)
16351 delete arg1;
16352 }
16353 {
16354 if (temp2)
16355 delete arg2;
16356 }
16357 return resultobj;
16358 fail:
16359 {
16360 if (temp1)
16361 delete arg1;
16362 }
16363 {
16364 if (temp2)
16365 delete arg2;
16366 }
16367 return NULL;
16368 }
16369
16370
16371 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16372 PyObject *resultobj;
16373 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16374 PyObject * obj0 = 0 ;
16375 char *kwnames[] = {
16376 (char *) "self", NULL
16377 };
16378
16379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16381 if (SWIG_arg_fail(1)) SWIG_fail;
16382 {
16383 PyThreadState* __tstate = wxPyBeginAllowThreads();
16384 wxPyArtProvider_Destroy(arg1);
16385
16386 wxPyEndAllowThreads(__tstate);
16387 if (PyErr_Occurred()) SWIG_fail;
16388 }
16389 Py_INCREF(Py_None); resultobj = Py_None;
16390 return resultobj;
16391 fail:
16392 return NULL;
16393 }
16394
16395
16396 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16397 PyObject *obj;
16398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16399 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16400 Py_INCREF(obj);
16401 return Py_BuildValue((char *)"");
16402 }
16403 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16404 PyObject *resultobj;
16405 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16406 PyObject * obj0 = 0 ;
16407 char *kwnames[] = {
16408 (char *) "self", NULL
16409 };
16410
16411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16413 if (SWIG_arg_fail(1)) SWIG_fail;
16414 {
16415 PyThreadState* __tstate = wxPyBeginAllowThreads();
16416 delete arg1;
16417
16418 wxPyEndAllowThreads(__tstate);
16419 if (PyErr_Occurred()) SWIG_fail;
16420 }
16421 Py_INCREF(Py_None); resultobj = Py_None;
16422 return resultobj;
16423 fail:
16424 return NULL;
16425 }
16426
16427
16428 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16429 PyObject *resultobj;
16430 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16431 wxConfigBase *result;
16432 PyObject * obj0 = 0 ;
16433 char *kwnames[] = {
16434 (char *) "config", NULL
16435 };
16436
16437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16439 if (SWIG_arg_fail(1)) SWIG_fail;
16440 {
16441 PyThreadState* __tstate = wxPyBeginAllowThreads();
16442 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16443
16444 wxPyEndAllowThreads(__tstate);
16445 if (PyErr_Occurred()) SWIG_fail;
16446 }
16447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16448 return resultobj;
16449 fail:
16450 return NULL;
16451 }
16452
16453
16454 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16455 PyObject *resultobj;
16456 bool arg1 = (bool) true ;
16457 wxConfigBase *result;
16458 PyObject * obj0 = 0 ;
16459 char *kwnames[] = {
16460 (char *) "createOnDemand", NULL
16461 };
16462
16463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16464 if (obj0) {
16465 {
16466 arg1 = (bool)(SWIG_As_bool(obj0));
16467 if (SWIG_arg_fail(1)) SWIG_fail;
16468 }
16469 }
16470 {
16471 PyThreadState* __tstate = wxPyBeginAllowThreads();
16472 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16473
16474 wxPyEndAllowThreads(__tstate);
16475 if (PyErr_Occurred()) SWIG_fail;
16476 }
16477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16478 return resultobj;
16479 fail:
16480 return NULL;
16481 }
16482
16483
16484 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16485 PyObject *resultobj;
16486 wxConfigBase *result;
16487 char *kwnames[] = {
16488 NULL
16489 };
16490
16491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16492 {
16493 PyThreadState* __tstate = wxPyBeginAllowThreads();
16494 result = (wxConfigBase *)wxConfigBase::Create();
16495
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16507 PyObject *resultobj;
16508 char *kwnames[] = {
16509 NULL
16510 };
16511
16512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16513 {
16514 PyThreadState* __tstate = wxPyBeginAllowThreads();
16515 wxConfigBase::DontCreateOnDemand();
16516
16517 wxPyEndAllowThreads(__tstate);
16518 if (PyErr_Occurred()) SWIG_fail;
16519 }
16520 Py_INCREF(Py_None); resultobj = Py_None;
16521 return resultobj;
16522 fail:
16523 return NULL;
16524 }
16525
16526
16527 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16528 PyObject *resultobj;
16529 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16530 wxString *arg2 = 0 ;
16531 bool temp2 = false ;
16532 PyObject * obj0 = 0 ;
16533 PyObject * obj1 = 0 ;
16534 char *kwnames[] = {
16535 (char *) "self",(char *) "path", NULL
16536 };
16537
16538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16540 if (SWIG_arg_fail(1)) SWIG_fail;
16541 {
16542 arg2 = wxString_in_helper(obj1);
16543 if (arg2 == NULL) SWIG_fail;
16544 temp2 = true;
16545 }
16546 {
16547 PyThreadState* __tstate = wxPyBeginAllowThreads();
16548 (arg1)->SetPath((wxString const &)*arg2);
16549
16550 wxPyEndAllowThreads(__tstate);
16551 if (PyErr_Occurred()) SWIG_fail;
16552 }
16553 Py_INCREF(Py_None); resultobj = Py_None;
16554 {
16555 if (temp2)
16556 delete arg2;
16557 }
16558 return resultobj;
16559 fail:
16560 {
16561 if (temp2)
16562 delete arg2;
16563 }
16564 return NULL;
16565 }
16566
16567
16568 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16569 PyObject *resultobj;
16570 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16571 wxString *result;
16572 PyObject * obj0 = 0 ;
16573 char *kwnames[] = {
16574 (char *) "self", NULL
16575 };
16576
16577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16579 if (SWIG_arg_fail(1)) SWIG_fail;
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 {
16583 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16584 result = (wxString *) &_result_ref;
16585 }
16586
16587 wxPyEndAllowThreads(__tstate);
16588 if (PyErr_Occurred()) SWIG_fail;
16589 }
16590 {
16591 #if wxUSE_UNICODE
16592 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16593 #else
16594 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16595 #endif
16596 }
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj;
16605 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16606 PyObject *result;
16607 PyObject * obj0 = 0 ;
16608 char *kwnames[] = {
16609 (char *) "self", NULL
16610 };
16611
16612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16614 if (SWIG_arg_fail(1)) SWIG_fail;
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 resultobj = result;
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16630 PyObject *resultobj;
16631 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16632 long arg2 ;
16633 PyObject *result;
16634 PyObject * obj0 = 0 ;
16635 PyObject * obj1 = 0 ;
16636 char *kwnames[] = {
16637 (char *) "self",(char *) "index", NULL
16638 };
16639
16640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16642 if (SWIG_arg_fail(1)) SWIG_fail;
16643 {
16644 arg2 = (long)(SWIG_As_long(obj1));
16645 if (SWIG_arg_fail(2)) SWIG_fail;
16646 }
16647 {
16648 PyThreadState* __tstate = wxPyBeginAllowThreads();
16649 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16650
16651 wxPyEndAllowThreads(__tstate);
16652 if (PyErr_Occurred()) SWIG_fail;
16653 }
16654 resultobj = result;
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj;
16663 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16664 PyObject *result;
16665 PyObject * obj0 = 0 ;
16666 char *kwnames[] = {
16667 (char *) "self", NULL
16668 };
16669
16670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16672 if (SWIG_arg_fail(1)) SWIG_fail;
16673 {
16674 PyThreadState* __tstate = wxPyBeginAllowThreads();
16675 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16676
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 resultobj = result;
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16688 PyObject *resultobj;
16689 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16690 long arg2 ;
16691 PyObject *result;
16692 PyObject * obj0 = 0 ;
16693 PyObject * obj1 = 0 ;
16694 char *kwnames[] = {
16695 (char *) "self",(char *) "index", NULL
16696 };
16697
16698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16700 if (SWIG_arg_fail(1)) SWIG_fail;
16701 {
16702 arg2 = (long)(SWIG_As_long(obj1));
16703 if (SWIG_arg_fail(2)) SWIG_fail;
16704 }
16705 {
16706 PyThreadState* __tstate = wxPyBeginAllowThreads();
16707 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16708
16709 wxPyEndAllowThreads(__tstate);
16710 if (PyErr_Occurred()) SWIG_fail;
16711 }
16712 resultobj = result;
16713 return resultobj;
16714 fail:
16715 return NULL;
16716 }
16717
16718
16719 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16720 PyObject *resultobj;
16721 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16722 bool arg2 = (bool) false ;
16723 size_t result;
16724 PyObject * obj0 = 0 ;
16725 PyObject * obj1 = 0 ;
16726 char *kwnames[] = {
16727 (char *) "self",(char *) "recursive", NULL
16728 };
16729
16730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16732 if (SWIG_arg_fail(1)) SWIG_fail;
16733 if (obj1) {
16734 {
16735 arg2 = (bool)(SWIG_As_bool(obj1));
16736 if (SWIG_arg_fail(2)) SWIG_fail;
16737 }
16738 }
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16742
16743 wxPyEndAllowThreads(__tstate);
16744 if (PyErr_Occurred()) SWIG_fail;
16745 }
16746 {
16747 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16748 }
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj;
16757 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16758 bool arg2 = (bool) false ;
16759 size_t result;
16760 PyObject * obj0 = 0 ;
16761 PyObject * obj1 = 0 ;
16762 char *kwnames[] = {
16763 (char *) "self",(char *) "recursive", NULL
16764 };
16765
16766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16768 if (SWIG_arg_fail(1)) SWIG_fail;
16769 if (obj1) {
16770 {
16771 arg2 = (bool)(SWIG_As_bool(obj1));
16772 if (SWIG_arg_fail(2)) SWIG_fail;
16773 }
16774 }
16775 {
16776 PyThreadState* __tstate = wxPyBeginAllowThreads();
16777 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
16778
16779 wxPyEndAllowThreads(__tstate);
16780 if (PyErr_Occurred()) SWIG_fail;
16781 }
16782 {
16783 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16784 }
16785 return resultobj;
16786 fail:
16787 return NULL;
16788 }
16789
16790
16791 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16792 PyObject *resultobj;
16793 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16794 wxString *arg2 = 0 ;
16795 bool result;
16796 bool temp2 = false ;
16797 PyObject * obj0 = 0 ;
16798 PyObject * obj1 = 0 ;
16799 char *kwnames[] = {
16800 (char *) "self",(char *) "name", NULL
16801 };
16802
16803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
16804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16805 if (SWIG_arg_fail(1)) SWIG_fail;
16806 {
16807 arg2 = wxString_in_helper(obj1);
16808 if (arg2 == NULL) SWIG_fail;
16809 temp2 = true;
16810 }
16811 {
16812 PyThreadState* __tstate = wxPyBeginAllowThreads();
16813 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
16814
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 {
16819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16820 }
16821 {
16822 if (temp2)
16823 delete arg2;
16824 }
16825 return resultobj;
16826 fail:
16827 {
16828 if (temp2)
16829 delete arg2;
16830 }
16831 return NULL;
16832 }
16833
16834
16835 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16836 PyObject *resultobj;
16837 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16838 wxString *arg2 = 0 ;
16839 bool result;
16840 bool temp2 = false ;
16841 PyObject * obj0 = 0 ;
16842 PyObject * obj1 = 0 ;
16843 char *kwnames[] = {
16844 (char *) "self",(char *) "name", NULL
16845 };
16846
16847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
16848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16849 if (SWIG_arg_fail(1)) SWIG_fail;
16850 {
16851 arg2 = wxString_in_helper(obj1);
16852 if (arg2 == NULL) SWIG_fail;
16853 temp2 = true;
16854 }
16855 {
16856 PyThreadState* __tstate = wxPyBeginAllowThreads();
16857 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
16858
16859 wxPyEndAllowThreads(__tstate);
16860 if (PyErr_Occurred()) SWIG_fail;
16861 }
16862 {
16863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16864 }
16865 {
16866 if (temp2)
16867 delete arg2;
16868 }
16869 return resultobj;
16870 fail:
16871 {
16872 if (temp2)
16873 delete arg2;
16874 }
16875 return NULL;
16876 }
16877
16878
16879 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
16880 PyObject *resultobj;
16881 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16882 wxString *arg2 = 0 ;
16883 bool result;
16884 bool temp2 = false ;
16885 PyObject * obj0 = 0 ;
16886 PyObject * obj1 = 0 ;
16887 char *kwnames[] = {
16888 (char *) "self",(char *) "name", NULL
16889 };
16890
16891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
16892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16893 if (SWIG_arg_fail(1)) SWIG_fail;
16894 {
16895 arg2 = wxString_in_helper(obj1);
16896 if (arg2 == NULL) SWIG_fail;
16897 temp2 = true;
16898 }
16899 {
16900 PyThreadState* __tstate = wxPyBeginAllowThreads();
16901 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
16902
16903 wxPyEndAllowThreads(__tstate);
16904 if (PyErr_Occurred()) SWIG_fail;
16905 }
16906 {
16907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16908 }
16909 {
16910 if (temp2)
16911 delete arg2;
16912 }
16913 return resultobj;
16914 fail:
16915 {
16916 if (temp2)
16917 delete arg2;
16918 }
16919 return NULL;
16920 }
16921
16922
16923 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
16924 PyObject *resultobj;
16925 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16926 wxString *arg2 = 0 ;
16927 wxConfigBase::EntryType result;
16928 bool temp2 = false ;
16929 PyObject * obj0 = 0 ;
16930 PyObject * obj1 = 0 ;
16931 char *kwnames[] = {
16932 (char *) "self",(char *) "name", NULL
16933 };
16934
16935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
16936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16937 if (SWIG_arg_fail(1)) SWIG_fail;
16938 {
16939 arg2 = wxString_in_helper(obj1);
16940 if (arg2 == NULL) SWIG_fail;
16941 temp2 = true;
16942 }
16943 {
16944 PyThreadState* __tstate = wxPyBeginAllowThreads();
16945 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
16946
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 resultobj = SWIG_From_int((result));
16951 {
16952 if (temp2)
16953 delete arg2;
16954 }
16955 return resultobj;
16956 fail:
16957 {
16958 if (temp2)
16959 delete arg2;
16960 }
16961 return NULL;
16962 }
16963
16964
16965 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj;
16967 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16968 wxString *arg2 = 0 ;
16969 wxString const &arg3_defvalue = wxPyEmptyString ;
16970 wxString *arg3 = (wxString *) &arg3_defvalue ;
16971 wxString result;
16972 bool temp2 = false ;
16973 bool temp3 = false ;
16974 PyObject * obj0 = 0 ;
16975 PyObject * obj1 = 0 ;
16976 PyObject * obj2 = 0 ;
16977 char *kwnames[] = {
16978 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
16979 };
16980
16981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
16982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16983 if (SWIG_arg_fail(1)) SWIG_fail;
16984 {
16985 arg2 = wxString_in_helper(obj1);
16986 if (arg2 == NULL) SWIG_fail;
16987 temp2 = true;
16988 }
16989 if (obj2) {
16990 {
16991 arg3 = wxString_in_helper(obj2);
16992 if (arg3 == NULL) SWIG_fail;
16993 temp3 = true;
16994 }
16995 }
16996 {
16997 PyThreadState* __tstate = wxPyBeginAllowThreads();
16998 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
16999
17000 wxPyEndAllowThreads(__tstate);
17001 if (PyErr_Occurred()) SWIG_fail;
17002 }
17003 {
17004 #if wxUSE_UNICODE
17005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17006 #else
17007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17008 #endif
17009 }
17010 {
17011 if (temp2)
17012 delete arg2;
17013 }
17014 {
17015 if (temp3)
17016 delete arg3;
17017 }
17018 return resultobj;
17019 fail:
17020 {
17021 if (temp2)
17022 delete arg2;
17023 }
17024 {
17025 if (temp3)
17026 delete arg3;
17027 }
17028 return NULL;
17029 }
17030
17031
17032 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17033 PyObject *resultobj;
17034 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17035 wxString *arg2 = 0 ;
17036 long arg3 = (long) 0 ;
17037 long result;
17038 bool temp2 = false ;
17039 PyObject * obj0 = 0 ;
17040 PyObject * obj1 = 0 ;
17041 PyObject * obj2 = 0 ;
17042 char *kwnames[] = {
17043 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17044 };
17045
17046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17048 if (SWIG_arg_fail(1)) SWIG_fail;
17049 {
17050 arg2 = wxString_in_helper(obj1);
17051 if (arg2 == NULL) SWIG_fail;
17052 temp2 = true;
17053 }
17054 if (obj2) {
17055 {
17056 arg3 = (long)(SWIG_As_long(obj2));
17057 if (SWIG_arg_fail(3)) SWIG_fail;
17058 }
17059 }
17060 {
17061 PyThreadState* __tstate = wxPyBeginAllowThreads();
17062 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17063
17064 wxPyEndAllowThreads(__tstate);
17065 if (PyErr_Occurred()) SWIG_fail;
17066 }
17067 {
17068 resultobj = SWIG_From_long((long)(result));
17069 }
17070 {
17071 if (temp2)
17072 delete arg2;
17073 }
17074 return resultobj;
17075 fail:
17076 {
17077 if (temp2)
17078 delete arg2;
17079 }
17080 return NULL;
17081 }
17082
17083
17084 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17085 PyObject *resultobj;
17086 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17087 wxString *arg2 = 0 ;
17088 double arg3 = (double) 0.0 ;
17089 double result;
17090 bool temp2 = false ;
17091 PyObject * obj0 = 0 ;
17092 PyObject * obj1 = 0 ;
17093 PyObject * obj2 = 0 ;
17094 char *kwnames[] = {
17095 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17096 };
17097
17098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17100 if (SWIG_arg_fail(1)) SWIG_fail;
17101 {
17102 arg2 = wxString_in_helper(obj1);
17103 if (arg2 == NULL) SWIG_fail;
17104 temp2 = true;
17105 }
17106 if (obj2) {
17107 {
17108 arg3 = (double)(SWIG_As_double(obj2));
17109 if (SWIG_arg_fail(3)) SWIG_fail;
17110 }
17111 }
17112 {
17113 PyThreadState* __tstate = wxPyBeginAllowThreads();
17114 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17115
17116 wxPyEndAllowThreads(__tstate);
17117 if (PyErr_Occurred()) SWIG_fail;
17118 }
17119 {
17120 resultobj = SWIG_From_double((double)(result));
17121 }
17122 {
17123 if (temp2)
17124 delete arg2;
17125 }
17126 return resultobj;
17127 fail:
17128 {
17129 if (temp2)
17130 delete arg2;
17131 }
17132 return NULL;
17133 }
17134
17135
17136 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17137 PyObject *resultobj;
17138 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17139 wxString *arg2 = 0 ;
17140 bool arg3 = (bool) false ;
17141 bool result;
17142 bool temp2 = false ;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 PyObject * obj2 = 0 ;
17146 char *kwnames[] = {
17147 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17148 };
17149
17150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17152 if (SWIG_arg_fail(1)) SWIG_fail;
17153 {
17154 arg2 = wxString_in_helper(obj1);
17155 if (arg2 == NULL) SWIG_fail;
17156 temp2 = true;
17157 }
17158 if (obj2) {
17159 {
17160 arg3 = (bool)(SWIG_As_bool(obj2));
17161 if (SWIG_arg_fail(3)) SWIG_fail;
17162 }
17163 }
17164 {
17165 PyThreadState* __tstate = wxPyBeginAllowThreads();
17166 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17167
17168 wxPyEndAllowThreads(__tstate);
17169 if (PyErr_Occurred()) SWIG_fail;
17170 }
17171 {
17172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17173 }
17174 {
17175 if (temp2)
17176 delete arg2;
17177 }
17178 return resultobj;
17179 fail:
17180 {
17181 if (temp2)
17182 delete arg2;
17183 }
17184 return NULL;
17185 }
17186
17187
17188 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17189 PyObject *resultobj;
17190 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17191 wxString *arg2 = 0 ;
17192 wxString *arg3 = 0 ;
17193 bool result;
17194 bool temp2 = false ;
17195 bool temp3 = false ;
17196 PyObject * obj0 = 0 ;
17197 PyObject * obj1 = 0 ;
17198 PyObject * obj2 = 0 ;
17199 char *kwnames[] = {
17200 (char *) "self",(char *) "key",(char *) "value", NULL
17201 };
17202
17203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17205 if (SWIG_arg_fail(1)) SWIG_fail;
17206 {
17207 arg2 = wxString_in_helper(obj1);
17208 if (arg2 == NULL) SWIG_fail;
17209 temp2 = true;
17210 }
17211 {
17212 arg3 = wxString_in_helper(obj2);
17213 if (arg3 == NULL) SWIG_fail;
17214 temp3 = true;
17215 }
17216 {
17217 PyThreadState* __tstate = wxPyBeginAllowThreads();
17218 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17219
17220 wxPyEndAllowThreads(__tstate);
17221 if (PyErr_Occurred()) SWIG_fail;
17222 }
17223 {
17224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17225 }
17226 {
17227 if (temp2)
17228 delete arg2;
17229 }
17230 {
17231 if (temp3)
17232 delete arg3;
17233 }
17234 return resultobj;
17235 fail:
17236 {
17237 if (temp2)
17238 delete arg2;
17239 }
17240 {
17241 if (temp3)
17242 delete arg3;
17243 }
17244 return NULL;
17245 }
17246
17247
17248 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17249 PyObject *resultobj;
17250 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17251 wxString *arg2 = 0 ;
17252 long arg3 ;
17253 bool result;
17254 bool temp2 = false ;
17255 PyObject * obj0 = 0 ;
17256 PyObject * obj1 = 0 ;
17257 PyObject * obj2 = 0 ;
17258 char *kwnames[] = {
17259 (char *) "self",(char *) "key",(char *) "value", NULL
17260 };
17261
17262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17264 if (SWIG_arg_fail(1)) SWIG_fail;
17265 {
17266 arg2 = wxString_in_helper(obj1);
17267 if (arg2 == NULL) SWIG_fail;
17268 temp2 = true;
17269 }
17270 {
17271 arg3 = (long)(SWIG_As_long(obj2));
17272 if (SWIG_arg_fail(3)) SWIG_fail;
17273 }
17274 {
17275 PyThreadState* __tstate = wxPyBeginAllowThreads();
17276 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17277
17278 wxPyEndAllowThreads(__tstate);
17279 if (PyErr_Occurred()) SWIG_fail;
17280 }
17281 {
17282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17283 }
17284 {
17285 if (temp2)
17286 delete arg2;
17287 }
17288 return resultobj;
17289 fail:
17290 {
17291 if (temp2)
17292 delete arg2;
17293 }
17294 return NULL;
17295 }
17296
17297
17298 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17299 PyObject *resultobj;
17300 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17301 wxString *arg2 = 0 ;
17302 double arg3 ;
17303 bool result;
17304 bool temp2 = false ;
17305 PyObject * obj0 = 0 ;
17306 PyObject * obj1 = 0 ;
17307 PyObject * obj2 = 0 ;
17308 char *kwnames[] = {
17309 (char *) "self",(char *) "key",(char *) "value", NULL
17310 };
17311
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 {
17316 arg2 = wxString_in_helper(obj1);
17317 if (arg2 == NULL) SWIG_fail;
17318 temp2 = true;
17319 }
17320 {
17321 arg3 = (double)(SWIG_As_double(obj2));
17322 if (SWIG_arg_fail(3)) SWIG_fail;
17323 }
17324 {
17325 PyThreadState* __tstate = wxPyBeginAllowThreads();
17326 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17327
17328 wxPyEndAllowThreads(__tstate);
17329 if (PyErr_Occurred()) SWIG_fail;
17330 }
17331 {
17332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17333 }
17334 {
17335 if (temp2)
17336 delete arg2;
17337 }
17338 return resultobj;
17339 fail:
17340 {
17341 if (temp2)
17342 delete arg2;
17343 }
17344 return NULL;
17345 }
17346
17347
17348 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17349 PyObject *resultobj;
17350 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17351 wxString *arg2 = 0 ;
17352 bool arg3 ;
17353 bool result;
17354 bool temp2 = false ;
17355 PyObject * obj0 = 0 ;
17356 PyObject * obj1 = 0 ;
17357 PyObject * obj2 = 0 ;
17358 char *kwnames[] = {
17359 (char *) "self",(char *) "key",(char *) "value", NULL
17360 };
17361
17362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17364 if (SWIG_arg_fail(1)) SWIG_fail;
17365 {
17366 arg2 = wxString_in_helper(obj1);
17367 if (arg2 == NULL) SWIG_fail;
17368 temp2 = true;
17369 }
17370 {
17371 arg3 = (bool)(SWIG_As_bool(obj2));
17372 if (SWIG_arg_fail(3)) SWIG_fail;
17373 }
17374 {
17375 PyThreadState* __tstate = wxPyBeginAllowThreads();
17376 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17377
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 {
17382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17383 }
17384 {
17385 if (temp2)
17386 delete arg2;
17387 }
17388 return resultobj;
17389 fail:
17390 {
17391 if (temp2)
17392 delete arg2;
17393 }
17394 return NULL;
17395 }
17396
17397
17398 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17399 PyObject *resultobj;
17400 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17401 bool arg2 = (bool) false ;
17402 bool result;
17403 PyObject * obj0 = 0 ;
17404 PyObject * obj1 = 0 ;
17405 char *kwnames[] = {
17406 (char *) "self",(char *) "currentOnly", NULL
17407 };
17408
17409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17411 if (SWIG_arg_fail(1)) SWIG_fail;
17412 if (obj1) {
17413 {
17414 arg2 = (bool)(SWIG_As_bool(obj1));
17415 if (SWIG_arg_fail(2)) SWIG_fail;
17416 }
17417 }
17418 {
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 result = (bool)(arg1)->Flush(arg2);
17421
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 {
17426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17427 }
17428 return resultobj;
17429 fail:
17430 return NULL;
17431 }
17432
17433
17434 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17435 PyObject *resultobj;
17436 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17437 wxString *arg2 = 0 ;
17438 wxString *arg3 = 0 ;
17439 bool result;
17440 bool temp2 = false ;
17441 bool temp3 = false ;
17442 PyObject * obj0 = 0 ;
17443 PyObject * obj1 = 0 ;
17444 PyObject * obj2 = 0 ;
17445 char *kwnames[] = {
17446 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17447 };
17448
17449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17451 if (SWIG_arg_fail(1)) SWIG_fail;
17452 {
17453 arg2 = wxString_in_helper(obj1);
17454 if (arg2 == NULL) SWIG_fail;
17455 temp2 = true;
17456 }
17457 {
17458 arg3 = wxString_in_helper(obj2);
17459 if (arg3 == NULL) SWIG_fail;
17460 temp3 = true;
17461 }
17462 {
17463 PyThreadState* __tstate = wxPyBeginAllowThreads();
17464 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17465
17466 wxPyEndAllowThreads(__tstate);
17467 if (PyErr_Occurred()) SWIG_fail;
17468 }
17469 {
17470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17471 }
17472 {
17473 if (temp2)
17474 delete arg2;
17475 }
17476 {
17477 if (temp3)
17478 delete arg3;
17479 }
17480 return resultobj;
17481 fail:
17482 {
17483 if (temp2)
17484 delete arg2;
17485 }
17486 {
17487 if (temp3)
17488 delete arg3;
17489 }
17490 return NULL;
17491 }
17492
17493
17494 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17495 PyObject *resultobj;
17496 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17497 wxString *arg2 = 0 ;
17498 wxString *arg3 = 0 ;
17499 bool result;
17500 bool temp2 = false ;
17501 bool temp3 = false ;
17502 PyObject * obj0 = 0 ;
17503 PyObject * obj1 = 0 ;
17504 PyObject * obj2 = 0 ;
17505 char *kwnames[] = {
17506 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17507 };
17508
17509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17511 if (SWIG_arg_fail(1)) SWIG_fail;
17512 {
17513 arg2 = wxString_in_helper(obj1);
17514 if (arg2 == NULL) SWIG_fail;
17515 temp2 = true;
17516 }
17517 {
17518 arg3 = wxString_in_helper(obj2);
17519 if (arg3 == NULL) SWIG_fail;
17520 temp3 = true;
17521 }
17522 {
17523 PyThreadState* __tstate = wxPyBeginAllowThreads();
17524 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17525
17526 wxPyEndAllowThreads(__tstate);
17527 if (PyErr_Occurred()) SWIG_fail;
17528 }
17529 {
17530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17531 }
17532 {
17533 if (temp2)
17534 delete arg2;
17535 }
17536 {
17537 if (temp3)
17538 delete arg3;
17539 }
17540 return resultobj;
17541 fail:
17542 {
17543 if (temp2)
17544 delete arg2;
17545 }
17546 {
17547 if (temp3)
17548 delete arg3;
17549 }
17550 return NULL;
17551 }
17552
17553
17554 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17555 PyObject *resultobj;
17556 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17557 wxString *arg2 = 0 ;
17558 bool arg3 = (bool) true ;
17559 bool result;
17560 bool temp2 = false ;
17561 PyObject * obj0 = 0 ;
17562 PyObject * obj1 = 0 ;
17563 PyObject * obj2 = 0 ;
17564 char *kwnames[] = {
17565 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17566 };
17567
17568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17570 if (SWIG_arg_fail(1)) SWIG_fail;
17571 {
17572 arg2 = wxString_in_helper(obj1);
17573 if (arg2 == NULL) SWIG_fail;
17574 temp2 = true;
17575 }
17576 if (obj2) {
17577 {
17578 arg3 = (bool)(SWIG_As_bool(obj2));
17579 if (SWIG_arg_fail(3)) SWIG_fail;
17580 }
17581 }
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17585
17586 wxPyEndAllowThreads(__tstate);
17587 if (PyErr_Occurred()) SWIG_fail;
17588 }
17589 {
17590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17591 }
17592 {
17593 if (temp2)
17594 delete arg2;
17595 }
17596 return resultobj;
17597 fail:
17598 {
17599 if (temp2)
17600 delete arg2;
17601 }
17602 return NULL;
17603 }
17604
17605
17606 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17607 PyObject *resultobj;
17608 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17609 wxString *arg2 = 0 ;
17610 bool result;
17611 bool temp2 = false ;
17612 PyObject * obj0 = 0 ;
17613 PyObject * obj1 = 0 ;
17614 char *kwnames[] = {
17615 (char *) "self",(char *) "key", NULL
17616 };
17617
17618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17620 if (SWIG_arg_fail(1)) SWIG_fail;
17621 {
17622 arg2 = wxString_in_helper(obj1);
17623 if (arg2 == NULL) SWIG_fail;
17624 temp2 = true;
17625 }
17626 {
17627 PyThreadState* __tstate = wxPyBeginAllowThreads();
17628 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17629
17630 wxPyEndAllowThreads(__tstate);
17631 if (PyErr_Occurred()) SWIG_fail;
17632 }
17633 {
17634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17635 }
17636 {
17637 if (temp2)
17638 delete arg2;
17639 }
17640 return resultobj;
17641 fail:
17642 {
17643 if (temp2)
17644 delete arg2;
17645 }
17646 return NULL;
17647 }
17648
17649
17650 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17651 PyObject *resultobj;
17652 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17653 bool result;
17654 PyObject * obj0 = 0 ;
17655 char *kwnames[] = {
17656 (char *) "self", NULL
17657 };
17658
17659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17661 if (SWIG_arg_fail(1)) SWIG_fail;
17662 {
17663 PyThreadState* __tstate = wxPyBeginAllowThreads();
17664 result = (bool)(arg1)->DeleteAll();
17665
17666 wxPyEndAllowThreads(__tstate);
17667 if (PyErr_Occurred()) SWIG_fail;
17668 }
17669 {
17670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17671 }
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17679 PyObject *resultobj;
17680 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17681 bool arg2 = (bool) true ;
17682 PyObject * obj0 = 0 ;
17683 PyObject * obj1 = 0 ;
17684 char *kwnames[] = {
17685 (char *) "self",(char *) "doIt", NULL
17686 };
17687
17688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17690 if (SWIG_arg_fail(1)) SWIG_fail;
17691 if (obj1) {
17692 {
17693 arg2 = (bool)(SWIG_As_bool(obj1));
17694 if (SWIG_arg_fail(2)) SWIG_fail;
17695 }
17696 }
17697 {
17698 PyThreadState* __tstate = wxPyBeginAllowThreads();
17699 (arg1)->SetExpandEnvVars(arg2);
17700
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 Py_INCREF(Py_None); resultobj = Py_None;
17705 return resultobj;
17706 fail:
17707 return NULL;
17708 }
17709
17710
17711 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17712 PyObject *resultobj;
17713 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17714 bool result;
17715 PyObject * obj0 = 0 ;
17716 char *kwnames[] = {
17717 (char *) "self", NULL
17718 };
17719
17720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17722 if (SWIG_arg_fail(1)) SWIG_fail;
17723 {
17724 PyThreadState* __tstate = wxPyBeginAllowThreads();
17725 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17726
17727 wxPyEndAllowThreads(__tstate);
17728 if (PyErr_Occurred()) SWIG_fail;
17729 }
17730 {
17731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17732 }
17733 return resultobj;
17734 fail:
17735 return NULL;
17736 }
17737
17738
17739 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17740 PyObject *resultobj;
17741 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17742 bool arg2 = (bool) true ;
17743 PyObject * obj0 = 0 ;
17744 PyObject * obj1 = 0 ;
17745 char *kwnames[] = {
17746 (char *) "self",(char *) "doIt", NULL
17747 };
17748
17749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17751 if (SWIG_arg_fail(1)) SWIG_fail;
17752 if (obj1) {
17753 {
17754 arg2 = (bool)(SWIG_As_bool(obj1));
17755 if (SWIG_arg_fail(2)) SWIG_fail;
17756 }
17757 }
17758 {
17759 PyThreadState* __tstate = wxPyBeginAllowThreads();
17760 (arg1)->SetRecordDefaults(arg2);
17761
17762 wxPyEndAllowThreads(__tstate);
17763 if (PyErr_Occurred()) SWIG_fail;
17764 }
17765 Py_INCREF(Py_None); resultobj = Py_None;
17766 return resultobj;
17767 fail:
17768 return NULL;
17769 }
17770
17771
17772 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17773 PyObject *resultobj;
17774 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17775 bool result;
17776 PyObject * obj0 = 0 ;
17777 char *kwnames[] = {
17778 (char *) "self", NULL
17779 };
17780
17781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
17782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17783 if (SWIG_arg_fail(1)) SWIG_fail;
17784 {
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
17787
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 {
17792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17793 }
17794 return resultobj;
17795 fail:
17796 return NULL;
17797 }
17798
17799
17800 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17801 PyObject *resultobj;
17802 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17803 wxString *arg2 = 0 ;
17804 wxString result;
17805 bool temp2 = false ;
17806 PyObject * obj0 = 0 ;
17807 PyObject * obj1 = 0 ;
17808 char *kwnames[] = {
17809 (char *) "self",(char *) "str", NULL
17810 };
17811
17812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17814 if (SWIG_arg_fail(1)) SWIG_fail;
17815 {
17816 arg2 = wxString_in_helper(obj1);
17817 if (arg2 == NULL) SWIG_fail;
17818 temp2 = true;
17819 }
17820 {
17821 PyThreadState* __tstate = wxPyBeginAllowThreads();
17822 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
17823
17824 wxPyEndAllowThreads(__tstate);
17825 if (PyErr_Occurred()) SWIG_fail;
17826 }
17827 {
17828 #if wxUSE_UNICODE
17829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17830 #else
17831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17832 #endif
17833 }
17834 {
17835 if (temp2)
17836 delete arg2;
17837 }
17838 return resultobj;
17839 fail:
17840 {
17841 if (temp2)
17842 delete arg2;
17843 }
17844 return NULL;
17845 }
17846
17847
17848 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17849 PyObject *resultobj;
17850 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17851 wxString result;
17852 PyObject * obj0 = 0 ;
17853 char *kwnames[] = {
17854 (char *) "self", NULL
17855 };
17856
17857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
17858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17859 if (SWIG_arg_fail(1)) SWIG_fail;
17860 {
17861 PyThreadState* __tstate = wxPyBeginAllowThreads();
17862 result = ((wxConfigBase const *)arg1)->GetAppName();
17863
17864 wxPyEndAllowThreads(__tstate);
17865 if (PyErr_Occurred()) SWIG_fail;
17866 }
17867 {
17868 #if wxUSE_UNICODE
17869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17870 #else
17871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17872 #endif
17873 }
17874 return resultobj;
17875 fail:
17876 return NULL;
17877 }
17878
17879
17880 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17881 PyObject *resultobj;
17882 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17883 wxString result;
17884 PyObject * obj0 = 0 ;
17885 char *kwnames[] = {
17886 (char *) "self", NULL
17887 };
17888
17889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
17890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17891 if (SWIG_arg_fail(1)) SWIG_fail;
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 result = ((wxConfigBase const *)arg1)->GetVendorName();
17895
17896 wxPyEndAllowThreads(__tstate);
17897 if (PyErr_Occurred()) SWIG_fail;
17898 }
17899 {
17900 #if wxUSE_UNICODE
17901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17902 #else
17903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17904 #endif
17905 }
17906 return resultobj;
17907 fail:
17908 return NULL;
17909 }
17910
17911
17912 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17913 PyObject *resultobj;
17914 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17915 wxString *arg2 = 0 ;
17916 bool temp2 = false ;
17917 PyObject * obj0 = 0 ;
17918 PyObject * obj1 = 0 ;
17919 char *kwnames[] = {
17920 (char *) "self",(char *) "appName", NULL
17921 };
17922
17923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
17924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17925 if (SWIG_arg_fail(1)) SWIG_fail;
17926 {
17927 arg2 = wxString_in_helper(obj1);
17928 if (arg2 == NULL) SWIG_fail;
17929 temp2 = true;
17930 }
17931 {
17932 PyThreadState* __tstate = wxPyBeginAllowThreads();
17933 (arg1)->SetAppName((wxString const &)*arg2);
17934
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 Py_INCREF(Py_None); resultobj = Py_None;
17939 {
17940 if (temp2)
17941 delete arg2;
17942 }
17943 return resultobj;
17944 fail:
17945 {
17946 if (temp2)
17947 delete arg2;
17948 }
17949 return NULL;
17950 }
17951
17952
17953 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17954 PyObject *resultobj;
17955 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17956 wxString *arg2 = 0 ;
17957 bool temp2 = false ;
17958 PyObject * obj0 = 0 ;
17959 PyObject * obj1 = 0 ;
17960 char *kwnames[] = {
17961 (char *) "self",(char *) "vendorName", NULL
17962 };
17963
17964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
17965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17966 if (SWIG_arg_fail(1)) SWIG_fail;
17967 {
17968 arg2 = wxString_in_helper(obj1);
17969 if (arg2 == NULL) SWIG_fail;
17970 temp2 = true;
17971 }
17972 {
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 (arg1)->SetVendorName((wxString const &)*arg2);
17975
17976 wxPyEndAllowThreads(__tstate);
17977 if (PyErr_Occurred()) SWIG_fail;
17978 }
17979 Py_INCREF(Py_None); resultobj = Py_None;
17980 {
17981 if (temp2)
17982 delete arg2;
17983 }
17984 return resultobj;
17985 fail:
17986 {
17987 if (temp2)
17988 delete arg2;
17989 }
17990 return NULL;
17991 }
17992
17993
17994 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
17995 PyObject *resultobj;
17996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17997 long arg2 ;
17998 PyObject * obj0 = 0 ;
17999 PyObject * obj1 = 0 ;
18000 char *kwnames[] = {
18001 (char *) "self",(char *) "style", NULL
18002 };
18003
18004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18006 if (SWIG_arg_fail(1)) SWIG_fail;
18007 {
18008 arg2 = (long)(SWIG_As_long(obj1));
18009 if (SWIG_arg_fail(2)) SWIG_fail;
18010 }
18011 {
18012 PyThreadState* __tstate = wxPyBeginAllowThreads();
18013 (arg1)->SetStyle(arg2);
18014
18015 wxPyEndAllowThreads(__tstate);
18016 if (PyErr_Occurred()) SWIG_fail;
18017 }
18018 Py_INCREF(Py_None); resultobj = Py_None;
18019 return resultobj;
18020 fail:
18021 return NULL;
18022 }
18023
18024
18025 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18026 PyObject *resultobj;
18027 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18028 long result;
18029 PyObject * obj0 = 0 ;
18030 char *kwnames[] = {
18031 (char *) "self", NULL
18032 };
18033
18034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18036 if (SWIG_arg_fail(1)) SWIG_fail;
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18040
18041 wxPyEndAllowThreads(__tstate);
18042 if (PyErr_Occurred()) SWIG_fail;
18043 }
18044 {
18045 resultobj = SWIG_From_long((long)(result));
18046 }
18047 return resultobj;
18048 fail:
18049 return NULL;
18050 }
18051
18052
18053 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18054 PyObject *obj;
18055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18056 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18057 Py_INCREF(obj);
18058 return Py_BuildValue((char *)"");
18059 }
18060 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18061 PyObject *resultobj;
18062 wxString const &arg1_defvalue = wxPyEmptyString ;
18063 wxString *arg1 = (wxString *) &arg1_defvalue ;
18064 wxString const &arg2_defvalue = wxPyEmptyString ;
18065 wxString *arg2 = (wxString *) &arg2_defvalue ;
18066 wxString const &arg3_defvalue = wxPyEmptyString ;
18067 wxString *arg3 = (wxString *) &arg3_defvalue ;
18068 wxString const &arg4_defvalue = wxPyEmptyString ;
18069 wxString *arg4 = (wxString *) &arg4_defvalue ;
18070 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18071 wxConfig *result;
18072 bool temp1 = false ;
18073 bool temp2 = false ;
18074 bool temp3 = false ;
18075 bool temp4 = false ;
18076 PyObject * obj0 = 0 ;
18077 PyObject * obj1 = 0 ;
18078 PyObject * obj2 = 0 ;
18079 PyObject * obj3 = 0 ;
18080 PyObject * obj4 = 0 ;
18081 char *kwnames[] = {
18082 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18083 };
18084
18085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18086 if (obj0) {
18087 {
18088 arg1 = wxString_in_helper(obj0);
18089 if (arg1 == NULL) SWIG_fail;
18090 temp1 = true;
18091 }
18092 }
18093 if (obj1) {
18094 {
18095 arg2 = wxString_in_helper(obj1);
18096 if (arg2 == NULL) SWIG_fail;
18097 temp2 = true;
18098 }
18099 }
18100 if (obj2) {
18101 {
18102 arg3 = wxString_in_helper(obj2);
18103 if (arg3 == NULL) SWIG_fail;
18104 temp3 = true;
18105 }
18106 }
18107 if (obj3) {
18108 {
18109 arg4 = wxString_in_helper(obj3);
18110 if (arg4 == NULL) SWIG_fail;
18111 temp4 = true;
18112 }
18113 }
18114 if (obj4) {
18115 {
18116 arg5 = (long)(SWIG_As_long(obj4));
18117 if (SWIG_arg_fail(5)) SWIG_fail;
18118 }
18119 }
18120 {
18121 PyThreadState* __tstate = wxPyBeginAllowThreads();
18122 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18123
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18128 {
18129 if (temp1)
18130 delete arg1;
18131 }
18132 {
18133 if (temp2)
18134 delete arg2;
18135 }
18136 {
18137 if (temp3)
18138 delete arg3;
18139 }
18140 {
18141 if (temp4)
18142 delete arg4;
18143 }
18144 return resultobj;
18145 fail:
18146 {
18147 if (temp1)
18148 delete arg1;
18149 }
18150 {
18151 if (temp2)
18152 delete arg2;
18153 }
18154 {
18155 if (temp3)
18156 delete arg3;
18157 }
18158 {
18159 if (temp4)
18160 delete arg4;
18161 }
18162 return NULL;
18163 }
18164
18165
18166 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18167 PyObject *resultobj;
18168 wxConfig *arg1 = (wxConfig *) 0 ;
18169 PyObject * obj0 = 0 ;
18170 char *kwnames[] = {
18171 (char *) "self", NULL
18172 };
18173
18174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18176 if (SWIG_arg_fail(1)) SWIG_fail;
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 delete arg1;
18180
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 Py_INCREF(Py_None); resultobj = Py_None;
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18192 PyObject *obj;
18193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18194 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18195 Py_INCREF(obj);
18196 return Py_BuildValue((char *)"");
18197 }
18198 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18199 PyObject *resultobj;
18200 wxString const &arg1_defvalue = wxPyEmptyString ;
18201 wxString *arg1 = (wxString *) &arg1_defvalue ;
18202 wxString const &arg2_defvalue = wxPyEmptyString ;
18203 wxString *arg2 = (wxString *) &arg2_defvalue ;
18204 wxString const &arg3_defvalue = wxPyEmptyString ;
18205 wxString *arg3 = (wxString *) &arg3_defvalue ;
18206 wxString const &arg4_defvalue = wxPyEmptyString ;
18207 wxString *arg4 = (wxString *) &arg4_defvalue ;
18208 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18209 wxFileConfig *result;
18210 bool temp1 = false ;
18211 bool temp2 = false ;
18212 bool temp3 = false ;
18213 bool temp4 = false ;
18214 PyObject * obj0 = 0 ;
18215 PyObject * obj1 = 0 ;
18216 PyObject * obj2 = 0 ;
18217 PyObject * obj3 = 0 ;
18218 PyObject * obj4 = 0 ;
18219 char *kwnames[] = {
18220 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18221 };
18222
18223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18224 if (obj0) {
18225 {
18226 arg1 = wxString_in_helper(obj0);
18227 if (arg1 == NULL) SWIG_fail;
18228 temp1 = true;
18229 }
18230 }
18231 if (obj1) {
18232 {
18233 arg2 = wxString_in_helper(obj1);
18234 if (arg2 == NULL) SWIG_fail;
18235 temp2 = true;
18236 }
18237 }
18238 if (obj2) {
18239 {
18240 arg3 = wxString_in_helper(obj2);
18241 if (arg3 == NULL) SWIG_fail;
18242 temp3 = true;
18243 }
18244 }
18245 if (obj3) {
18246 {
18247 arg4 = wxString_in_helper(obj3);
18248 if (arg4 == NULL) SWIG_fail;
18249 temp4 = true;
18250 }
18251 }
18252 if (obj4) {
18253 {
18254 arg5 = (long)(SWIG_As_long(obj4));
18255 if (SWIG_arg_fail(5)) SWIG_fail;
18256 }
18257 }
18258 {
18259 PyThreadState* __tstate = wxPyBeginAllowThreads();
18260 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18261
18262 wxPyEndAllowThreads(__tstate);
18263 if (PyErr_Occurred()) SWIG_fail;
18264 }
18265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18266 {
18267 if (temp1)
18268 delete arg1;
18269 }
18270 {
18271 if (temp2)
18272 delete arg2;
18273 }
18274 {
18275 if (temp3)
18276 delete arg3;
18277 }
18278 {
18279 if (temp4)
18280 delete arg4;
18281 }
18282 return resultobj;
18283 fail:
18284 {
18285 if (temp1)
18286 delete arg1;
18287 }
18288 {
18289 if (temp2)
18290 delete arg2;
18291 }
18292 {
18293 if (temp3)
18294 delete arg3;
18295 }
18296 {
18297 if (temp4)
18298 delete arg4;
18299 }
18300 return NULL;
18301 }
18302
18303
18304 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18305 PyObject *resultobj;
18306 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18307 PyObject * obj0 = 0 ;
18308 char *kwnames[] = {
18309 (char *) "self", NULL
18310 };
18311
18312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18314 if (SWIG_arg_fail(1)) SWIG_fail;
18315 {
18316 PyThreadState* __tstate = wxPyBeginAllowThreads();
18317 delete arg1;
18318
18319 wxPyEndAllowThreads(__tstate);
18320 if (PyErr_Occurred()) SWIG_fail;
18321 }
18322 Py_INCREF(Py_None); resultobj = Py_None;
18323 return resultobj;
18324 fail:
18325 return NULL;
18326 }
18327
18328
18329 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18330 PyObject *obj;
18331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18332 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18333 Py_INCREF(obj);
18334 return Py_BuildValue((char *)"");
18335 }
18336 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18337 PyObject *resultobj;
18338 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18339 wxString *arg2 = 0 ;
18340 wxConfigPathChanger *result;
18341 bool temp2 = false ;
18342 PyObject * obj0 = 0 ;
18343 PyObject * obj1 = 0 ;
18344 char *kwnames[] = {
18345 (char *) "config",(char *) "entry", NULL
18346 };
18347
18348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18350 if (SWIG_arg_fail(1)) SWIG_fail;
18351 {
18352 arg2 = wxString_in_helper(obj1);
18353 if (arg2 == NULL) SWIG_fail;
18354 temp2 = true;
18355 }
18356 {
18357 PyThreadState* __tstate = wxPyBeginAllowThreads();
18358 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18359
18360 wxPyEndAllowThreads(__tstate);
18361 if (PyErr_Occurred()) SWIG_fail;
18362 }
18363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18364 {
18365 if (temp2)
18366 delete arg2;
18367 }
18368 return resultobj;
18369 fail:
18370 {
18371 if (temp2)
18372 delete arg2;
18373 }
18374 return NULL;
18375 }
18376
18377
18378 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj;
18380 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18381 PyObject * obj0 = 0 ;
18382 char *kwnames[] = {
18383 (char *) "self", NULL
18384 };
18385
18386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18388 if (SWIG_arg_fail(1)) SWIG_fail;
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 delete arg1;
18392
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
18395 }
18396 Py_INCREF(Py_None); resultobj = Py_None;
18397 return resultobj;
18398 fail:
18399 return NULL;
18400 }
18401
18402
18403 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18404 PyObject *resultobj;
18405 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18406 wxString *result;
18407 PyObject * obj0 = 0 ;
18408 char *kwnames[] = {
18409 (char *) "self", NULL
18410 };
18411
18412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18414 if (SWIG_arg_fail(1)) SWIG_fail;
18415 {
18416 PyThreadState* __tstate = wxPyBeginAllowThreads();
18417 {
18418 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18419 result = (wxString *) &_result_ref;
18420 }
18421
18422 wxPyEndAllowThreads(__tstate);
18423 if (PyErr_Occurred()) SWIG_fail;
18424 }
18425 {
18426 #if wxUSE_UNICODE
18427 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18428 #else
18429 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18430 #endif
18431 }
18432 return resultobj;
18433 fail:
18434 return NULL;
18435 }
18436
18437
18438 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18439 PyObject *obj;
18440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18441 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18442 Py_INCREF(obj);
18443 return Py_BuildValue((char *)"");
18444 }
18445 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18446 PyObject *resultobj;
18447 wxString *arg1 = 0 ;
18448 wxString result;
18449 bool temp1 = false ;
18450 PyObject * obj0 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "sz", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18456 {
18457 arg1 = wxString_in_helper(obj0);
18458 if (arg1 == NULL) SWIG_fail;
18459 temp1 = true;
18460 }
18461 {
18462 PyThreadState* __tstate = wxPyBeginAllowThreads();
18463 result = wxExpandEnvVars((wxString const &)*arg1);
18464
18465 wxPyEndAllowThreads(__tstate);
18466 if (PyErr_Occurred()) SWIG_fail;
18467 }
18468 {
18469 #if wxUSE_UNICODE
18470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18471 #else
18472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18473 #endif
18474 }
18475 {
18476 if (temp1)
18477 delete arg1;
18478 }
18479 return resultobj;
18480 fail:
18481 {
18482 if (temp1)
18483 delete arg1;
18484 }
18485 return NULL;
18486 }
18487
18488
18489 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18490 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18491 return 1;
18492 }
18493
18494
18495 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18496 PyObject *pyobj;
18497
18498 {
18499 #if wxUSE_UNICODE
18500 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18501 #else
18502 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18503 #endif
18504 }
18505 return pyobj;
18506 }
18507
18508
18509 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18510 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18511 return 1;
18512 }
18513
18514
18515 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18516 PyObject *pyobj;
18517
18518 {
18519 #if wxUSE_UNICODE
18520 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18521 #else
18522 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18523 #endif
18524 }
18525 return pyobj;
18526 }
18527
18528
18529 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18530 PyObject *resultobj;
18531 wxDateTime::Country arg1 ;
18532 PyObject * obj0 = 0 ;
18533 char *kwnames[] = {
18534 (char *) "country", NULL
18535 };
18536
18537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18538 {
18539 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18540 if (SWIG_arg_fail(1)) SWIG_fail;
18541 }
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18545
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 Py_INCREF(Py_None); resultobj = Py_None;
18550 return resultobj;
18551 fail:
18552 return NULL;
18553 }
18554
18555
18556 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj;
18558 wxDateTime::Country result;
18559 char *kwnames[] = {
18560 NULL
18561 };
18562
18563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18564 {
18565 PyThreadState* __tstate = wxPyBeginAllowThreads();
18566 result = (wxDateTime::Country)wxDateTime::GetCountry();
18567
18568 wxPyEndAllowThreads(__tstate);
18569 if (PyErr_Occurred()) SWIG_fail;
18570 }
18571 resultobj = SWIG_From_int((result));
18572 return resultobj;
18573 fail:
18574 return NULL;
18575 }
18576
18577
18578 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18579 PyObject *resultobj;
18580 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18581 bool result;
18582 PyObject * obj0 = 0 ;
18583 char *kwnames[] = {
18584 (char *) "country", NULL
18585 };
18586
18587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18588 if (obj0) {
18589 {
18590 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18591 if (SWIG_arg_fail(1)) SWIG_fail;
18592 }
18593 }
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18597
18598 wxPyEndAllowThreads(__tstate);
18599 if (PyErr_Occurred()) SWIG_fail;
18600 }
18601 {
18602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18603 }
18604 return resultobj;
18605 fail:
18606 return NULL;
18607 }
18608
18609
18610 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18611 PyObject *resultobj;
18612 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18613 int result;
18614 PyObject * obj0 = 0 ;
18615 char *kwnames[] = {
18616 (char *) "cal", NULL
18617 };
18618
18619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18620 if (obj0) {
18621 {
18622 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18623 if (SWIG_arg_fail(1)) SWIG_fail;
18624 }
18625 }
18626 {
18627 PyThreadState* __tstate = wxPyBeginAllowThreads();
18628 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18629
18630 wxPyEndAllowThreads(__tstate);
18631 if (PyErr_Occurred()) SWIG_fail;
18632 }
18633 {
18634 resultobj = SWIG_From_int((int)(result));
18635 }
18636 return resultobj;
18637 fail:
18638 return NULL;
18639 }
18640
18641
18642 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18643 PyObject *resultobj;
18644 int arg1 ;
18645 int result;
18646 PyObject * obj0 = 0 ;
18647 char *kwnames[] = {
18648 (char *) "year", NULL
18649 };
18650
18651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18652 {
18653 arg1 = (int)(SWIG_As_int(obj0));
18654 if (SWIG_arg_fail(1)) SWIG_fail;
18655 }
18656 {
18657 PyThreadState* __tstate = wxPyBeginAllowThreads();
18658 result = (int)wxDateTime::ConvertYearToBC(arg1);
18659
18660 wxPyEndAllowThreads(__tstate);
18661 if (PyErr_Occurred()) SWIG_fail;
18662 }
18663 {
18664 resultobj = SWIG_From_int((int)(result));
18665 }
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj;
18674 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18675 wxDateTime::Month result;
18676 PyObject * obj0 = 0 ;
18677 char *kwnames[] = {
18678 (char *) "cal", NULL
18679 };
18680
18681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18682 if (obj0) {
18683 {
18684 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18685 if (SWIG_arg_fail(1)) SWIG_fail;
18686 }
18687 }
18688 {
18689 PyThreadState* __tstate = wxPyBeginAllowThreads();
18690 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18691
18692 wxPyEndAllowThreads(__tstate);
18693 if (PyErr_Occurred()) SWIG_fail;
18694 }
18695 resultobj = SWIG_From_int((result));
18696 return resultobj;
18697 fail:
18698 return NULL;
18699 }
18700
18701
18702 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18703 PyObject *resultobj;
18704 int arg1 = (int) wxDateTime::Inv_Year ;
18705 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18706 bool result;
18707 PyObject * obj0 = 0 ;
18708 PyObject * obj1 = 0 ;
18709 char *kwnames[] = {
18710 (char *) "year",(char *) "cal", NULL
18711 };
18712
18713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18714 if (obj0) {
18715 {
18716 arg1 = (int)(SWIG_As_int(obj0));
18717 if (SWIG_arg_fail(1)) SWIG_fail;
18718 }
18719 }
18720 if (obj1) {
18721 {
18722 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18723 if (SWIG_arg_fail(2)) SWIG_fail;
18724 }
18725 }
18726 {
18727 PyThreadState* __tstate = wxPyBeginAllowThreads();
18728 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18729
18730 wxPyEndAllowThreads(__tstate);
18731 if (PyErr_Occurred()) SWIG_fail;
18732 }
18733 {
18734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18735 }
18736 return resultobj;
18737 fail:
18738 return NULL;
18739 }
18740
18741
18742 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18743 PyObject *resultobj;
18744 int arg1 = (int) wxDateTime::Inv_Year ;
18745 int result;
18746 PyObject * obj0 = 0 ;
18747 char *kwnames[] = {
18748 (char *) "year", NULL
18749 };
18750
18751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18752 if (obj0) {
18753 {
18754 arg1 = (int)(SWIG_As_int(obj0));
18755 if (SWIG_arg_fail(1)) SWIG_fail;
18756 }
18757 }
18758 {
18759 PyThreadState* __tstate = wxPyBeginAllowThreads();
18760 result = (int)wxDateTime::GetCentury(arg1);
18761
18762 wxPyEndAllowThreads(__tstate);
18763 if (PyErr_Occurred()) SWIG_fail;
18764 }
18765 {
18766 resultobj = SWIG_From_int((int)(result));
18767 }
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj;
18776 int arg1 ;
18777 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18778 int result;
18779 PyObject * obj0 = 0 ;
18780 PyObject * obj1 = 0 ;
18781 char *kwnames[] = {
18782 (char *) "year",(char *) "cal", NULL
18783 };
18784
18785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
18786 {
18787 arg1 = (int)(SWIG_As_int(obj0));
18788 if (SWIG_arg_fail(1)) SWIG_fail;
18789 }
18790 if (obj1) {
18791 {
18792 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18793 if (SWIG_arg_fail(2)) SWIG_fail;
18794 }
18795 }
18796 {
18797 PyThreadState* __tstate = wxPyBeginAllowThreads();
18798 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
18799
18800 wxPyEndAllowThreads(__tstate);
18801 if (PyErr_Occurred()) SWIG_fail;
18802 }
18803 {
18804 resultobj = SWIG_From_int((int)(result));
18805 }
18806 return resultobj;
18807 fail:
18808 return NULL;
18809 }
18810
18811
18812 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18813 PyObject *resultobj;
18814 wxDateTime::Month arg1 ;
18815 int arg2 = (int) wxDateTime::Inv_Year ;
18816 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18817 int result;
18818 PyObject * obj0 = 0 ;
18819 PyObject * obj1 = 0 ;
18820 PyObject * obj2 = 0 ;
18821 char *kwnames[] = {
18822 (char *) "month",(char *) "year",(char *) "cal", NULL
18823 };
18824
18825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
18826 {
18827 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18828 if (SWIG_arg_fail(1)) SWIG_fail;
18829 }
18830 if (obj1) {
18831 {
18832 arg2 = (int)(SWIG_As_int(obj1));
18833 if (SWIG_arg_fail(2)) SWIG_fail;
18834 }
18835 }
18836 if (obj2) {
18837 {
18838 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
18839 if (SWIG_arg_fail(3)) SWIG_fail;
18840 }
18841 }
18842 {
18843 PyThreadState* __tstate = wxPyBeginAllowThreads();
18844 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
18845
18846 wxPyEndAllowThreads(__tstate);
18847 if (PyErr_Occurred()) SWIG_fail;
18848 }
18849 {
18850 resultobj = SWIG_From_int((int)(result));
18851 }
18852 return resultobj;
18853 fail:
18854 return NULL;
18855 }
18856
18857
18858 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
18859 PyObject *resultobj;
18860 wxDateTime::Month arg1 ;
18861 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18862 wxString result;
18863 PyObject * obj0 = 0 ;
18864 PyObject * obj1 = 0 ;
18865 char *kwnames[] = {
18866 (char *) "month",(char *) "flags", NULL
18867 };
18868
18869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
18870 {
18871 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18872 if (SWIG_arg_fail(1)) SWIG_fail;
18873 }
18874 if (obj1) {
18875 {
18876 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18877 if (SWIG_arg_fail(2)) SWIG_fail;
18878 }
18879 }
18880 {
18881 PyThreadState* __tstate = wxPyBeginAllowThreads();
18882 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
18883
18884 wxPyEndAllowThreads(__tstate);
18885 if (PyErr_Occurred()) SWIG_fail;
18886 }
18887 {
18888 #if wxUSE_UNICODE
18889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18890 #else
18891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18892 #endif
18893 }
18894 return resultobj;
18895 fail:
18896 return NULL;
18897 }
18898
18899
18900 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
18901 PyObject *resultobj;
18902 wxDateTime::WeekDay arg1 ;
18903 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18904 wxString result;
18905 PyObject * obj0 = 0 ;
18906 PyObject * obj1 = 0 ;
18907 char *kwnames[] = {
18908 (char *) "weekday",(char *) "flags", NULL
18909 };
18910
18911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
18912 {
18913 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
18914 if (SWIG_arg_fail(1)) SWIG_fail;
18915 }
18916 if (obj1) {
18917 {
18918 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18919 if (SWIG_arg_fail(2)) SWIG_fail;
18920 }
18921 }
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
18925
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 {
18930 #if wxUSE_UNICODE
18931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18932 #else
18933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18934 #endif
18935 }
18936 return resultobj;
18937 fail:
18938 return NULL;
18939 }
18940
18941
18942 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
18943 PyObject *resultobj;
18944 wxString *arg1 = (wxString *) 0 ;
18945 wxString *arg2 = (wxString *) 0 ;
18946 bool temp1 = false ;
18947 bool temp2 = false ;
18948 PyObject * obj0 = 0 ;
18949 PyObject * obj1 = 0 ;
18950 char *kwnames[] = {
18951 (char *) "OUTPUT",(char *) "OUTPUT", NULL
18952 };
18953
18954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
18955 {
18956 arg1 = wxString_in_helper(obj0);
18957 if (arg1 == NULL) SWIG_fail;
18958 temp1 = true;
18959 }
18960 {
18961 arg2 = wxString_in_helper(obj1);
18962 if (arg2 == NULL) SWIG_fail;
18963 temp2 = true;
18964 }
18965 {
18966 PyThreadState* __tstate = wxPyBeginAllowThreads();
18967 wxDateTime::GetAmPmStrings(arg1,arg2);
18968
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 Py_INCREF(Py_None); resultobj = Py_None;
18973 {
18974 if (temp1)
18975 delete arg1;
18976 }
18977 {
18978 if (temp2)
18979 delete arg2;
18980 }
18981 return resultobj;
18982 fail:
18983 {
18984 if (temp1)
18985 delete arg1;
18986 }
18987 {
18988 if (temp2)
18989 delete arg2;
18990 }
18991 return NULL;
18992 }
18993
18994
18995 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
18996 PyObject *resultobj;
18997 int arg1 = (int) wxDateTime::Inv_Year ;
18998 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
18999 bool result;
19000 PyObject * obj0 = 0 ;
19001 PyObject * obj1 = 0 ;
19002 char *kwnames[] = {
19003 (char *) "year",(char *) "country", NULL
19004 };
19005
19006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19007 if (obj0) {
19008 {
19009 arg1 = (int)(SWIG_As_int(obj0));
19010 if (SWIG_arg_fail(1)) SWIG_fail;
19011 }
19012 }
19013 if (obj1) {
19014 {
19015 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19016 if (SWIG_arg_fail(2)) SWIG_fail;
19017 }
19018 }
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19022
19023 wxPyEndAllowThreads(__tstate);
19024 if (PyErr_Occurred()) SWIG_fail;
19025 }
19026 {
19027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19028 }
19029 return resultobj;
19030 fail:
19031 return NULL;
19032 }
19033
19034
19035 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19036 PyObject *resultobj;
19037 int arg1 = (int) wxDateTime::Inv_Year ;
19038 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19039 wxDateTime result;
19040 PyObject * obj0 = 0 ;
19041 PyObject * obj1 = 0 ;
19042 char *kwnames[] = {
19043 (char *) "year",(char *) "country", NULL
19044 };
19045
19046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19047 if (obj0) {
19048 {
19049 arg1 = (int)(SWIG_As_int(obj0));
19050 if (SWIG_arg_fail(1)) SWIG_fail;
19051 }
19052 }
19053 if (obj1) {
19054 {
19055 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19056 if (SWIG_arg_fail(2)) SWIG_fail;
19057 }
19058 }
19059 {
19060 PyThreadState* __tstate = wxPyBeginAllowThreads();
19061 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19062
19063 wxPyEndAllowThreads(__tstate);
19064 if (PyErr_Occurred()) SWIG_fail;
19065 }
19066 {
19067 wxDateTime * resultptr;
19068 resultptr = new wxDateTime((wxDateTime &)(result));
19069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19070 }
19071 return resultobj;
19072 fail:
19073 return NULL;
19074 }
19075
19076
19077 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19078 PyObject *resultobj;
19079 int arg1 = (int) wxDateTime::Inv_Year ;
19080 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19081 wxDateTime result;
19082 PyObject * obj0 = 0 ;
19083 PyObject * obj1 = 0 ;
19084 char *kwnames[] = {
19085 (char *) "year",(char *) "country", NULL
19086 };
19087
19088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19089 if (obj0) {
19090 {
19091 arg1 = (int)(SWIG_As_int(obj0));
19092 if (SWIG_arg_fail(1)) SWIG_fail;
19093 }
19094 }
19095 if (obj1) {
19096 {
19097 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19098 if (SWIG_arg_fail(2)) SWIG_fail;
19099 }
19100 }
19101 {
19102 PyThreadState* __tstate = wxPyBeginAllowThreads();
19103 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19104
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 {
19109 wxDateTime * resultptr;
19110 resultptr = new wxDateTime((wxDateTime &)(result));
19111 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19112 }
19113 return resultobj;
19114 fail:
19115 return NULL;
19116 }
19117
19118
19119 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19120 PyObject *resultobj;
19121 wxDateTime result;
19122 char *kwnames[] = {
19123 NULL
19124 };
19125
19126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19127 {
19128 PyThreadState* __tstate = wxPyBeginAllowThreads();
19129 result = wxDateTime::Now();
19130
19131 wxPyEndAllowThreads(__tstate);
19132 if (PyErr_Occurred()) SWIG_fail;
19133 }
19134 {
19135 wxDateTime * resultptr;
19136 resultptr = new wxDateTime((wxDateTime &)(result));
19137 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19138 }
19139 return resultobj;
19140 fail:
19141 return NULL;
19142 }
19143
19144
19145 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19146 PyObject *resultobj;
19147 wxDateTime result;
19148 char *kwnames[] = {
19149 NULL
19150 };
19151
19152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 result = wxDateTime::UNow();
19156
19157 wxPyEndAllowThreads(__tstate);
19158 if (PyErr_Occurred()) SWIG_fail;
19159 }
19160 {
19161 wxDateTime * resultptr;
19162 resultptr = new wxDateTime((wxDateTime &)(result));
19163 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19164 }
19165 return resultobj;
19166 fail:
19167 return NULL;
19168 }
19169
19170
19171 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19172 PyObject *resultobj;
19173 wxDateTime result;
19174 char *kwnames[] = {
19175 NULL
19176 };
19177
19178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19179 {
19180 PyThreadState* __tstate = wxPyBeginAllowThreads();
19181 result = wxDateTime::Today();
19182
19183 wxPyEndAllowThreads(__tstate);
19184 if (PyErr_Occurred()) SWIG_fail;
19185 }
19186 {
19187 wxDateTime * resultptr;
19188 resultptr = new wxDateTime((wxDateTime &)(result));
19189 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19190 }
19191 return resultobj;
19192 fail:
19193 return NULL;
19194 }
19195
19196
19197 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19198 PyObject *resultobj;
19199 wxDateTime *result;
19200 char *kwnames[] = {
19201 NULL
19202 };
19203
19204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19205 {
19206 PyThreadState* __tstate = wxPyBeginAllowThreads();
19207 result = (wxDateTime *)new wxDateTime();
19208
19209 wxPyEndAllowThreads(__tstate);
19210 if (PyErr_Occurred()) SWIG_fail;
19211 }
19212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19220 PyObject *resultobj;
19221 time_t arg1 ;
19222 wxDateTime *result;
19223 PyObject * obj0 = 0 ;
19224 char *kwnames[] = {
19225 (char *) "timet", NULL
19226 };
19227
19228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19229 {
19230 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19231 if (SWIG_arg_fail(1)) SWIG_fail;
19232 }
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (wxDateTime *)new wxDateTime(arg1);
19236
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19241 return resultobj;
19242 fail:
19243 return NULL;
19244 }
19245
19246
19247 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19248 PyObject *resultobj;
19249 double arg1 ;
19250 wxDateTime *result;
19251 PyObject * obj0 = 0 ;
19252 char *kwnames[] = {
19253 (char *) "jdn", NULL
19254 };
19255
19256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19257 {
19258 arg1 = (double)(SWIG_As_double(obj0));
19259 if (SWIG_arg_fail(1)) SWIG_fail;
19260 }
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 result = (wxDateTime *)new wxDateTime(arg1);
19264
19265 wxPyEndAllowThreads(__tstate);
19266 if (PyErr_Occurred()) SWIG_fail;
19267 }
19268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19269 return resultobj;
19270 fail:
19271 return NULL;
19272 }
19273
19274
19275 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19276 PyObject *resultobj;
19277 int arg1 ;
19278 int arg2 = (int) 0 ;
19279 int arg3 = (int) 0 ;
19280 int arg4 = (int) 0 ;
19281 wxDateTime *result;
19282 PyObject * obj0 = 0 ;
19283 PyObject * obj1 = 0 ;
19284 PyObject * obj2 = 0 ;
19285 PyObject * obj3 = 0 ;
19286 char *kwnames[] = {
19287 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19288 };
19289
19290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19291 {
19292 arg1 = (int)(SWIG_As_int(obj0));
19293 if (SWIG_arg_fail(1)) SWIG_fail;
19294 }
19295 if (obj1) {
19296 {
19297 arg2 = (int)(SWIG_As_int(obj1));
19298 if (SWIG_arg_fail(2)) SWIG_fail;
19299 }
19300 }
19301 if (obj2) {
19302 {
19303 arg3 = (int)(SWIG_As_int(obj2));
19304 if (SWIG_arg_fail(3)) SWIG_fail;
19305 }
19306 }
19307 if (obj3) {
19308 {
19309 arg4 = (int)(SWIG_As_int(obj3));
19310 if (SWIG_arg_fail(4)) SWIG_fail;
19311 }
19312 }
19313 {
19314 PyThreadState* __tstate = wxPyBeginAllowThreads();
19315 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19316
19317 wxPyEndAllowThreads(__tstate);
19318 if (PyErr_Occurred()) SWIG_fail;
19319 }
19320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19321 return resultobj;
19322 fail:
19323 return NULL;
19324 }
19325
19326
19327 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19328 PyObject *resultobj;
19329 int arg1 ;
19330 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19331 int arg3 = (int) wxDateTime::Inv_Year ;
19332 int arg4 = (int) 0 ;
19333 int arg5 = (int) 0 ;
19334 int arg6 = (int) 0 ;
19335 int arg7 = (int) 0 ;
19336 wxDateTime *result;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 PyObject * obj2 = 0 ;
19340 PyObject * obj3 = 0 ;
19341 PyObject * obj4 = 0 ;
19342 PyObject * obj5 = 0 ;
19343 PyObject * obj6 = 0 ;
19344 char *kwnames[] = {
19345 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19346 };
19347
19348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19349 {
19350 arg1 = (int)(SWIG_As_int(obj0));
19351 if (SWIG_arg_fail(1)) SWIG_fail;
19352 }
19353 if (obj1) {
19354 {
19355 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19356 if (SWIG_arg_fail(2)) SWIG_fail;
19357 }
19358 }
19359 if (obj2) {
19360 {
19361 arg3 = (int)(SWIG_As_int(obj2));
19362 if (SWIG_arg_fail(3)) SWIG_fail;
19363 }
19364 }
19365 if (obj3) {
19366 {
19367 arg4 = (int)(SWIG_As_int(obj3));
19368 if (SWIG_arg_fail(4)) SWIG_fail;
19369 }
19370 }
19371 if (obj4) {
19372 {
19373 arg5 = (int)(SWIG_As_int(obj4));
19374 if (SWIG_arg_fail(5)) SWIG_fail;
19375 }
19376 }
19377 if (obj5) {
19378 {
19379 arg6 = (int)(SWIG_As_int(obj5));
19380 if (SWIG_arg_fail(6)) SWIG_fail;
19381 }
19382 }
19383 if (obj6) {
19384 {
19385 arg7 = (int)(SWIG_As_int(obj6));
19386 if (SWIG_arg_fail(7)) SWIG_fail;
19387 }
19388 }
19389 {
19390 PyThreadState* __tstate = wxPyBeginAllowThreads();
19391 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19392
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj;
19405 wxDateTime *arg1 = (wxDateTime *) 0 ;
19406 PyObject * obj0 = 0 ;
19407 char *kwnames[] = {
19408 (char *) "self", NULL
19409 };
19410
19411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19413 if (SWIG_arg_fail(1)) SWIG_fail;
19414 {
19415 PyThreadState* __tstate = wxPyBeginAllowThreads();
19416 delete arg1;
19417
19418 wxPyEndAllowThreads(__tstate);
19419 if (PyErr_Occurred()) SWIG_fail;
19420 }
19421 Py_INCREF(Py_None); resultobj = Py_None;
19422 return resultobj;
19423 fail:
19424 return NULL;
19425 }
19426
19427
19428 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19429 PyObject *resultobj;
19430 wxDateTime *arg1 = (wxDateTime *) 0 ;
19431 wxDateTime *result;
19432 PyObject * obj0 = 0 ;
19433 char *kwnames[] = {
19434 (char *) "self", NULL
19435 };
19436
19437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19439 if (SWIG_arg_fail(1)) SWIG_fail;
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 {
19443 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19444 result = (wxDateTime *) &_result_ref;
19445 }
19446
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj;
19459 wxDateTime *arg1 = (wxDateTime *) 0 ;
19460 time_t arg2 ;
19461 wxDateTime *result;
19462 PyObject * obj0 = 0 ;
19463 PyObject * obj1 = 0 ;
19464 char *kwnames[] = {
19465 (char *) "self",(char *) "timet", NULL
19466 };
19467
19468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19470 if (SWIG_arg_fail(1)) SWIG_fail;
19471 {
19472 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19473 if (SWIG_arg_fail(2)) SWIG_fail;
19474 }
19475 {
19476 PyThreadState* __tstate = wxPyBeginAllowThreads();
19477 {
19478 wxDateTime &_result_ref = (arg1)->Set(arg2);
19479 result = (wxDateTime *) &_result_ref;
19480 }
19481
19482 wxPyEndAllowThreads(__tstate);
19483 if (PyErr_Occurred()) SWIG_fail;
19484 }
19485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19493 PyObject *resultobj;
19494 wxDateTime *arg1 = (wxDateTime *) 0 ;
19495 double arg2 ;
19496 wxDateTime *result;
19497 PyObject * obj0 = 0 ;
19498 PyObject * obj1 = 0 ;
19499 char *kwnames[] = {
19500 (char *) "self",(char *) "jdn", NULL
19501 };
19502
19503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19505 if (SWIG_arg_fail(1)) SWIG_fail;
19506 {
19507 arg2 = (double)(SWIG_As_double(obj1));
19508 if (SWIG_arg_fail(2)) SWIG_fail;
19509 }
19510 {
19511 PyThreadState* __tstate = wxPyBeginAllowThreads();
19512 {
19513 wxDateTime &_result_ref = (arg1)->Set(arg2);
19514 result = (wxDateTime *) &_result_ref;
19515 }
19516
19517 wxPyEndAllowThreads(__tstate);
19518 if (PyErr_Occurred()) SWIG_fail;
19519 }
19520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19521 return resultobj;
19522 fail:
19523 return NULL;
19524 }
19525
19526
19527 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj;
19529 wxDateTime *arg1 = (wxDateTime *) 0 ;
19530 int arg2 ;
19531 int arg3 = (int) 0 ;
19532 int arg4 = (int) 0 ;
19533 int arg5 = (int) 0 ;
19534 wxDateTime *result;
19535 PyObject * obj0 = 0 ;
19536 PyObject * obj1 = 0 ;
19537 PyObject * obj2 = 0 ;
19538 PyObject * obj3 = 0 ;
19539 PyObject * obj4 = 0 ;
19540 char *kwnames[] = {
19541 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19542 };
19543
19544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19546 if (SWIG_arg_fail(1)) SWIG_fail;
19547 {
19548 arg2 = (int)(SWIG_As_int(obj1));
19549 if (SWIG_arg_fail(2)) SWIG_fail;
19550 }
19551 if (obj2) {
19552 {
19553 arg3 = (int)(SWIG_As_int(obj2));
19554 if (SWIG_arg_fail(3)) SWIG_fail;
19555 }
19556 }
19557 if (obj3) {
19558 {
19559 arg4 = (int)(SWIG_As_int(obj3));
19560 if (SWIG_arg_fail(4)) SWIG_fail;
19561 }
19562 }
19563 if (obj4) {
19564 {
19565 arg5 = (int)(SWIG_As_int(obj4));
19566 if (SWIG_arg_fail(5)) SWIG_fail;
19567 }
19568 }
19569 {
19570 PyThreadState* __tstate = wxPyBeginAllowThreads();
19571 {
19572 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19573 result = (wxDateTime *) &_result_ref;
19574 }
19575
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj;
19588 wxDateTime *arg1 = (wxDateTime *) 0 ;
19589 int arg2 ;
19590 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19591 int arg4 = (int) wxDateTime::Inv_Year ;
19592 int arg5 = (int) 0 ;
19593 int arg6 = (int) 0 ;
19594 int arg7 = (int) 0 ;
19595 int arg8 = (int) 0 ;
19596 wxDateTime *result;
19597 PyObject * obj0 = 0 ;
19598 PyObject * obj1 = 0 ;
19599 PyObject * obj2 = 0 ;
19600 PyObject * obj3 = 0 ;
19601 PyObject * obj4 = 0 ;
19602 PyObject * obj5 = 0 ;
19603 PyObject * obj6 = 0 ;
19604 PyObject * obj7 = 0 ;
19605 char *kwnames[] = {
19606 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19607 };
19608
19609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19611 if (SWIG_arg_fail(1)) SWIG_fail;
19612 {
19613 arg2 = (int)(SWIG_As_int(obj1));
19614 if (SWIG_arg_fail(2)) SWIG_fail;
19615 }
19616 if (obj2) {
19617 {
19618 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19619 if (SWIG_arg_fail(3)) SWIG_fail;
19620 }
19621 }
19622 if (obj3) {
19623 {
19624 arg4 = (int)(SWIG_As_int(obj3));
19625 if (SWIG_arg_fail(4)) SWIG_fail;
19626 }
19627 }
19628 if (obj4) {
19629 {
19630 arg5 = (int)(SWIG_As_int(obj4));
19631 if (SWIG_arg_fail(5)) SWIG_fail;
19632 }
19633 }
19634 if (obj5) {
19635 {
19636 arg6 = (int)(SWIG_As_int(obj5));
19637 if (SWIG_arg_fail(6)) SWIG_fail;
19638 }
19639 }
19640 if (obj6) {
19641 {
19642 arg7 = (int)(SWIG_As_int(obj6));
19643 if (SWIG_arg_fail(7)) SWIG_fail;
19644 }
19645 }
19646 if (obj7) {
19647 {
19648 arg8 = (int)(SWIG_As_int(obj7));
19649 if (SWIG_arg_fail(8)) SWIG_fail;
19650 }
19651 }
19652 {
19653 PyThreadState* __tstate = wxPyBeginAllowThreads();
19654 {
19655 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19656 result = (wxDateTime *) &_result_ref;
19657 }
19658
19659 wxPyEndAllowThreads(__tstate);
19660 if (PyErr_Occurred()) SWIG_fail;
19661 }
19662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19663 return resultobj;
19664 fail:
19665 return NULL;
19666 }
19667
19668
19669 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19670 PyObject *resultobj;
19671 wxDateTime *arg1 = (wxDateTime *) 0 ;
19672 wxDateTime *result;
19673 PyObject * obj0 = 0 ;
19674 char *kwnames[] = {
19675 (char *) "self", NULL
19676 };
19677
19678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19680 if (SWIG_arg_fail(1)) SWIG_fail;
19681 {
19682 PyThreadState* __tstate = wxPyBeginAllowThreads();
19683 {
19684 wxDateTime &_result_ref = (arg1)->ResetTime();
19685 result = (wxDateTime *) &_result_ref;
19686 }
19687
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19699 PyObject *resultobj;
19700 wxDateTime *arg1 = (wxDateTime *) 0 ;
19701 int arg2 ;
19702 wxDateTime *result;
19703 PyObject * obj0 = 0 ;
19704 PyObject * obj1 = 0 ;
19705 char *kwnames[] = {
19706 (char *) "self",(char *) "year", NULL
19707 };
19708
19709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19711 if (SWIG_arg_fail(1)) SWIG_fail;
19712 {
19713 arg2 = (int)(SWIG_As_int(obj1));
19714 if (SWIG_arg_fail(2)) SWIG_fail;
19715 }
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 {
19719 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19720 result = (wxDateTime *) &_result_ref;
19721 }
19722
19723 wxPyEndAllowThreads(__tstate);
19724 if (PyErr_Occurred()) SWIG_fail;
19725 }
19726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19727 return resultobj;
19728 fail:
19729 return NULL;
19730 }
19731
19732
19733 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19734 PyObject *resultobj;
19735 wxDateTime *arg1 = (wxDateTime *) 0 ;
19736 wxDateTime::Month arg2 ;
19737 wxDateTime *result;
19738 PyObject * obj0 = 0 ;
19739 PyObject * obj1 = 0 ;
19740 char *kwnames[] = {
19741 (char *) "self",(char *) "month", NULL
19742 };
19743
19744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19746 if (SWIG_arg_fail(1)) SWIG_fail;
19747 {
19748 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19749 if (SWIG_arg_fail(2)) SWIG_fail;
19750 }
19751 {
19752 PyThreadState* __tstate = wxPyBeginAllowThreads();
19753 {
19754 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19755 result = (wxDateTime *) &_result_ref;
19756 }
19757
19758 wxPyEndAllowThreads(__tstate);
19759 if (PyErr_Occurred()) SWIG_fail;
19760 }
19761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19762 return resultobj;
19763 fail:
19764 return NULL;
19765 }
19766
19767
19768 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19769 PyObject *resultobj;
19770 wxDateTime *arg1 = (wxDateTime *) 0 ;
19771 int arg2 ;
19772 wxDateTime *result;
19773 PyObject * obj0 = 0 ;
19774 PyObject * obj1 = 0 ;
19775 char *kwnames[] = {
19776 (char *) "self",(char *) "day", NULL
19777 };
19778
19779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
19780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19781 if (SWIG_arg_fail(1)) SWIG_fail;
19782 {
19783 arg2 = (int)(SWIG_As_int(obj1));
19784 if (SWIG_arg_fail(2)) SWIG_fail;
19785 }
19786 {
19787 PyThreadState* __tstate = wxPyBeginAllowThreads();
19788 {
19789 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
19790 result = (wxDateTime *) &_result_ref;
19791 }
19792
19793 wxPyEndAllowThreads(__tstate);
19794 if (PyErr_Occurred()) SWIG_fail;
19795 }
19796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19797 return resultobj;
19798 fail:
19799 return NULL;
19800 }
19801
19802
19803 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
19804 PyObject *resultobj;
19805 wxDateTime *arg1 = (wxDateTime *) 0 ;
19806 int arg2 ;
19807 wxDateTime *result;
19808 PyObject * obj0 = 0 ;
19809 PyObject * obj1 = 0 ;
19810 char *kwnames[] = {
19811 (char *) "self",(char *) "hour", NULL
19812 };
19813
19814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
19815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19816 if (SWIG_arg_fail(1)) SWIG_fail;
19817 {
19818 arg2 = (int)(SWIG_As_int(obj1));
19819 if (SWIG_arg_fail(2)) SWIG_fail;
19820 }
19821 {
19822 PyThreadState* __tstate = wxPyBeginAllowThreads();
19823 {
19824 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
19825 result = (wxDateTime *) &_result_ref;
19826 }
19827
19828 wxPyEndAllowThreads(__tstate);
19829 if (PyErr_Occurred()) SWIG_fail;
19830 }
19831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19832 return resultobj;
19833 fail:
19834 return NULL;
19835 }
19836
19837
19838 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
19839 PyObject *resultobj;
19840 wxDateTime *arg1 = (wxDateTime *) 0 ;
19841 int arg2 ;
19842 wxDateTime *result;
19843 PyObject * obj0 = 0 ;
19844 PyObject * obj1 = 0 ;
19845 char *kwnames[] = {
19846 (char *) "self",(char *) "minute", NULL
19847 };
19848
19849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
19850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19851 if (SWIG_arg_fail(1)) SWIG_fail;
19852 {
19853 arg2 = (int)(SWIG_As_int(obj1));
19854 if (SWIG_arg_fail(2)) SWIG_fail;
19855 }
19856 {
19857 PyThreadState* __tstate = wxPyBeginAllowThreads();
19858 {
19859 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
19860 result = (wxDateTime *) &_result_ref;
19861 }
19862
19863 wxPyEndAllowThreads(__tstate);
19864 if (PyErr_Occurred()) SWIG_fail;
19865 }
19866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19867 return resultobj;
19868 fail:
19869 return NULL;
19870 }
19871
19872
19873 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
19874 PyObject *resultobj;
19875 wxDateTime *arg1 = (wxDateTime *) 0 ;
19876 int arg2 ;
19877 wxDateTime *result;
19878 PyObject * obj0 = 0 ;
19879 PyObject * obj1 = 0 ;
19880 char *kwnames[] = {
19881 (char *) "self",(char *) "second", NULL
19882 };
19883
19884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
19885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19886 if (SWIG_arg_fail(1)) SWIG_fail;
19887 {
19888 arg2 = (int)(SWIG_As_int(obj1));
19889 if (SWIG_arg_fail(2)) SWIG_fail;
19890 }
19891 {
19892 PyThreadState* __tstate = wxPyBeginAllowThreads();
19893 {
19894 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
19895 result = (wxDateTime *) &_result_ref;
19896 }
19897
19898 wxPyEndAllowThreads(__tstate);
19899 if (PyErr_Occurred()) SWIG_fail;
19900 }
19901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19902 return resultobj;
19903 fail:
19904 return NULL;
19905 }
19906
19907
19908 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
19909 PyObject *resultobj;
19910 wxDateTime *arg1 = (wxDateTime *) 0 ;
19911 int arg2 ;
19912 wxDateTime *result;
19913 PyObject * obj0 = 0 ;
19914 PyObject * obj1 = 0 ;
19915 char *kwnames[] = {
19916 (char *) "self",(char *) "millisecond", NULL
19917 };
19918
19919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
19920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19921 if (SWIG_arg_fail(1)) SWIG_fail;
19922 {
19923 arg2 = (int)(SWIG_As_int(obj1));
19924 if (SWIG_arg_fail(2)) SWIG_fail;
19925 }
19926 {
19927 PyThreadState* __tstate = wxPyBeginAllowThreads();
19928 {
19929 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
19930 result = (wxDateTime *) &_result_ref;
19931 }
19932
19933 wxPyEndAllowThreads(__tstate);
19934 if (PyErr_Occurred()) SWIG_fail;
19935 }
19936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19937 return resultobj;
19938 fail:
19939 return NULL;
19940 }
19941
19942
19943 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19944 PyObject *resultobj;
19945 wxDateTime *arg1 = (wxDateTime *) 0 ;
19946 wxDateTime::WeekDay arg2 ;
19947 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19948 wxDateTime *result;
19949 PyObject * obj0 = 0 ;
19950 PyObject * obj1 = 0 ;
19951 PyObject * obj2 = 0 ;
19952 char *kwnames[] = {
19953 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19954 };
19955
19956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19958 if (SWIG_arg_fail(1)) SWIG_fail;
19959 {
19960 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19961 if (SWIG_arg_fail(2)) SWIG_fail;
19962 }
19963 if (obj2) {
19964 {
19965 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
19966 if (SWIG_arg_fail(3)) SWIG_fail;
19967 }
19968 }
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 {
19972 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
19973 result = (wxDateTime *) &_result_ref;
19974 }
19975
19976 wxPyEndAllowThreads(__tstate);
19977 if (PyErr_Occurred()) SWIG_fail;
19978 }
19979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19980 return resultobj;
19981 fail:
19982 return NULL;
19983 }
19984
19985
19986 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19987 PyObject *resultobj;
19988 wxDateTime *arg1 = (wxDateTime *) 0 ;
19989 wxDateTime::WeekDay arg2 ;
19990 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19991 wxDateTime result;
19992 PyObject * obj0 = 0 ;
19993 PyObject * obj1 = 0 ;
19994 PyObject * obj2 = 0 ;
19995 char *kwnames[] = {
19996 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19997 };
19998
19999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20001 if (SWIG_arg_fail(1)) SWIG_fail;
20002 {
20003 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20004 if (SWIG_arg_fail(2)) SWIG_fail;
20005 }
20006 if (obj2) {
20007 {
20008 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20009 if (SWIG_arg_fail(3)) SWIG_fail;
20010 }
20011 }
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20015
20016 wxPyEndAllowThreads(__tstate);
20017 if (PyErr_Occurred()) SWIG_fail;
20018 }
20019 {
20020 wxDateTime * resultptr;
20021 resultptr = new wxDateTime((wxDateTime &)(result));
20022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20023 }
20024 return resultobj;
20025 fail:
20026 return NULL;
20027 }
20028
20029
20030 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20031 PyObject *resultobj;
20032 wxDateTime *arg1 = (wxDateTime *) 0 ;
20033 wxDateTime::WeekDay arg2 ;
20034 wxDateTime *result;
20035 PyObject * obj0 = 0 ;
20036 PyObject * obj1 = 0 ;
20037 char *kwnames[] = {
20038 (char *) "self",(char *) "weekday", NULL
20039 };
20040
20041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20043 if (SWIG_arg_fail(1)) SWIG_fail;
20044 {
20045 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20046 if (SWIG_arg_fail(2)) SWIG_fail;
20047 }
20048 {
20049 PyThreadState* __tstate = wxPyBeginAllowThreads();
20050 {
20051 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20052 result = (wxDateTime *) &_result_ref;
20053 }
20054
20055 wxPyEndAllowThreads(__tstate);
20056 if (PyErr_Occurred()) SWIG_fail;
20057 }
20058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20059 return resultobj;
20060 fail:
20061 return NULL;
20062 }
20063
20064
20065 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20066 PyObject *resultobj;
20067 wxDateTime *arg1 = (wxDateTime *) 0 ;
20068 wxDateTime::WeekDay arg2 ;
20069 wxDateTime result;
20070 PyObject * obj0 = 0 ;
20071 PyObject * obj1 = 0 ;
20072 char *kwnames[] = {
20073 (char *) "self",(char *) "weekday", NULL
20074 };
20075
20076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20078 if (SWIG_arg_fail(1)) SWIG_fail;
20079 {
20080 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20081 if (SWIG_arg_fail(2)) SWIG_fail;
20082 }
20083 {
20084 PyThreadState* __tstate = wxPyBeginAllowThreads();
20085 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20086
20087 wxPyEndAllowThreads(__tstate);
20088 if (PyErr_Occurred()) SWIG_fail;
20089 }
20090 {
20091 wxDateTime * resultptr;
20092 resultptr = new wxDateTime((wxDateTime &)(result));
20093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20094 }
20095 return resultobj;
20096 fail:
20097 return NULL;
20098 }
20099
20100
20101 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20102 PyObject *resultobj;
20103 wxDateTime *arg1 = (wxDateTime *) 0 ;
20104 wxDateTime::WeekDay arg2 ;
20105 wxDateTime *result;
20106 PyObject * obj0 = 0 ;
20107 PyObject * obj1 = 0 ;
20108 char *kwnames[] = {
20109 (char *) "self",(char *) "weekday", NULL
20110 };
20111
20112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20114 if (SWIG_arg_fail(1)) SWIG_fail;
20115 {
20116 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20117 if (SWIG_arg_fail(2)) SWIG_fail;
20118 }
20119 {
20120 PyThreadState* __tstate = wxPyBeginAllowThreads();
20121 {
20122 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20123 result = (wxDateTime *) &_result_ref;
20124 }
20125
20126 wxPyEndAllowThreads(__tstate);
20127 if (PyErr_Occurred()) SWIG_fail;
20128 }
20129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20130 return resultobj;
20131 fail:
20132 return NULL;
20133 }
20134
20135
20136 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20137 PyObject *resultobj;
20138 wxDateTime *arg1 = (wxDateTime *) 0 ;
20139 wxDateTime::WeekDay arg2 ;
20140 wxDateTime result;
20141 PyObject * obj0 = 0 ;
20142 PyObject * obj1 = 0 ;
20143 char *kwnames[] = {
20144 (char *) "self",(char *) "weekday", NULL
20145 };
20146
20147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20149 if (SWIG_arg_fail(1)) SWIG_fail;
20150 {
20151 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20152 if (SWIG_arg_fail(2)) SWIG_fail;
20153 }
20154 {
20155 PyThreadState* __tstate = wxPyBeginAllowThreads();
20156 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20157
20158 wxPyEndAllowThreads(__tstate);
20159 if (PyErr_Occurred()) SWIG_fail;
20160 }
20161 {
20162 wxDateTime * resultptr;
20163 resultptr = new wxDateTime((wxDateTime &)(result));
20164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20165 }
20166 return resultobj;
20167 fail:
20168 return NULL;
20169 }
20170
20171
20172 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20173 PyObject *resultobj;
20174 wxDateTime *arg1 = (wxDateTime *) 0 ;
20175 wxDateTime::WeekDay arg2 ;
20176 int arg3 = (int) 1 ;
20177 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20178 int arg5 = (int) wxDateTime::Inv_Year ;
20179 bool result;
20180 PyObject * obj0 = 0 ;
20181 PyObject * obj1 = 0 ;
20182 PyObject * obj2 = 0 ;
20183 PyObject * obj3 = 0 ;
20184 PyObject * obj4 = 0 ;
20185 char *kwnames[] = {
20186 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20187 };
20188
20189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20191 if (SWIG_arg_fail(1)) SWIG_fail;
20192 {
20193 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20194 if (SWIG_arg_fail(2)) SWIG_fail;
20195 }
20196 if (obj2) {
20197 {
20198 arg3 = (int)(SWIG_As_int(obj2));
20199 if (SWIG_arg_fail(3)) SWIG_fail;
20200 }
20201 }
20202 if (obj3) {
20203 {
20204 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20205 if (SWIG_arg_fail(4)) SWIG_fail;
20206 }
20207 }
20208 if (obj4) {
20209 {
20210 arg5 = (int)(SWIG_As_int(obj4));
20211 if (SWIG_arg_fail(5)) SWIG_fail;
20212 }
20213 }
20214 {
20215 PyThreadState* __tstate = wxPyBeginAllowThreads();
20216 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20217
20218 wxPyEndAllowThreads(__tstate);
20219 if (PyErr_Occurred()) SWIG_fail;
20220 }
20221 {
20222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20223 }
20224 return resultobj;
20225 fail:
20226 return NULL;
20227 }
20228
20229
20230 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20231 PyObject *resultobj;
20232 wxDateTime *arg1 = (wxDateTime *) 0 ;
20233 wxDateTime::WeekDay arg2 ;
20234 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20235 int arg4 = (int) wxDateTime::Inv_Year ;
20236 bool result;
20237 PyObject * obj0 = 0 ;
20238 PyObject * obj1 = 0 ;
20239 PyObject * obj2 = 0 ;
20240 PyObject * obj3 = 0 ;
20241 char *kwnames[] = {
20242 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20243 };
20244
20245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20247 if (SWIG_arg_fail(1)) SWIG_fail;
20248 {
20249 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20250 if (SWIG_arg_fail(2)) SWIG_fail;
20251 }
20252 if (obj2) {
20253 {
20254 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20255 if (SWIG_arg_fail(3)) SWIG_fail;
20256 }
20257 }
20258 if (obj3) {
20259 {
20260 arg4 = (int)(SWIG_As_int(obj3));
20261 if (SWIG_arg_fail(4)) SWIG_fail;
20262 }
20263 }
20264 {
20265 PyThreadState* __tstate = wxPyBeginAllowThreads();
20266 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20267
20268 wxPyEndAllowThreads(__tstate);
20269 if (PyErr_Occurred()) SWIG_fail;
20270 }
20271 {
20272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20273 }
20274 return resultobj;
20275 fail:
20276 return NULL;
20277 }
20278
20279
20280 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20281 PyObject *resultobj;
20282 wxDateTime *arg1 = (wxDateTime *) 0 ;
20283 wxDateTime::WeekDay arg2 ;
20284 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20285 int arg4 = (int) wxDateTime::Inv_Year ;
20286 wxDateTime result;
20287 PyObject * obj0 = 0 ;
20288 PyObject * obj1 = 0 ;
20289 PyObject * obj2 = 0 ;
20290 PyObject * obj3 = 0 ;
20291 char *kwnames[] = {
20292 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20293 };
20294
20295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20297 if (SWIG_arg_fail(1)) SWIG_fail;
20298 {
20299 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20300 if (SWIG_arg_fail(2)) SWIG_fail;
20301 }
20302 if (obj2) {
20303 {
20304 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20305 if (SWIG_arg_fail(3)) SWIG_fail;
20306 }
20307 }
20308 if (obj3) {
20309 {
20310 arg4 = (int)(SWIG_As_int(obj3));
20311 if (SWIG_arg_fail(4)) SWIG_fail;
20312 }
20313 }
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20317
20318 wxPyEndAllowThreads(__tstate);
20319 if (PyErr_Occurred()) SWIG_fail;
20320 }
20321 {
20322 wxDateTime * resultptr;
20323 resultptr = new wxDateTime((wxDateTime &)(result));
20324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20325 }
20326 return resultobj;
20327 fail:
20328 return NULL;
20329 }
20330
20331
20332 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20333 PyObject *resultobj;
20334 wxDateTime *arg1 = (wxDateTime *) 0 ;
20335 int arg2 ;
20336 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20337 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20338 bool result;
20339 PyObject * obj0 = 0 ;
20340 PyObject * obj1 = 0 ;
20341 PyObject * obj2 = 0 ;
20342 PyObject * obj3 = 0 ;
20343 char *kwnames[] = {
20344 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20345 };
20346
20347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20349 if (SWIG_arg_fail(1)) SWIG_fail;
20350 {
20351 arg2 = (int)(SWIG_As_int(obj1));
20352 if (SWIG_arg_fail(2)) SWIG_fail;
20353 }
20354 if (obj2) {
20355 {
20356 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20357 if (SWIG_arg_fail(3)) SWIG_fail;
20358 }
20359 }
20360 if (obj3) {
20361 {
20362 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20363 if (SWIG_arg_fail(4)) SWIG_fail;
20364 }
20365 }
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20369
20370 wxPyEndAllowThreads(__tstate);
20371 if (PyErr_Occurred()) SWIG_fail;
20372 }
20373 {
20374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20375 }
20376 return resultobj;
20377 fail:
20378 return NULL;
20379 }
20380
20381
20382 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20383 PyObject *resultobj;
20384 wxDateTime *arg1 = (wxDateTime *) 0 ;
20385 int arg2 ;
20386 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20387 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20388 wxDateTime result;
20389 PyObject * obj0 = 0 ;
20390 PyObject * obj1 = 0 ;
20391 PyObject * obj2 = 0 ;
20392 PyObject * obj3 = 0 ;
20393 char *kwnames[] = {
20394 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20395 };
20396
20397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20399 if (SWIG_arg_fail(1)) SWIG_fail;
20400 {
20401 arg2 = (int)(SWIG_As_int(obj1));
20402 if (SWIG_arg_fail(2)) SWIG_fail;
20403 }
20404 if (obj2) {
20405 {
20406 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20407 if (SWIG_arg_fail(3)) SWIG_fail;
20408 }
20409 }
20410 if (obj3) {
20411 {
20412 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20413 if (SWIG_arg_fail(4)) SWIG_fail;
20414 }
20415 }
20416 {
20417 PyThreadState* __tstate = wxPyBeginAllowThreads();
20418 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20419
20420 wxPyEndAllowThreads(__tstate);
20421 if (PyErr_Occurred()) SWIG_fail;
20422 }
20423 {
20424 wxDateTime * resultptr;
20425 resultptr = new wxDateTime((wxDateTime &)(result));
20426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20427 }
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20435 PyObject *resultobj;
20436 int arg1 ;
20437 int arg2 ;
20438 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20439 wxDateTime result;
20440 PyObject * obj0 = 0 ;
20441 PyObject * obj1 = 0 ;
20442 PyObject * obj2 = 0 ;
20443 char *kwnames[] = {
20444 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20445 };
20446
20447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20448 {
20449 arg1 = (int)(SWIG_As_int(obj0));
20450 if (SWIG_arg_fail(1)) SWIG_fail;
20451 }
20452 {
20453 arg2 = (int)(SWIG_As_int(obj1));
20454 if (SWIG_arg_fail(2)) SWIG_fail;
20455 }
20456 if (obj2) {
20457 {
20458 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20459 if (SWIG_arg_fail(3)) SWIG_fail;
20460 }
20461 }
20462 {
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20465
20466 wxPyEndAllowThreads(__tstate);
20467 if (PyErr_Occurred()) SWIG_fail;
20468 }
20469 {
20470 wxDateTime * resultptr;
20471 resultptr = new wxDateTime((wxDateTime &)(result));
20472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20473 }
20474 return resultobj;
20475 fail:
20476 return NULL;
20477 }
20478
20479
20480 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20481 PyObject *resultobj;
20482 wxDateTime *arg1 = (wxDateTime *) 0 ;
20483 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20484 int arg3 = (int) wxDateTime::Inv_Year ;
20485 wxDateTime *result;
20486 PyObject * obj0 = 0 ;
20487 PyObject * obj1 = 0 ;
20488 PyObject * obj2 = 0 ;
20489 char *kwnames[] = {
20490 (char *) "self",(char *) "month",(char *) "year", NULL
20491 };
20492
20493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20495 if (SWIG_arg_fail(1)) SWIG_fail;
20496 if (obj1) {
20497 {
20498 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20499 if (SWIG_arg_fail(2)) SWIG_fail;
20500 }
20501 }
20502 if (obj2) {
20503 {
20504 arg3 = (int)(SWIG_As_int(obj2));
20505 if (SWIG_arg_fail(3)) SWIG_fail;
20506 }
20507 }
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 {
20511 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20512 result = (wxDateTime *) &_result_ref;
20513 }
20514
20515 wxPyEndAllowThreads(__tstate);
20516 if (PyErr_Occurred()) SWIG_fail;
20517 }
20518 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20519 return resultobj;
20520 fail:
20521 return NULL;
20522 }
20523
20524
20525 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj;
20527 wxDateTime *arg1 = (wxDateTime *) 0 ;
20528 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20529 int arg3 = (int) wxDateTime::Inv_Year ;
20530 wxDateTime result;
20531 PyObject * obj0 = 0 ;
20532 PyObject * obj1 = 0 ;
20533 PyObject * obj2 = 0 ;
20534 char *kwnames[] = {
20535 (char *) "self",(char *) "month",(char *) "year", NULL
20536 };
20537
20538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20540 if (SWIG_arg_fail(1)) SWIG_fail;
20541 if (obj1) {
20542 {
20543 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20544 if (SWIG_arg_fail(2)) SWIG_fail;
20545 }
20546 }
20547 if (obj2) {
20548 {
20549 arg3 = (int)(SWIG_As_int(obj2));
20550 if (SWIG_arg_fail(3)) SWIG_fail;
20551 }
20552 }
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20556
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 {
20561 wxDateTime * resultptr;
20562 resultptr = new wxDateTime((wxDateTime &)(result));
20563 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20564 }
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20572 PyObject *resultobj;
20573 wxDateTime *arg1 = (wxDateTime *) 0 ;
20574 int arg2 ;
20575 wxDateTime *result;
20576 PyObject * obj0 = 0 ;
20577 PyObject * obj1 = 0 ;
20578 char *kwnames[] = {
20579 (char *) "self",(char *) "yday", NULL
20580 };
20581
20582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20584 if (SWIG_arg_fail(1)) SWIG_fail;
20585 {
20586 arg2 = (int)(SWIG_As_int(obj1));
20587 if (SWIG_arg_fail(2)) SWIG_fail;
20588 }
20589 {
20590 PyThreadState* __tstate = wxPyBeginAllowThreads();
20591 {
20592 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20593 result = (wxDateTime *) &_result_ref;
20594 }
20595
20596 wxPyEndAllowThreads(__tstate);
20597 if (PyErr_Occurred()) SWIG_fail;
20598 }
20599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20607 PyObject *resultobj;
20608 wxDateTime *arg1 = (wxDateTime *) 0 ;
20609 int arg2 ;
20610 wxDateTime result;
20611 PyObject * obj0 = 0 ;
20612 PyObject * obj1 = 0 ;
20613 char *kwnames[] = {
20614 (char *) "self",(char *) "yday", NULL
20615 };
20616
20617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20619 if (SWIG_arg_fail(1)) SWIG_fail;
20620 {
20621 arg2 = (int)(SWIG_As_int(obj1));
20622 if (SWIG_arg_fail(2)) SWIG_fail;
20623 }
20624 {
20625 PyThreadState* __tstate = wxPyBeginAllowThreads();
20626 result = (arg1)->GetYearDay(arg2);
20627
20628 wxPyEndAllowThreads(__tstate);
20629 if (PyErr_Occurred()) SWIG_fail;
20630 }
20631 {
20632 wxDateTime * resultptr;
20633 resultptr = new wxDateTime((wxDateTime &)(result));
20634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20635 }
20636 return resultobj;
20637 fail:
20638 return NULL;
20639 }
20640
20641
20642 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20643 PyObject *resultobj;
20644 wxDateTime *arg1 = (wxDateTime *) 0 ;
20645 double result;
20646 PyObject * obj0 = 0 ;
20647 char *kwnames[] = {
20648 (char *) "self", NULL
20649 };
20650
20651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20653 if (SWIG_arg_fail(1)) SWIG_fail;
20654 {
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 result = (double)(arg1)->GetJulianDayNumber();
20657
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 {
20662 resultobj = SWIG_From_double((double)(result));
20663 }
20664 return resultobj;
20665 fail:
20666 return NULL;
20667 }
20668
20669
20670 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20671 PyObject *resultobj;
20672 wxDateTime *arg1 = (wxDateTime *) 0 ;
20673 double result;
20674 PyObject * obj0 = 0 ;
20675 char *kwnames[] = {
20676 (char *) "self", NULL
20677 };
20678
20679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20681 if (SWIG_arg_fail(1)) SWIG_fail;
20682 {
20683 PyThreadState* __tstate = wxPyBeginAllowThreads();
20684 result = (double)(arg1)->GetJDN();
20685
20686 wxPyEndAllowThreads(__tstate);
20687 if (PyErr_Occurred()) SWIG_fail;
20688 }
20689 {
20690 resultobj = SWIG_From_double((double)(result));
20691 }
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20699 PyObject *resultobj;
20700 wxDateTime *arg1 = (wxDateTime *) 0 ;
20701 double result;
20702 PyObject * obj0 = 0 ;
20703 char *kwnames[] = {
20704 (char *) "self", NULL
20705 };
20706
20707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20709 if (SWIG_arg_fail(1)) SWIG_fail;
20710 {
20711 PyThreadState* __tstate = wxPyBeginAllowThreads();
20712 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20713
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 {
20718 resultobj = SWIG_From_double((double)(result));
20719 }
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20727 PyObject *resultobj;
20728 wxDateTime *arg1 = (wxDateTime *) 0 ;
20729 double result;
20730 PyObject * obj0 = 0 ;
20731 char *kwnames[] = {
20732 (char *) "self", NULL
20733 };
20734
20735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20737 if (SWIG_arg_fail(1)) SWIG_fail;
20738 {
20739 PyThreadState* __tstate = wxPyBeginAllowThreads();
20740 result = (double)(arg1)->GetMJD();
20741
20742 wxPyEndAllowThreads(__tstate);
20743 if (PyErr_Occurred()) SWIG_fail;
20744 }
20745 {
20746 resultobj = SWIG_From_double((double)(result));
20747 }
20748 return resultobj;
20749 fail:
20750 return NULL;
20751 }
20752
20753
20754 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20755 PyObject *resultobj;
20756 wxDateTime *arg1 = (wxDateTime *) 0 ;
20757 double result;
20758 PyObject * obj0 = 0 ;
20759 char *kwnames[] = {
20760 (char *) "self", NULL
20761 };
20762
20763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20765 if (SWIG_arg_fail(1)) SWIG_fail;
20766 {
20767 PyThreadState* __tstate = wxPyBeginAllowThreads();
20768 result = (double)(arg1)->GetRataDie();
20769
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 {
20774 resultobj = SWIG_From_double((double)(result));
20775 }
20776 return resultobj;
20777 fail:
20778 return NULL;
20779 }
20780
20781
20782 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20783 PyObject *resultobj;
20784 wxDateTime *arg1 = (wxDateTime *) 0 ;
20785 wxDateTime::TimeZone *arg2 = 0 ;
20786 bool arg3 = (bool) false ;
20787 wxDateTime result;
20788 bool temp2 = false ;
20789 PyObject * obj0 = 0 ;
20790 PyObject * obj1 = 0 ;
20791 PyObject * obj2 = 0 ;
20792 char *kwnames[] = {
20793 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20794 };
20795
20796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20798 if (SWIG_arg_fail(1)) SWIG_fail;
20799 {
20800 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20801 temp2 = true;
20802 }
20803 if (obj2) {
20804 {
20805 arg3 = (bool)(SWIG_As_bool(obj2));
20806 if (SWIG_arg_fail(3)) SWIG_fail;
20807 }
20808 }
20809 {
20810 PyThreadState* __tstate = wxPyBeginAllowThreads();
20811 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20812
20813 wxPyEndAllowThreads(__tstate);
20814 if (PyErr_Occurred()) SWIG_fail;
20815 }
20816 {
20817 wxDateTime * resultptr;
20818 resultptr = new wxDateTime((wxDateTime &)(result));
20819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20820 }
20821 {
20822 if (temp2) delete arg2;
20823 }
20824 return resultobj;
20825 fail:
20826 {
20827 if (temp2) delete arg2;
20828 }
20829 return NULL;
20830 }
20831
20832
20833 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20834 PyObject *resultobj;
20835 wxDateTime *arg1 = (wxDateTime *) 0 ;
20836 wxDateTime::TimeZone *arg2 = 0 ;
20837 bool arg3 = (bool) false ;
20838 wxDateTime *result;
20839 bool temp2 = false ;
20840 PyObject * obj0 = 0 ;
20841 PyObject * obj1 = 0 ;
20842 PyObject * obj2 = 0 ;
20843 char *kwnames[] = {
20844 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20845 };
20846
20847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20849 if (SWIG_arg_fail(1)) SWIG_fail;
20850 {
20851 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20852 temp2 = true;
20853 }
20854 if (obj2) {
20855 {
20856 arg3 = (bool)(SWIG_As_bool(obj2));
20857 if (SWIG_arg_fail(3)) SWIG_fail;
20858 }
20859 }
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 {
20863 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20864 result = (wxDateTime *) &_result_ref;
20865 }
20866
20867 wxPyEndAllowThreads(__tstate);
20868 if (PyErr_Occurred()) SWIG_fail;
20869 }
20870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20871 {
20872 if (temp2) delete arg2;
20873 }
20874 return resultobj;
20875 fail:
20876 {
20877 if (temp2) delete arg2;
20878 }
20879 return NULL;
20880 }
20881
20882
20883 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20884 PyObject *resultobj;
20885 wxDateTime *arg1 = (wxDateTime *) 0 ;
20886 bool arg2 = (bool) false ;
20887 wxDateTime result;
20888 PyObject * obj0 = 0 ;
20889 PyObject * obj1 = 0 ;
20890 char *kwnames[] = {
20891 (char *) "self",(char *) "noDST", NULL
20892 };
20893
20894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
20895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20896 if (SWIG_arg_fail(1)) SWIG_fail;
20897 if (obj1) {
20898 {
20899 arg2 = (bool)(SWIG_As_bool(obj1));
20900 if (SWIG_arg_fail(2)) SWIG_fail;
20901 }
20902 }
20903 {
20904 PyThreadState* __tstate = wxPyBeginAllowThreads();
20905 result = (arg1)->ToGMT(arg2);
20906
20907 wxPyEndAllowThreads(__tstate);
20908 if (PyErr_Occurred()) SWIG_fail;
20909 }
20910 {
20911 wxDateTime * resultptr;
20912 resultptr = new wxDateTime((wxDateTime &)(result));
20913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20914 }
20915 return resultobj;
20916 fail:
20917 return NULL;
20918 }
20919
20920
20921 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20922 PyObject *resultobj;
20923 wxDateTime *arg1 = (wxDateTime *) 0 ;
20924 bool arg2 = (bool) false ;
20925 wxDateTime *result;
20926 PyObject * obj0 = 0 ;
20927 PyObject * obj1 = 0 ;
20928 char *kwnames[] = {
20929 (char *) "self",(char *) "noDST", NULL
20930 };
20931
20932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
20933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20934 if (SWIG_arg_fail(1)) SWIG_fail;
20935 if (obj1) {
20936 {
20937 arg2 = (bool)(SWIG_As_bool(obj1));
20938 if (SWIG_arg_fail(2)) SWIG_fail;
20939 }
20940 }
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 {
20944 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
20945 result = (wxDateTime *) &_result_ref;
20946 }
20947
20948 wxPyEndAllowThreads(__tstate);
20949 if (PyErr_Occurred()) SWIG_fail;
20950 }
20951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
20959 PyObject *resultobj;
20960 wxDateTime *arg1 = (wxDateTime *) 0 ;
20961 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20962 int result;
20963 PyObject * obj0 = 0 ;
20964 PyObject * obj1 = 0 ;
20965 char *kwnames[] = {
20966 (char *) "self",(char *) "country", NULL
20967 };
20968
20969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
20970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20971 if (SWIG_arg_fail(1)) SWIG_fail;
20972 if (obj1) {
20973 {
20974 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
20975 if (SWIG_arg_fail(2)) SWIG_fail;
20976 }
20977 }
20978 {
20979 PyThreadState* __tstate = wxPyBeginAllowThreads();
20980 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
20981
20982 wxPyEndAllowThreads(__tstate);
20983 if (PyErr_Occurred()) SWIG_fail;
20984 }
20985 {
20986 resultobj = SWIG_From_int((int)(result));
20987 }
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj;
20996 wxDateTime *arg1 = (wxDateTime *) 0 ;
20997 bool result;
20998 PyObject * obj0 = 0 ;
20999 char *kwnames[] = {
21000 (char *) "self", NULL
21001 };
21002
21003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21005 if (SWIG_arg_fail(1)) SWIG_fail;
21006 {
21007 PyThreadState* __tstate = wxPyBeginAllowThreads();
21008 result = (bool)((wxDateTime const *)arg1)->IsValid();
21009
21010 wxPyEndAllowThreads(__tstate);
21011 if (PyErr_Occurred()) SWIG_fail;
21012 }
21013 {
21014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21015 }
21016 return resultobj;
21017 fail:
21018 return NULL;
21019 }
21020
21021
21022 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21023 PyObject *resultobj;
21024 wxDateTime *arg1 = (wxDateTime *) 0 ;
21025 time_t result;
21026 PyObject * obj0 = 0 ;
21027 char *kwnames[] = {
21028 (char *) "self", NULL
21029 };
21030
21031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21033 if (SWIG_arg_fail(1)) SWIG_fail;
21034 {
21035 PyThreadState* __tstate = wxPyBeginAllowThreads();
21036 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21037
21038 wxPyEndAllowThreads(__tstate);
21039 if (PyErr_Occurred()) SWIG_fail;
21040 }
21041 {
21042 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21043 }
21044 return resultobj;
21045 fail:
21046 return NULL;
21047 }
21048
21049
21050 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21051 PyObject *resultobj;
21052 wxDateTime *arg1 = (wxDateTime *) 0 ;
21053 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21054 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21055 int result;
21056 bool temp2 = false ;
21057 PyObject * obj0 = 0 ;
21058 PyObject * obj1 = 0 ;
21059 char *kwnames[] = {
21060 (char *) "self",(char *) "tz", NULL
21061 };
21062
21063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21065 if (SWIG_arg_fail(1)) SWIG_fail;
21066 if (obj1) {
21067 {
21068 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21069 temp2 = true;
21070 }
21071 }
21072 {
21073 PyThreadState* __tstate = wxPyBeginAllowThreads();
21074 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21075
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 {
21080 resultobj = SWIG_From_int((int)(result));
21081 }
21082 {
21083 if (temp2) delete arg2;
21084 }
21085 return resultobj;
21086 fail:
21087 {
21088 if (temp2) delete arg2;
21089 }
21090 return NULL;
21091 }
21092
21093
21094 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21095 PyObject *resultobj;
21096 wxDateTime *arg1 = (wxDateTime *) 0 ;
21097 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21098 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21099 wxDateTime::Month result;
21100 bool temp2 = false ;
21101 PyObject * obj0 = 0 ;
21102 PyObject * obj1 = 0 ;
21103 char *kwnames[] = {
21104 (char *) "self",(char *) "tz", NULL
21105 };
21106
21107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21109 if (SWIG_arg_fail(1)) SWIG_fail;
21110 if (obj1) {
21111 {
21112 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21113 temp2 = true;
21114 }
21115 }
21116 {
21117 PyThreadState* __tstate = wxPyBeginAllowThreads();
21118 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21119
21120 wxPyEndAllowThreads(__tstate);
21121 if (PyErr_Occurred()) SWIG_fail;
21122 }
21123 resultobj = SWIG_From_int((result));
21124 {
21125 if (temp2) delete arg2;
21126 }
21127 return resultobj;
21128 fail:
21129 {
21130 if (temp2) delete arg2;
21131 }
21132 return NULL;
21133 }
21134
21135
21136 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21137 PyObject *resultobj;
21138 wxDateTime *arg1 = (wxDateTime *) 0 ;
21139 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21140 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21141 int result;
21142 bool temp2 = false ;
21143 PyObject * obj0 = 0 ;
21144 PyObject * obj1 = 0 ;
21145 char *kwnames[] = {
21146 (char *) "self",(char *) "tz", NULL
21147 };
21148
21149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21151 if (SWIG_arg_fail(1)) SWIG_fail;
21152 if (obj1) {
21153 {
21154 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21155 temp2 = true;
21156 }
21157 }
21158 {
21159 PyThreadState* __tstate = wxPyBeginAllowThreads();
21160 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21161
21162 wxPyEndAllowThreads(__tstate);
21163 if (PyErr_Occurred()) SWIG_fail;
21164 }
21165 {
21166 resultobj = SWIG_From_int((int)(result));
21167 }
21168 {
21169 if (temp2) delete arg2;
21170 }
21171 return resultobj;
21172 fail:
21173 {
21174 if (temp2) delete arg2;
21175 }
21176 return NULL;
21177 }
21178
21179
21180 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21181 PyObject *resultobj;
21182 wxDateTime *arg1 = (wxDateTime *) 0 ;
21183 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21184 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21185 wxDateTime::WeekDay result;
21186 bool temp2 = false ;
21187 PyObject * obj0 = 0 ;
21188 PyObject * obj1 = 0 ;
21189 char *kwnames[] = {
21190 (char *) "self",(char *) "tz", NULL
21191 };
21192
21193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21195 if (SWIG_arg_fail(1)) SWIG_fail;
21196 if (obj1) {
21197 {
21198 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21199 temp2 = true;
21200 }
21201 }
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21205
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 resultobj = SWIG_From_int((result));
21210 {
21211 if (temp2) delete arg2;
21212 }
21213 return resultobj;
21214 fail:
21215 {
21216 if (temp2) delete arg2;
21217 }
21218 return NULL;
21219 }
21220
21221
21222 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21223 PyObject *resultobj;
21224 wxDateTime *arg1 = (wxDateTime *) 0 ;
21225 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21226 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21227 int result;
21228 bool temp2 = false ;
21229 PyObject * obj0 = 0 ;
21230 PyObject * obj1 = 0 ;
21231 char *kwnames[] = {
21232 (char *) "self",(char *) "tz", NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21237 if (SWIG_arg_fail(1)) SWIG_fail;
21238 if (obj1) {
21239 {
21240 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21241 temp2 = true;
21242 }
21243 }
21244 {
21245 PyThreadState* __tstate = wxPyBeginAllowThreads();
21246 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21247
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 {
21252 resultobj = SWIG_From_int((int)(result));
21253 }
21254 {
21255 if (temp2) delete arg2;
21256 }
21257 return resultobj;
21258 fail:
21259 {
21260 if (temp2) delete arg2;
21261 }
21262 return NULL;
21263 }
21264
21265
21266 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21267 PyObject *resultobj;
21268 wxDateTime *arg1 = (wxDateTime *) 0 ;
21269 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21270 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21271 int result;
21272 bool temp2 = false ;
21273 PyObject * obj0 = 0 ;
21274 PyObject * obj1 = 0 ;
21275 char *kwnames[] = {
21276 (char *) "self",(char *) "tz", NULL
21277 };
21278
21279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21281 if (SWIG_arg_fail(1)) SWIG_fail;
21282 if (obj1) {
21283 {
21284 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21285 temp2 = true;
21286 }
21287 }
21288 {
21289 PyThreadState* __tstate = wxPyBeginAllowThreads();
21290 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21291
21292 wxPyEndAllowThreads(__tstate);
21293 if (PyErr_Occurred()) SWIG_fail;
21294 }
21295 {
21296 resultobj = SWIG_From_int((int)(result));
21297 }
21298 {
21299 if (temp2) delete arg2;
21300 }
21301 return resultobj;
21302 fail:
21303 {
21304 if (temp2) delete arg2;
21305 }
21306 return NULL;
21307 }
21308
21309
21310 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21311 PyObject *resultobj;
21312 wxDateTime *arg1 = (wxDateTime *) 0 ;
21313 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21314 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21315 int result;
21316 bool temp2 = false ;
21317 PyObject * obj0 = 0 ;
21318 PyObject * obj1 = 0 ;
21319 char *kwnames[] = {
21320 (char *) "self",(char *) "tz", NULL
21321 };
21322
21323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21325 if (SWIG_arg_fail(1)) SWIG_fail;
21326 if (obj1) {
21327 {
21328 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21329 temp2 = true;
21330 }
21331 }
21332 {
21333 PyThreadState* __tstate = wxPyBeginAllowThreads();
21334 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21335
21336 wxPyEndAllowThreads(__tstate);
21337 if (PyErr_Occurred()) SWIG_fail;
21338 }
21339 {
21340 resultobj = SWIG_From_int((int)(result));
21341 }
21342 {
21343 if (temp2) delete arg2;
21344 }
21345 return resultobj;
21346 fail:
21347 {
21348 if (temp2) delete arg2;
21349 }
21350 return NULL;
21351 }
21352
21353
21354 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21355 PyObject *resultobj;
21356 wxDateTime *arg1 = (wxDateTime *) 0 ;
21357 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21358 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21359 int result;
21360 bool temp2 = false ;
21361 PyObject * obj0 = 0 ;
21362 PyObject * obj1 = 0 ;
21363 char *kwnames[] = {
21364 (char *) "self",(char *) "tz", NULL
21365 };
21366
21367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21369 if (SWIG_arg_fail(1)) SWIG_fail;
21370 if (obj1) {
21371 {
21372 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21373 temp2 = true;
21374 }
21375 }
21376 {
21377 PyThreadState* __tstate = wxPyBeginAllowThreads();
21378 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21379
21380 wxPyEndAllowThreads(__tstate);
21381 if (PyErr_Occurred()) SWIG_fail;
21382 }
21383 {
21384 resultobj = SWIG_From_int((int)(result));
21385 }
21386 {
21387 if (temp2) delete arg2;
21388 }
21389 return resultobj;
21390 fail:
21391 {
21392 if (temp2) delete arg2;
21393 }
21394 return NULL;
21395 }
21396
21397
21398 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21399 PyObject *resultobj;
21400 wxDateTime *arg1 = (wxDateTime *) 0 ;
21401 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21402 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21403 int result;
21404 bool temp2 = false ;
21405 PyObject * obj0 = 0 ;
21406 PyObject * obj1 = 0 ;
21407 char *kwnames[] = {
21408 (char *) "self",(char *) "tz", NULL
21409 };
21410
21411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21413 if (SWIG_arg_fail(1)) SWIG_fail;
21414 if (obj1) {
21415 {
21416 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21417 temp2 = true;
21418 }
21419 }
21420 {
21421 PyThreadState* __tstate = wxPyBeginAllowThreads();
21422 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21423
21424 wxPyEndAllowThreads(__tstate);
21425 if (PyErr_Occurred()) SWIG_fail;
21426 }
21427 {
21428 resultobj = SWIG_From_int((int)(result));
21429 }
21430 {
21431 if (temp2) delete arg2;
21432 }
21433 return resultobj;
21434 fail:
21435 {
21436 if (temp2) delete arg2;
21437 }
21438 return NULL;
21439 }
21440
21441
21442 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21443 PyObject *resultobj;
21444 wxDateTime *arg1 = (wxDateTime *) 0 ;
21445 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21446 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21447 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21448 int result;
21449 bool temp3 = false ;
21450 PyObject * obj0 = 0 ;
21451 PyObject * obj1 = 0 ;
21452 PyObject * obj2 = 0 ;
21453 char *kwnames[] = {
21454 (char *) "self",(char *) "flags",(char *) "tz", NULL
21455 };
21456
21457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21459 if (SWIG_arg_fail(1)) SWIG_fail;
21460 if (obj1) {
21461 {
21462 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21463 if (SWIG_arg_fail(2)) SWIG_fail;
21464 }
21465 }
21466 if (obj2) {
21467 {
21468 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21469 temp3 = true;
21470 }
21471 }
21472 {
21473 PyThreadState* __tstate = wxPyBeginAllowThreads();
21474 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21475
21476 wxPyEndAllowThreads(__tstate);
21477 if (PyErr_Occurred()) SWIG_fail;
21478 }
21479 {
21480 resultobj = SWIG_From_int((int)(result));
21481 }
21482 {
21483 if (temp3) delete arg3;
21484 }
21485 return resultobj;
21486 fail:
21487 {
21488 if (temp3) delete arg3;
21489 }
21490 return NULL;
21491 }
21492
21493
21494 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21495 PyObject *resultobj;
21496 wxDateTime *arg1 = (wxDateTime *) 0 ;
21497 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21498 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21499 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21500 int result;
21501 bool temp3 = false ;
21502 PyObject * obj0 = 0 ;
21503 PyObject * obj1 = 0 ;
21504 PyObject * obj2 = 0 ;
21505 char *kwnames[] = {
21506 (char *) "self",(char *) "flags",(char *) "tz", NULL
21507 };
21508
21509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21511 if (SWIG_arg_fail(1)) SWIG_fail;
21512 if (obj1) {
21513 {
21514 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21515 if (SWIG_arg_fail(2)) SWIG_fail;
21516 }
21517 }
21518 if (obj2) {
21519 {
21520 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21521 temp3 = true;
21522 }
21523 }
21524 {
21525 PyThreadState* __tstate = wxPyBeginAllowThreads();
21526 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21527
21528 wxPyEndAllowThreads(__tstate);
21529 if (PyErr_Occurred()) SWIG_fail;
21530 }
21531 {
21532 resultobj = SWIG_From_int((int)(result));
21533 }
21534 {
21535 if (temp3) delete arg3;
21536 }
21537 return resultobj;
21538 fail:
21539 {
21540 if (temp3) delete arg3;
21541 }
21542 return NULL;
21543 }
21544
21545
21546 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21547 PyObject *resultobj;
21548 wxDateTime *arg1 = (wxDateTime *) 0 ;
21549 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21550 bool result;
21551 PyObject * obj0 = 0 ;
21552 PyObject * obj1 = 0 ;
21553 char *kwnames[] = {
21554 (char *) "self",(char *) "country", NULL
21555 };
21556
21557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21559 if (SWIG_arg_fail(1)) SWIG_fail;
21560 if (obj1) {
21561 {
21562 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21563 if (SWIG_arg_fail(2)) SWIG_fail;
21564 }
21565 }
21566 {
21567 PyThreadState* __tstate = wxPyBeginAllowThreads();
21568 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21569
21570 wxPyEndAllowThreads(__tstate);
21571 if (PyErr_Occurred()) SWIG_fail;
21572 }
21573 {
21574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21575 }
21576 return resultobj;
21577 fail:
21578 return NULL;
21579 }
21580
21581
21582 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21583 PyObject *resultobj;
21584 wxDateTime *arg1 = (wxDateTime *) 0 ;
21585 wxDateTime *arg2 = 0 ;
21586 bool result;
21587 PyObject * obj0 = 0 ;
21588 PyObject * obj1 = 0 ;
21589 char *kwnames[] = {
21590 (char *) "self",(char *) "datetime", NULL
21591 };
21592
21593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21595 if (SWIG_arg_fail(1)) SWIG_fail;
21596 {
21597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21598 if (SWIG_arg_fail(2)) SWIG_fail;
21599 if (arg2 == NULL) {
21600 SWIG_null_ref("wxDateTime");
21601 }
21602 if (SWIG_arg_fail(2)) SWIG_fail;
21603 }
21604 {
21605 PyThreadState* __tstate = wxPyBeginAllowThreads();
21606 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21607
21608 wxPyEndAllowThreads(__tstate);
21609 if (PyErr_Occurred()) SWIG_fail;
21610 }
21611 {
21612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21613 }
21614 return resultobj;
21615 fail:
21616 return NULL;
21617 }
21618
21619
21620 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21621 PyObject *resultobj;
21622 wxDateTime *arg1 = (wxDateTime *) 0 ;
21623 wxDateTime *arg2 = 0 ;
21624 bool result;
21625 PyObject * obj0 = 0 ;
21626 PyObject * obj1 = 0 ;
21627 char *kwnames[] = {
21628 (char *) "self",(char *) "datetime", NULL
21629 };
21630
21631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21633 if (SWIG_arg_fail(1)) SWIG_fail;
21634 {
21635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21636 if (SWIG_arg_fail(2)) SWIG_fail;
21637 if (arg2 == NULL) {
21638 SWIG_null_ref("wxDateTime");
21639 }
21640 if (SWIG_arg_fail(2)) SWIG_fail;
21641 }
21642 {
21643 PyThreadState* __tstate = wxPyBeginAllowThreads();
21644 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21645
21646 wxPyEndAllowThreads(__tstate);
21647 if (PyErr_Occurred()) SWIG_fail;
21648 }
21649 {
21650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21651 }
21652 return resultobj;
21653 fail:
21654 return NULL;
21655 }
21656
21657
21658 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21659 PyObject *resultobj;
21660 wxDateTime *arg1 = (wxDateTime *) 0 ;
21661 wxDateTime *arg2 = 0 ;
21662 bool result;
21663 PyObject * obj0 = 0 ;
21664 PyObject * obj1 = 0 ;
21665 char *kwnames[] = {
21666 (char *) "self",(char *) "datetime", NULL
21667 };
21668
21669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21671 if (SWIG_arg_fail(1)) SWIG_fail;
21672 {
21673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21674 if (SWIG_arg_fail(2)) SWIG_fail;
21675 if (arg2 == NULL) {
21676 SWIG_null_ref("wxDateTime");
21677 }
21678 if (SWIG_arg_fail(2)) SWIG_fail;
21679 }
21680 {
21681 PyThreadState* __tstate = wxPyBeginAllowThreads();
21682 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21683
21684 wxPyEndAllowThreads(__tstate);
21685 if (PyErr_Occurred()) SWIG_fail;
21686 }
21687 {
21688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21689 }
21690 return resultobj;
21691 fail:
21692 return NULL;
21693 }
21694
21695
21696 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21697 PyObject *resultobj;
21698 wxDateTime *arg1 = (wxDateTime *) 0 ;
21699 wxDateTime *arg2 = 0 ;
21700 wxDateTime *arg3 = 0 ;
21701 bool result;
21702 PyObject * obj0 = 0 ;
21703 PyObject * obj1 = 0 ;
21704 PyObject * obj2 = 0 ;
21705 char *kwnames[] = {
21706 (char *) "self",(char *) "t1",(char *) "t2", NULL
21707 };
21708
21709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21711 if (SWIG_arg_fail(1)) SWIG_fail;
21712 {
21713 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21714 if (SWIG_arg_fail(2)) SWIG_fail;
21715 if (arg2 == NULL) {
21716 SWIG_null_ref("wxDateTime");
21717 }
21718 if (SWIG_arg_fail(2)) SWIG_fail;
21719 }
21720 {
21721 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21722 if (SWIG_arg_fail(3)) SWIG_fail;
21723 if (arg3 == NULL) {
21724 SWIG_null_ref("wxDateTime");
21725 }
21726 if (SWIG_arg_fail(3)) SWIG_fail;
21727 }
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21731
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21737 }
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj;
21746 wxDateTime *arg1 = (wxDateTime *) 0 ;
21747 wxDateTime *arg2 = 0 ;
21748 wxDateTime *arg3 = 0 ;
21749 bool result;
21750 PyObject * obj0 = 0 ;
21751 PyObject * obj1 = 0 ;
21752 PyObject * obj2 = 0 ;
21753 char *kwnames[] = {
21754 (char *) "self",(char *) "t1",(char *) "t2", NULL
21755 };
21756
21757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21759 if (SWIG_arg_fail(1)) SWIG_fail;
21760 {
21761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21762 if (SWIG_arg_fail(2)) SWIG_fail;
21763 if (arg2 == NULL) {
21764 SWIG_null_ref("wxDateTime");
21765 }
21766 if (SWIG_arg_fail(2)) SWIG_fail;
21767 }
21768 {
21769 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21770 if (SWIG_arg_fail(3)) SWIG_fail;
21771 if (arg3 == NULL) {
21772 SWIG_null_ref("wxDateTime");
21773 }
21774 if (SWIG_arg_fail(3)) SWIG_fail;
21775 }
21776 {
21777 PyThreadState* __tstate = wxPyBeginAllowThreads();
21778 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21779
21780 wxPyEndAllowThreads(__tstate);
21781 if (PyErr_Occurred()) SWIG_fail;
21782 }
21783 {
21784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21785 }
21786 return resultobj;
21787 fail:
21788 return NULL;
21789 }
21790
21791
21792 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
21793 PyObject *resultobj;
21794 wxDateTime *arg1 = (wxDateTime *) 0 ;
21795 wxDateTime *arg2 = 0 ;
21796 bool result;
21797 PyObject * obj0 = 0 ;
21798 PyObject * obj1 = 0 ;
21799 char *kwnames[] = {
21800 (char *) "self",(char *) "dt", NULL
21801 };
21802
21803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
21804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21805 if (SWIG_arg_fail(1)) SWIG_fail;
21806 {
21807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21808 if (SWIG_arg_fail(2)) SWIG_fail;
21809 if (arg2 == NULL) {
21810 SWIG_null_ref("wxDateTime");
21811 }
21812 if (SWIG_arg_fail(2)) SWIG_fail;
21813 }
21814 {
21815 PyThreadState* __tstate = wxPyBeginAllowThreads();
21816 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
21817
21818 wxPyEndAllowThreads(__tstate);
21819 if (PyErr_Occurred()) SWIG_fail;
21820 }
21821 {
21822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21823 }
21824 return resultobj;
21825 fail:
21826 return NULL;
21827 }
21828
21829
21830 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj;
21832 wxDateTime *arg1 = (wxDateTime *) 0 ;
21833 wxDateTime *arg2 = 0 ;
21834 bool result;
21835 PyObject * obj0 = 0 ;
21836 PyObject * obj1 = 0 ;
21837 char *kwnames[] = {
21838 (char *) "self",(char *) "dt", NULL
21839 };
21840
21841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
21842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21843 if (SWIG_arg_fail(1)) SWIG_fail;
21844 {
21845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21846 if (SWIG_arg_fail(2)) SWIG_fail;
21847 if (arg2 == NULL) {
21848 SWIG_null_ref("wxDateTime");
21849 }
21850 if (SWIG_arg_fail(2)) SWIG_fail;
21851 }
21852 {
21853 PyThreadState* __tstate = wxPyBeginAllowThreads();
21854 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
21855
21856 wxPyEndAllowThreads(__tstate);
21857 if (PyErr_Occurred()) SWIG_fail;
21858 }
21859 {
21860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21861 }
21862 return resultobj;
21863 fail:
21864 return NULL;
21865 }
21866
21867
21868 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
21869 PyObject *resultobj;
21870 wxDateTime *arg1 = (wxDateTime *) 0 ;
21871 wxDateTime *arg2 = 0 ;
21872 wxTimeSpan *arg3 = 0 ;
21873 bool result;
21874 PyObject * obj0 = 0 ;
21875 PyObject * obj1 = 0 ;
21876 PyObject * obj2 = 0 ;
21877 char *kwnames[] = {
21878 (char *) "self",(char *) "dt",(char *) "ts", NULL
21879 };
21880
21881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21883 if (SWIG_arg_fail(1)) SWIG_fail;
21884 {
21885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21886 if (SWIG_arg_fail(2)) SWIG_fail;
21887 if (arg2 == NULL) {
21888 SWIG_null_ref("wxDateTime");
21889 }
21890 if (SWIG_arg_fail(2)) SWIG_fail;
21891 }
21892 {
21893 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21894 if (SWIG_arg_fail(3)) SWIG_fail;
21895 if (arg3 == NULL) {
21896 SWIG_null_ref("wxTimeSpan");
21897 }
21898 if (SWIG_arg_fail(3)) SWIG_fail;
21899 }
21900 {
21901 PyThreadState* __tstate = wxPyBeginAllowThreads();
21902 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
21903
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 {
21908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21909 }
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj;
21918 wxDateTime *arg1 = (wxDateTime *) 0 ;
21919 wxTimeSpan *arg2 = 0 ;
21920 wxDateTime *result;
21921 PyObject * obj0 = 0 ;
21922 PyObject * obj1 = 0 ;
21923 char *kwnames[] = {
21924 (char *) "self",(char *) "diff", NULL
21925 };
21926
21927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
21928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21929 if (SWIG_arg_fail(1)) SWIG_fail;
21930 {
21931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21932 if (SWIG_arg_fail(2)) SWIG_fail;
21933 if (arg2 == NULL) {
21934 SWIG_null_ref("wxTimeSpan");
21935 }
21936 if (SWIG_arg_fail(2)) SWIG_fail;
21937 }
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 {
21941 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
21942 result = (wxDateTime *) &_result_ref;
21943 }
21944
21945 wxPyEndAllowThreads(__tstate);
21946 if (PyErr_Occurred()) SWIG_fail;
21947 }
21948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21949 return resultobj;
21950 fail:
21951 return NULL;
21952 }
21953
21954
21955 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
21956 PyObject *resultobj;
21957 wxDateTime *arg1 = (wxDateTime *) 0 ;
21958 wxDateSpan *arg2 = 0 ;
21959 wxDateTime *result;
21960 PyObject * obj0 = 0 ;
21961 PyObject * obj1 = 0 ;
21962 char *kwnames[] = {
21963 (char *) "self",(char *) "diff", NULL
21964 };
21965
21966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
21967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21968 if (SWIG_arg_fail(1)) SWIG_fail;
21969 {
21970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
21971 if (SWIG_arg_fail(2)) SWIG_fail;
21972 if (arg2 == NULL) {
21973 SWIG_null_ref("wxDateSpan");
21974 }
21975 if (SWIG_arg_fail(2)) SWIG_fail;
21976 }
21977 {
21978 PyThreadState* __tstate = wxPyBeginAllowThreads();
21979 {
21980 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
21981 result = (wxDateTime *) &_result_ref;
21982 }
21983
21984 wxPyEndAllowThreads(__tstate);
21985 if (PyErr_Occurred()) SWIG_fail;
21986 }
21987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21988 return resultobj;
21989 fail:
21990 return NULL;
21991 }
21992
21993
21994 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
21995 PyObject *resultobj;
21996 wxDateTime *arg1 = (wxDateTime *) 0 ;
21997 wxTimeSpan *arg2 = 0 ;
21998 wxDateTime *result;
21999 PyObject * obj0 = 0 ;
22000 PyObject * obj1 = 0 ;
22001 char *kwnames[] = {
22002 (char *) "self",(char *) "diff", NULL
22003 };
22004
22005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22007 if (SWIG_arg_fail(1)) SWIG_fail;
22008 {
22009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22010 if (SWIG_arg_fail(2)) SWIG_fail;
22011 if (arg2 == NULL) {
22012 SWIG_null_ref("wxTimeSpan");
22013 }
22014 if (SWIG_arg_fail(2)) SWIG_fail;
22015 }
22016 {
22017 PyThreadState* __tstate = wxPyBeginAllowThreads();
22018 {
22019 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22020 result = (wxDateTime *) &_result_ref;
22021 }
22022
22023 wxPyEndAllowThreads(__tstate);
22024 if (PyErr_Occurred()) SWIG_fail;
22025 }
22026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22027 return resultobj;
22028 fail:
22029 return NULL;
22030 }
22031
22032
22033 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22034 PyObject *resultobj;
22035 wxDateTime *arg1 = (wxDateTime *) 0 ;
22036 wxDateSpan *arg2 = 0 ;
22037 wxDateTime *result;
22038 PyObject * obj0 = 0 ;
22039 PyObject * obj1 = 0 ;
22040 char *kwnames[] = {
22041 (char *) "self",(char *) "diff", NULL
22042 };
22043
22044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22046 if (SWIG_arg_fail(1)) SWIG_fail;
22047 {
22048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22049 if (SWIG_arg_fail(2)) SWIG_fail;
22050 if (arg2 == NULL) {
22051 SWIG_null_ref("wxDateSpan");
22052 }
22053 if (SWIG_arg_fail(2)) SWIG_fail;
22054 }
22055 {
22056 PyThreadState* __tstate = wxPyBeginAllowThreads();
22057 {
22058 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22059 result = (wxDateTime *) &_result_ref;
22060 }
22061
22062 wxPyEndAllowThreads(__tstate);
22063 if (PyErr_Occurred()) SWIG_fail;
22064 }
22065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22066 return resultobj;
22067 fail:
22068 return NULL;
22069 }
22070
22071
22072 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22073 PyObject *resultobj;
22074 wxDateTime *arg1 = (wxDateTime *) 0 ;
22075 wxDateTime *arg2 = 0 ;
22076 wxTimeSpan result;
22077 PyObject * obj0 = 0 ;
22078 PyObject * obj1 = 0 ;
22079 char *kwnames[] = {
22080 (char *) "self",(char *) "dt", NULL
22081 };
22082
22083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22085 if (SWIG_arg_fail(1)) SWIG_fail;
22086 {
22087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22088 if (SWIG_arg_fail(2)) SWIG_fail;
22089 if (arg2 == NULL) {
22090 SWIG_null_ref("wxDateTime");
22091 }
22092 if (SWIG_arg_fail(2)) SWIG_fail;
22093 }
22094 {
22095 PyThreadState* __tstate = wxPyBeginAllowThreads();
22096 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22097
22098 wxPyEndAllowThreads(__tstate);
22099 if (PyErr_Occurred()) SWIG_fail;
22100 }
22101 {
22102 wxTimeSpan * resultptr;
22103 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22104 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22105 }
22106 return resultobj;
22107 fail:
22108 return NULL;
22109 }
22110
22111
22112 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22113 PyObject *resultobj;
22114 wxDateTime *arg1 = (wxDateTime *) 0 ;
22115 wxTimeSpan *arg2 = 0 ;
22116 wxDateTime *result;
22117 PyObject * obj0 = 0 ;
22118 PyObject * obj1 = 0 ;
22119
22120 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22122 if (SWIG_arg_fail(1)) SWIG_fail;
22123 {
22124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22125 if (SWIG_arg_fail(2)) SWIG_fail;
22126 if (arg2 == NULL) {
22127 SWIG_null_ref("wxTimeSpan");
22128 }
22129 if (SWIG_arg_fail(2)) SWIG_fail;
22130 }
22131 {
22132 PyThreadState* __tstate = wxPyBeginAllowThreads();
22133 {
22134 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22135 result = (wxDateTime *) &_result_ref;
22136 }
22137
22138 wxPyEndAllowThreads(__tstate);
22139 if (PyErr_Occurred()) SWIG_fail;
22140 }
22141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22142 return resultobj;
22143 fail:
22144 return NULL;
22145 }
22146
22147
22148 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22149 PyObject *resultobj;
22150 wxDateTime *arg1 = (wxDateTime *) 0 ;
22151 wxDateSpan *arg2 = 0 ;
22152 wxDateTime *result;
22153 PyObject * obj0 = 0 ;
22154 PyObject * obj1 = 0 ;
22155
22156 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22158 if (SWIG_arg_fail(1)) SWIG_fail;
22159 {
22160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22161 if (SWIG_arg_fail(2)) SWIG_fail;
22162 if (arg2 == NULL) {
22163 SWIG_null_ref("wxDateSpan");
22164 }
22165 if (SWIG_arg_fail(2)) SWIG_fail;
22166 }
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 {
22170 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22171 result = (wxDateTime *) &_result_ref;
22172 }
22173
22174 wxPyEndAllowThreads(__tstate);
22175 if (PyErr_Occurred()) SWIG_fail;
22176 }
22177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22178 return resultobj;
22179 fail:
22180 return NULL;
22181 }
22182
22183
22184 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22185 int argc;
22186 PyObject *argv[3];
22187 int ii;
22188
22189 argc = PyObject_Length(args);
22190 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22191 argv[ii] = PyTuple_GetItem(args,ii);
22192 }
22193 if (argc == 2) {
22194 int _v;
22195 {
22196 void *ptr;
22197 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22198 _v = 0;
22199 PyErr_Clear();
22200 } else {
22201 _v = 1;
22202 }
22203 }
22204 if (_v) {
22205 {
22206 void *ptr = 0;
22207 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22208 _v = 0;
22209 PyErr_Clear();
22210 } else {
22211 _v = (ptr != 0);
22212 }
22213 }
22214 if (_v) {
22215 return _wrap_DateTime___iadd____SWIG_0(self,args);
22216 }
22217 }
22218 }
22219 if (argc == 2) {
22220 int _v;
22221 {
22222 void *ptr;
22223 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22224 _v = 0;
22225 PyErr_Clear();
22226 } else {
22227 _v = 1;
22228 }
22229 }
22230 if (_v) {
22231 {
22232 void *ptr = 0;
22233 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22234 _v = 0;
22235 PyErr_Clear();
22236 } else {
22237 _v = (ptr != 0);
22238 }
22239 }
22240 if (_v) {
22241 return _wrap_DateTime___iadd____SWIG_1(self,args);
22242 }
22243 }
22244 }
22245
22246 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22247 return NULL;
22248 }
22249
22250
22251 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22252 PyObject *resultobj;
22253 wxDateTime *arg1 = (wxDateTime *) 0 ;
22254 wxTimeSpan *arg2 = 0 ;
22255 wxDateTime *result;
22256 PyObject * obj0 = 0 ;
22257 PyObject * obj1 = 0 ;
22258
22259 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22261 if (SWIG_arg_fail(1)) SWIG_fail;
22262 {
22263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22264 if (SWIG_arg_fail(2)) SWIG_fail;
22265 if (arg2 == NULL) {
22266 SWIG_null_ref("wxTimeSpan");
22267 }
22268 if (SWIG_arg_fail(2)) SWIG_fail;
22269 }
22270 {
22271 PyThreadState* __tstate = wxPyBeginAllowThreads();
22272 {
22273 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22274 result = (wxDateTime *) &_result_ref;
22275 }
22276
22277 wxPyEndAllowThreads(__tstate);
22278 if (PyErr_Occurred()) SWIG_fail;
22279 }
22280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22281 return resultobj;
22282 fail:
22283 return NULL;
22284 }
22285
22286
22287 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22288 PyObject *resultobj;
22289 wxDateTime *arg1 = (wxDateTime *) 0 ;
22290 wxDateSpan *arg2 = 0 ;
22291 wxDateTime *result;
22292 PyObject * obj0 = 0 ;
22293 PyObject * obj1 = 0 ;
22294
22295 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22297 if (SWIG_arg_fail(1)) SWIG_fail;
22298 {
22299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22300 if (SWIG_arg_fail(2)) SWIG_fail;
22301 if (arg2 == NULL) {
22302 SWIG_null_ref("wxDateSpan");
22303 }
22304 if (SWIG_arg_fail(2)) SWIG_fail;
22305 }
22306 {
22307 PyThreadState* __tstate = wxPyBeginAllowThreads();
22308 {
22309 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22310 result = (wxDateTime *) &_result_ref;
22311 }
22312
22313 wxPyEndAllowThreads(__tstate);
22314 if (PyErr_Occurred()) SWIG_fail;
22315 }
22316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22317 return resultobj;
22318 fail:
22319 return NULL;
22320 }
22321
22322
22323 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22324 int argc;
22325 PyObject *argv[3];
22326 int ii;
22327
22328 argc = PyObject_Length(args);
22329 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22330 argv[ii] = PyTuple_GetItem(args,ii);
22331 }
22332 if (argc == 2) {
22333 int _v;
22334 {
22335 void *ptr;
22336 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22337 _v = 0;
22338 PyErr_Clear();
22339 } else {
22340 _v = 1;
22341 }
22342 }
22343 if (_v) {
22344 {
22345 void *ptr = 0;
22346 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22347 _v = 0;
22348 PyErr_Clear();
22349 } else {
22350 _v = (ptr != 0);
22351 }
22352 }
22353 if (_v) {
22354 return _wrap_DateTime___isub____SWIG_0(self,args);
22355 }
22356 }
22357 }
22358 if (argc == 2) {
22359 int _v;
22360 {
22361 void *ptr;
22362 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22363 _v = 0;
22364 PyErr_Clear();
22365 } else {
22366 _v = 1;
22367 }
22368 }
22369 if (_v) {
22370 {
22371 void *ptr = 0;
22372 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22373 _v = 0;
22374 PyErr_Clear();
22375 } else {
22376 _v = (ptr != 0);
22377 }
22378 }
22379 if (_v) {
22380 return _wrap_DateTime___isub____SWIG_1(self,args);
22381 }
22382 }
22383 }
22384
22385 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22386 return NULL;
22387 }
22388
22389
22390 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22391 PyObject *resultobj;
22392 wxDateTime *arg1 = (wxDateTime *) 0 ;
22393 wxTimeSpan *arg2 = 0 ;
22394 wxDateTime result;
22395 PyObject * obj0 = 0 ;
22396 PyObject * obj1 = 0 ;
22397
22398 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22400 if (SWIG_arg_fail(1)) SWIG_fail;
22401 {
22402 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22403 if (SWIG_arg_fail(2)) SWIG_fail;
22404 if (arg2 == NULL) {
22405 SWIG_null_ref("wxTimeSpan");
22406 }
22407 if (SWIG_arg_fail(2)) SWIG_fail;
22408 }
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22412
22413 wxPyEndAllowThreads(__tstate);
22414 if (PyErr_Occurred()) SWIG_fail;
22415 }
22416 {
22417 wxDateTime * resultptr;
22418 resultptr = new wxDateTime((wxDateTime &)(result));
22419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22420 }
22421 return resultobj;
22422 fail:
22423 return NULL;
22424 }
22425
22426
22427 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22428 PyObject *resultobj;
22429 wxDateTime *arg1 = (wxDateTime *) 0 ;
22430 wxDateSpan *arg2 = 0 ;
22431 wxDateTime result;
22432 PyObject * obj0 = 0 ;
22433 PyObject * obj1 = 0 ;
22434
22435 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22437 if (SWIG_arg_fail(1)) SWIG_fail;
22438 {
22439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22440 if (SWIG_arg_fail(2)) SWIG_fail;
22441 if (arg2 == NULL) {
22442 SWIG_null_ref("wxDateSpan");
22443 }
22444 if (SWIG_arg_fail(2)) SWIG_fail;
22445 }
22446 {
22447 PyThreadState* __tstate = wxPyBeginAllowThreads();
22448 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22449
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 {
22454 wxDateTime * resultptr;
22455 resultptr = new wxDateTime((wxDateTime &)(result));
22456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22457 }
22458 return resultobj;
22459 fail:
22460 return NULL;
22461 }
22462
22463
22464 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22465 int argc;
22466 PyObject *argv[3];
22467 int ii;
22468
22469 argc = PyObject_Length(args);
22470 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22471 argv[ii] = PyTuple_GetItem(args,ii);
22472 }
22473 if (argc == 2) {
22474 int _v;
22475 {
22476 void *ptr;
22477 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22478 _v = 0;
22479 PyErr_Clear();
22480 } else {
22481 _v = 1;
22482 }
22483 }
22484 if (_v) {
22485 {
22486 void *ptr = 0;
22487 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22488 _v = 0;
22489 PyErr_Clear();
22490 } else {
22491 _v = (ptr != 0);
22492 }
22493 }
22494 if (_v) {
22495 return _wrap_DateTime___add____SWIG_0(self,args);
22496 }
22497 }
22498 }
22499 if (argc == 2) {
22500 int _v;
22501 {
22502 void *ptr;
22503 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22504 _v = 0;
22505 PyErr_Clear();
22506 } else {
22507 _v = 1;
22508 }
22509 }
22510 if (_v) {
22511 {
22512 void *ptr = 0;
22513 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22514 _v = 0;
22515 PyErr_Clear();
22516 } else {
22517 _v = (ptr != 0);
22518 }
22519 }
22520 if (_v) {
22521 return _wrap_DateTime___add____SWIG_1(self,args);
22522 }
22523 }
22524 }
22525
22526 Py_INCREF(Py_NotImplemented);
22527 return Py_NotImplemented;
22528 }
22529
22530
22531 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22532 PyObject *resultobj;
22533 wxDateTime *arg1 = (wxDateTime *) 0 ;
22534 wxDateTime *arg2 = 0 ;
22535 wxTimeSpan result;
22536 PyObject * obj0 = 0 ;
22537 PyObject * obj1 = 0 ;
22538
22539 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22541 if (SWIG_arg_fail(1)) SWIG_fail;
22542 {
22543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22544 if (SWIG_arg_fail(2)) SWIG_fail;
22545 if (arg2 == NULL) {
22546 SWIG_null_ref("wxDateTime");
22547 }
22548 if (SWIG_arg_fail(2)) SWIG_fail;
22549 }
22550 {
22551 PyThreadState* __tstate = wxPyBeginAllowThreads();
22552 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22553
22554 wxPyEndAllowThreads(__tstate);
22555 if (PyErr_Occurred()) SWIG_fail;
22556 }
22557 {
22558 wxTimeSpan * resultptr;
22559 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22561 }
22562 return resultobj;
22563 fail:
22564 return NULL;
22565 }
22566
22567
22568 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22569 PyObject *resultobj;
22570 wxDateTime *arg1 = (wxDateTime *) 0 ;
22571 wxTimeSpan *arg2 = 0 ;
22572 wxDateTime result;
22573 PyObject * obj0 = 0 ;
22574 PyObject * obj1 = 0 ;
22575
22576 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22578 if (SWIG_arg_fail(1)) SWIG_fail;
22579 {
22580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22581 if (SWIG_arg_fail(2)) SWIG_fail;
22582 if (arg2 == NULL) {
22583 SWIG_null_ref("wxTimeSpan");
22584 }
22585 if (SWIG_arg_fail(2)) SWIG_fail;
22586 }
22587 {
22588 PyThreadState* __tstate = wxPyBeginAllowThreads();
22589 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22590
22591 wxPyEndAllowThreads(__tstate);
22592 if (PyErr_Occurred()) SWIG_fail;
22593 }
22594 {
22595 wxDateTime * resultptr;
22596 resultptr = new wxDateTime((wxDateTime &)(result));
22597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22598 }
22599 return resultobj;
22600 fail:
22601 return NULL;
22602 }
22603
22604
22605 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22606 PyObject *resultobj;
22607 wxDateTime *arg1 = (wxDateTime *) 0 ;
22608 wxDateSpan *arg2 = 0 ;
22609 wxDateTime result;
22610 PyObject * obj0 = 0 ;
22611 PyObject * obj1 = 0 ;
22612
22613 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22615 if (SWIG_arg_fail(1)) SWIG_fail;
22616 {
22617 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22618 if (SWIG_arg_fail(2)) SWIG_fail;
22619 if (arg2 == NULL) {
22620 SWIG_null_ref("wxDateSpan");
22621 }
22622 if (SWIG_arg_fail(2)) SWIG_fail;
22623 }
22624 {
22625 PyThreadState* __tstate = wxPyBeginAllowThreads();
22626 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22627
22628 wxPyEndAllowThreads(__tstate);
22629 if (PyErr_Occurred()) SWIG_fail;
22630 }
22631 {
22632 wxDateTime * resultptr;
22633 resultptr = new wxDateTime((wxDateTime &)(result));
22634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22635 }
22636 return resultobj;
22637 fail:
22638 return NULL;
22639 }
22640
22641
22642 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22643 int argc;
22644 PyObject *argv[3];
22645 int ii;
22646
22647 argc = PyObject_Length(args);
22648 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22649 argv[ii] = PyTuple_GetItem(args,ii);
22650 }
22651 if (argc == 2) {
22652 int _v;
22653 {
22654 void *ptr;
22655 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22656 _v = 0;
22657 PyErr_Clear();
22658 } else {
22659 _v = 1;
22660 }
22661 }
22662 if (_v) {
22663 {
22664 void *ptr = 0;
22665 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22666 _v = 0;
22667 PyErr_Clear();
22668 } else {
22669 _v = (ptr != 0);
22670 }
22671 }
22672 if (_v) {
22673 return _wrap_DateTime___sub____SWIG_0(self,args);
22674 }
22675 }
22676 }
22677 if (argc == 2) {
22678 int _v;
22679 {
22680 void *ptr;
22681 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22682 _v = 0;
22683 PyErr_Clear();
22684 } else {
22685 _v = 1;
22686 }
22687 }
22688 if (_v) {
22689 {
22690 void *ptr = 0;
22691 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22692 _v = 0;
22693 PyErr_Clear();
22694 } else {
22695 _v = (ptr != 0);
22696 }
22697 }
22698 if (_v) {
22699 return _wrap_DateTime___sub____SWIG_1(self,args);
22700 }
22701 }
22702 }
22703 if (argc == 2) {
22704 int _v;
22705 {
22706 void *ptr;
22707 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22708 _v = 0;
22709 PyErr_Clear();
22710 } else {
22711 _v = 1;
22712 }
22713 }
22714 if (_v) {
22715 {
22716 void *ptr = 0;
22717 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22718 _v = 0;
22719 PyErr_Clear();
22720 } else {
22721 _v = (ptr != 0);
22722 }
22723 }
22724 if (_v) {
22725 return _wrap_DateTime___sub____SWIG_2(self,args);
22726 }
22727 }
22728 }
22729
22730 Py_INCREF(Py_NotImplemented);
22731 return Py_NotImplemented;
22732 }
22733
22734
22735 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
22736 PyObject *resultobj;
22737 wxDateTime *arg1 = (wxDateTime *) 0 ;
22738 wxDateTime *arg2 = (wxDateTime *) 0 ;
22739 bool result;
22740 PyObject * obj0 = 0 ;
22741 PyObject * obj1 = 0 ;
22742 char *kwnames[] = {
22743 (char *) "self",(char *) "other", NULL
22744 };
22745
22746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
22747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22748 if (SWIG_arg_fail(1)) SWIG_fail;
22749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22750 if (SWIG_arg_fail(2)) SWIG_fail;
22751 {
22752 PyThreadState* __tstate = wxPyBeginAllowThreads();
22753 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22754
22755 wxPyEndAllowThreads(__tstate);
22756 if (PyErr_Occurred()) SWIG_fail;
22757 }
22758 {
22759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22760 }
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
22768 PyObject *resultobj;
22769 wxDateTime *arg1 = (wxDateTime *) 0 ;
22770 wxDateTime *arg2 = (wxDateTime *) 0 ;
22771 bool result;
22772 PyObject * obj0 = 0 ;
22773 PyObject * obj1 = 0 ;
22774 char *kwnames[] = {
22775 (char *) "self",(char *) "other", NULL
22776 };
22777
22778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
22779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22780 if (SWIG_arg_fail(1)) SWIG_fail;
22781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22782 if (SWIG_arg_fail(2)) SWIG_fail;
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
22786
22787 wxPyEndAllowThreads(__tstate);
22788 if (PyErr_Occurred()) SWIG_fail;
22789 }
22790 {
22791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22792 }
22793 return resultobj;
22794 fail:
22795 return NULL;
22796 }
22797
22798
22799 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
22800 PyObject *resultobj;
22801 wxDateTime *arg1 = (wxDateTime *) 0 ;
22802 wxDateTime *arg2 = (wxDateTime *) 0 ;
22803 bool result;
22804 PyObject * obj0 = 0 ;
22805 PyObject * obj1 = 0 ;
22806 char *kwnames[] = {
22807 (char *) "self",(char *) "other", NULL
22808 };
22809
22810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
22811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22812 if (SWIG_arg_fail(1)) SWIG_fail;
22813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22814 if (SWIG_arg_fail(2)) SWIG_fail;
22815 {
22816 PyThreadState* __tstate = wxPyBeginAllowThreads();
22817 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
22818
22819 wxPyEndAllowThreads(__tstate);
22820 if (PyErr_Occurred()) SWIG_fail;
22821 }
22822 {
22823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22824 }
22825 return resultobj;
22826 fail:
22827 return NULL;
22828 }
22829
22830
22831 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
22832 PyObject *resultobj;
22833 wxDateTime *arg1 = (wxDateTime *) 0 ;
22834 wxDateTime *arg2 = (wxDateTime *) 0 ;
22835 bool result;
22836 PyObject * obj0 = 0 ;
22837 PyObject * obj1 = 0 ;
22838 char *kwnames[] = {
22839 (char *) "self",(char *) "other", NULL
22840 };
22841
22842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
22843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22844 if (SWIG_arg_fail(1)) SWIG_fail;
22845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22846 if (SWIG_arg_fail(2)) SWIG_fail;
22847 {
22848 PyThreadState* __tstate = wxPyBeginAllowThreads();
22849 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
22850
22851 wxPyEndAllowThreads(__tstate);
22852 if (PyErr_Occurred()) SWIG_fail;
22853 }
22854 {
22855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22856 }
22857 return resultobj;
22858 fail:
22859 return NULL;
22860 }
22861
22862
22863 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
22864 PyObject *resultobj;
22865 wxDateTime *arg1 = (wxDateTime *) 0 ;
22866 wxDateTime *arg2 = (wxDateTime *) 0 ;
22867 bool result;
22868 PyObject * obj0 = 0 ;
22869 PyObject * obj1 = 0 ;
22870 char *kwnames[] = {
22871 (char *) "self",(char *) "other", NULL
22872 };
22873
22874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
22875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22876 if (SWIG_arg_fail(1)) SWIG_fail;
22877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22878 if (SWIG_arg_fail(2)) SWIG_fail;
22879 {
22880 PyThreadState* __tstate = wxPyBeginAllowThreads();
22881 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
22882
22883 wxPyEndAllowThreads(__tstate);
22884 if (PyErr_Occurred()) SWIG_fail;
22885 }
22886 {
22887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22888 }
22889 return resultobj;
22890 fail:
22891 return NULL;
22892 }
22893
22894
22895 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
22896 PyObject *resultobj;
22897 wxDateTime *arg1 = (wxDateTime *) 0 ;
22898 wxDateTime *arg2 = (wxDateTime *) 0 ;
22899 bool result;
22900 PyObject * obj0 = 0 ;
22901 PyObject * obj1 = 0 ;
22902 char *kwnames[] = {
22903 (char *) "self",(char *) "other", NULL
22904 };
22905
22906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
22907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(1)) SWIG_fail;
22909 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22910 if (SWIG_arg_fail(2)) SWIG_fail;
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
22914
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 {
22919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22920 }
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
22928 PyObject *resultobj;
22929 wxDateTime *arg1 = (wxDateTime *) 0 ;
22930 wxString *arg2 = 0 ;
22931 int result;
22932 bool temp2 = false ;
22933 PyObject * obj0 = 0 ;
22934 PyObject * obj1 = 0 ;
22935 char *kwnames[] = {
22936 (char *) "self",(char *) "date", NULL
22937 };
22938
22939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
22940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22941 if (SWIG_arg_fail(1)) SWIG_fail;
22942 {
22943 arg2 = wxString_in_helper(obj1);
22944 if (arg2 == NULL) SWIG_fail;
22945 temp2 = true;
22946 }
22947 {
22948 PyThreadState* __tstate = wxPyBeginAllowThreads();
22949 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
22950
22951 wxPyEndAllowThreads(__tstate);
22952 if (PyErr_Occurred()) SWIG_fail;
22953 }
22954 {
22955 resultobj = SWIG_From_int((int)(result));
22956 }
22957 {
22958 if (temp2)
22959 delete arg2;
22960 }
22961 return resultobj;
22962 fail:
22963 {
22964 if (temp2)
22965 delete arg2;
22966 }
22967 return NULL;
22968 }
22969
22970
22971 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
22972 PyObject *resultobj;
22973 wxDateTime *arg1 = (wxDateTime *) 0 ;
22974 wxString *arg2 = 0 ;
22975 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
22976 wxString *arg3 = (wxString *) &arg3_defvalue ;
22977 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
22978 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
22979 int result;
22980 bool temp2 = false ;
22981 bool temp3 = false ;
22982 PyObject * obj0 = 0 ;
22983 PyObject * obj1 = 0 ;
22984 PyObject * obj2 = 0 ;
22985 PyObject * obj3 = 0 ;
22986 char *kwnames[] = {
22987 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
22988 };
22989
22990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22992 if (SWIG_arg_fail(1)) SWIG_fail;
22993 {
22994 arg2 = wxString_in_helper(obj1);
22995 if (arg2 == NULL) SWIG_fail;
22996 temp2 = true;
22997 }
22998 if (obj2) {
22999 {
23000 arg3 = wxString_in_helper(obj2);
23001 if (arg3 == NULL) SWIG_fail;
23002 temp3 = true;
23003 }
23004 }
23005 if (obj3) {
23006 {
23007 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23008 if (SWIG_arg_fail(4)) SWIG_fail;
23009 if (arg4 == NULL) {
23010 SWIG_null_ref("wxDateTime");
23011 }
23012 if (SWIG_arg_fail(4)) SWIG_fail;
23013 }
23014 }
23015 {
23016 PyThreadState* __tstate = wxPyBeginAllowThreads();
23017 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23018
23019 wxPyEndAllowThreads(__tstate);
23020 if (PyErr_Occurred()) SWIG_fail;
23021 }
23022 {
23023 resultobj = SWIG_From_int((int)(result));
23024 }
23025 {
23026 if (temp2)
23027 delete arg2;
23028 }
23029 {
23030 if (temp3)
23031 delete arg3;
23032 }
23033 return resultobj;
23034 fail:
23035 {
23036 if (temp2)
23037 delete arg2;
23038 }
23039 {
23040 if (temp3)
23041 delete arg3;
23042 }
23043 return NULL;
23044 }
23045
23046
23047 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23048 PyObject *resultobj;
23049 wxDateTime *arg1 = (wxDateTime *) 0 ;
23050 wxString *arg2 = 0 ;
23051 int result;
23052 bool temp2 = false ;
23053 PyObject * obj0 = 0 ;
23054 PyObject * obj1 = 0 ;
23055 char *kwnames[] = {
23056 (char *) "self",(char *) "datetime", NULL
23057 };
23058
23059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23061 if (SWIG_arg_fail(1)) SWIG_fail;
23062 {
23063 arg2 = wxString_in_helper(obj1);
23064 if (arg2 == NULL) SWIG_fail;
23065 temp2 = true;
23066 }
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23070
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 {
23075 resultobj = SWIG_From_int((int)(result));
23076 }
23077 {
23078 if (temp2)
23079 delete arg2;
23080 }
23081 return resultobj;
23082 fail:
23083 {
23084 if (temp2)
23085 delete arg2;
23086 }
23087 return NULL;
23088 }
23089
23090
23091 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23092 PyObject *resultobj;
23093 wxDateTime *arg1 = (wxDateTime *) 0 ;
23094 wxString *arg2 = 0 ;
23095 int result;
23096 bool temp2 = false ;
23097 PyObject * obj0 = 0 ;
23098 PyObject * obj1 = 0 ;
23099 char *kwnames[] = {
23100 (char *) "self",(char *) "date", NULL
23101 };
23102
23103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23105 if (SWIG_arg_fail(1)) SWIG_fail;
23106 {
23107 arg2 = wxString_in_helper(obj1);
23108 if (arg2 == NULL) SWIG_fail;
23109 temp2 = true;
23110 }
23111 {
23112 PyThreadState* __tstate = wxPyBeginAllowThreads();
23113 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23114
23115 wxPyEndAllowThreads(__tstate);
23116 if (PyErr_Occurred()) SWIG_fail;
23117 }
23118 {
23119 resultobj = SWIG_From_int((int)(result));
23120 }
23121 {
23122 if (temp2)
23123 delete arg2;
23124 }
23125 return resultobj;
23126 fail:
23127 {
23128 if (temp2)
23129 delete arg2;
23130 }
23131 return NULL;
23132 }
23133
23134
23135 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23136 PyObject *resultobj;
23137 wxDateTime *arg1 = (wxDateTime *) 0 ;
23138 wxString *arg2 = 0 ;
23139 int result;
23140 bool temp2 = false ;
23141 PyObject * obj0 = 0 ;
23142 PyObject * obj1 = 0 ;
23143 char *kwnames[] = {
23144 (char *) "self",(char *) "time", NULL
23145 };
23146
23147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23149 if (SWIG_arg_fail(1)) SWIG_fail;
23150 {
23151 arg2 = wxString_in_helper(obj1);
23152 if (arg2 == NULL) SWIG_fail;
23153 temp2 = true;
23154 }
23155 {
23156 PyThreadState* __tstate = wxPyBeginAllowThreads();
23157 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23158
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 {
23163 resultobj = SWIG_From_int((int)(result));
23164 }
23165 {
23166 if (temp2)
23167 delete arg2;
23168 }
23169 return resultobj;
23170 fail:
23171 {
23172 if (temp2)
23173 delete arg2;
23174 }
23175 return NULL;
23176 }
23177
23178
23179 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23180 PyObject *resultobj;
23181 wxDateTime *arg1 = (wxDateTime *) 0 ;
23182 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23183 wxString *arg2 = (wxString *) &arg2_defvalue ;
23184 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23185 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23186 wxString result;
23187 bool temp2 = false ;
23188 bool temp3 = false ;
23189 PyObject * obj0 = 0 ;
23190 PyObject * obj1 = 0 ;
23191 PyObject * obj2 = 0 ;
23192 char *kwnames[] = {
23193 (char *) "self",(char *) "format",(char *) "tz", NULL
23194 };
23195
23196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23198 if (SWIG_arg_fail(1)) SWIG_fail;
23199 if (obj1) {
23200 {
23201 arg2 = wxString_in_helper(obj1);
23202 if (arg2 == NULL) SWIG_fail;
23203 temp2 = true;
23204 }
23205 }
23206 if (obj2) {
23207 {
23208 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23209 temp3 = true;
23210 }
23211 }
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23215
23216 wxPyEndAllowThreads(__tstate);
23217 if (PyErr_Occurred()) SWIG_fail;
23218 }
23219 {
23220 #if wxUSE_UNICODE
23221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23222 #else
23223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23224 #endif
23225 }
23226 {
23227 if (temp2)
23228 delete arg2;
23229 }
23230 {
23231 if (temp3) delete arg3;
23232 }
23233 return resultobj;
23234 fail:
23235 {
23236 if (temp2)
23237 delete arg2;
23238 }
23239 {
23240 if (temp3) delete arg3;
23241 }
23242 return NULL;
23243 }
23244
23245
23246 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23247 PyObject *resultobj;
23248 wxDateTime *arg1 = (wxDateTime *) 0 ;
23249 wxString result;
23250 PyObject * obj0 = 0 ;
23251 char *kwnames[] = {
23252 (char *) "self", NULL
23253 };
23254
23255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23257 if (SWIG_arg_fail(1)) SWIG_fail;
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = ((wxDateTime const *)arg1)->FormatDate();
23261
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 {
23266 #if wxUSE_UNICODE
23267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23268 #else
23269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23270 #endif
23271 }
23272 return resultobj;
23273 fail:
23274 return NULL;
23275 }
23276
23277
23278 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23279 PyObject *resultobj;
23280 wxDateTime *arg1 = (wxDateTime *) 0 ;
23281 wxString result;
23282 PyObject * obj0 = 0 ;
23283 char *kwnames[] = {
23284 (char *) "self", NULL
23285 };
23286
23287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23289 if (SWIG_arg_fail(1)) SWIG_fail;
23290 {
23291 PyThreadState* __tstate = wxPyBeginAllowThreads();
23292 result = ((wxDateTime const *)arg1)->FormatTime();
23293
23294 wxPyEndAllowThreads(__tstate);
23295 if (PyErr_Occurred()) SWIG_fail;
23296 }
23297 {
23298 #if wxUSE_UNICODE
23299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23300 #else
23301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23302 #endif
23303 }
23304 return resultobj;
23305 fail:
23306 return NULL;
23307 }
23308
23309
23310 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23311 PyObject *resultobj;
23312 wxDateTime *arg1 = (wxDateTime *) 0 ;
23313 wxString result;
23314 PyObject * obj0 = 0 ;
23315 char *kwnames[] = {
23316 (char *) "self", NULL
23317 };
23318
23319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23321 if (SWIG_arg_fail(1)) SWIG_fail;
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 result = ((wxDateTime const *)arg1)->FormatISODate();
23325
23326 wxPyEndAllowThreads(__tstate);
23327 if (PyErr_Occurred()) SWIG_fail;
23328 }
23329 {
23330 #if wxUSE_UNICODE
23331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23332 #else
23333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23334 #endif
23335 }
23336 return resultobj;
23337 fail:
23338 return NULL;
23339 }
23340
23341
23342 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23343 PyObject *resultobj;
23344 wxDateTime *arg1 = (wxDateTime *) 0 ;
23345 wxString result;
23346 PyObject * obj0 = 0 ;
23347 char *kwnames[] = {
23348 (char *) "self", NULL
23349 };
23350
23351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23353 if (SWIG_arg_fail(1)) SWIG_fail;
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 result = ((wxDateTime const *)arg1)->FormatISOTime();
23357
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 {
23362 #if wxUSE_UNICODE
23363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23364 #else
23365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23366 #endif
23367 }
23368 return resultobj;
23369 fail:
23370 return NULL;
23371 }
23372
23373
23374 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23375 PyObject *obj;
23376 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23377 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23378 Py_INCREF(obj);
23379 return Py_BuildValue((char *)"");
23380 }
23381 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23382 PyObject *resultobj;
23383 long arg1 ;
23384 wxTimeSpan result;
23385 PyObject * obj0 = 0 ;
23386 char *kwnames[] = {
23387 (char *) "sec", NULL
23388 };
23389
23390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23391 {
23392 arg1 = (long)(SWIG_As_long(obj0));
23393 if (SWIG_arg_fail(1)) SWIG_fail;
23394 }
23395 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 result = wxTimeSpan::Seconds(arg1);
23398
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 {
23403 wxTimeSpan * resultptr;
23404 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23406 }
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23414 PyObject *resultobj;
23415 wxTimeSpan result;
23416 char *kwnames[] = {
23417 NULL
23418 };
23419
23420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23421 {
23422 PyThreadState* __tstate = wxPyBeginAllowThreads();
23423 result = wxTimeSpan::Second();
23424
23425 wxPyEndAllowThreads(__tstate);
23426 if (PyErr_Occurred()) SWIG_fail;
23427 }
23428 {
23429 wxTimeSpan * resultptr;
23430 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23431 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23432 }
23433 return resultobj;
23434 fail:
23435 return NULL;
23436 }
23437
23438
23439 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23440 PyObject *resultobj;
23441 long arg1 ;
23442 wxTimeSpan result;
23443 PyObject * obj0 = 0 ;
23444 char *kwnames[] = {
23445 (char *) "min", NULL
23446 };
23447
23448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23449 {
23450 arg1 = (long)(SWIG_As_long(obj0));
23451 if (SWIG_arg_fail(1)) SWIG_fail;
23452 }
23453 {
23454 PyThreadState* __tstate = wxPyBeginAllowThreads();
23455 result = wxTimeSpan::Minutes(arg1);
23456
23457 wxPyEndAllowThreads(__tstate);
23458 if (PyErr_Occurred()) SWIG_fail;
23459 }
23460 {
23461 wxTimeSpan * resultptr;
23462 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23463 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23464 }
23465 return resultobj;
23466 fail:
23467 return NULL;
23468 }
23469
23470
23471 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23472 PyObject *resultobj;
23473 wxTimeSpan result;
23474 char *kwnames[] = {
23475 NULL
23476 };
23477
23478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23479 {
23480 PyThreadState* __tstate = wxPyBeginAllowThreads();
23481 result = wxTimeSpan::Minute();
23482
23483 wxPyEndAllowThreads(__tstate);
23484 if (PyErr_Occurred()) SWIG_fail;
23485 }
23486 {
23487 wxTimeSpan * resultptr;
23488 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23489 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23490 }
23491 return resultobj;
23492 fail:
23493 return NULL;
23494 }
23495
23496
23497 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23498 PyObject *resultobj;
23499 long arg1 ;
23500 wxTimeSpan result;
23501 PyObject * obj0 = 0 ;
23502 char *kwnames[] = {
23503 (char *) "hours", NULL
23504 };
23505
23506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23507 {
23508 arg1 = (long)(SWIG_As_long(obj0));
23509 if (SWIG_arg_fail(1)) SWIG_fail;
23510 }
23511 {
23512 PyThreadState* __tstate = wxPyBeginAllowThreads();
23513 result = wxTimeSpan::Hours(arg1);
23514
23515 wxPyEndAllowThreads(__tstate);
23516 if (PyErr_Occurred()) SWIG_fail;
23517 }
23518 {
23519 wxTimeSpan * resultptr;
23520 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23522 }
23523 return resultobj;
23524 fail:
23525 return NULL;
23526 }
23527
23528
23529 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23530 PyObject *resultobj;
23531 wxTimeSpan result;
23532 char *kwnames[] = {
23533 NULL
23534 };
23535
23536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23537 {
23538 PyThreadState* __tstate = wxPyBeginAllowThreads();
23539 result = wxTimeSpan::Hour();
23540
23541 wxPyEndAllowThreads(__tstate);
23542 if (PyErr_Occurred()) SWIG_fail;
23543 }
23544 {
23545 wxTimeSpan * resultptr;
23546 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23548 }
23549 return resultobj;
23550 fail:
23551 return NULL;
23552 }
23553
23554
23555 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23556 PyObject *resultobj;
23557 long arg1 ;
23558 wxTimeSpan result;
23559 PyObject * obj0 = 0 ;
23560 char *kwnames[] = {
23561 (char *) "days", NULL
23562 };
23563
23564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23565 {
23566 arg1 = (long)(SWIG_As_long(obj0));
23567 if (SWIG_arg_fail(1)) SWIG_fail;
23568 }
23569 {
23570 PyThreadState* __tstate = wxPyBeginAllowThreads();
23571 result = wxTimeSpan::Days(arg1);
23572
23573 wxPyEndAllowThreads(__tstate);
23574 if (PyErr_Occurred()) SWIG_fail;
23575 }
23576 {
23577 wxTimeSpan * resultptr;
23578 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23580 }
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23588 PyObject *resultobj;
23589 wxTimeSpan result;
23590 char *kwnames[] = {
23591 NULL
23592 };
23593
23594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23595 {
23596 PyThreadState* __tstate = wxPyBeginAllowThreads();
23597 result = wxTimeSpan::Day();
23598
23599 wxPyEndAllowThreads(__tstate);
23600 if (PyErr_Occurred()) SWIG_fail;
23601 }
23602 {
23603 wxTimeSpan * resultptr;
23604 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23606 }
23607 return resultobj;
23608 fail:
23609 return NULL;
23610 }
23611
23612
23613 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23614 PyObject *resultobj;
23615 long arg1 ;
23616 wxTimeSpan result;
23617 PyObject * obj0 = 0 ;
23618 char *kwnames[] = {
23619 (char *) "days", NULL
23620 };
23621
23622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23623 {
23624 arg1 = (long)(SWIG_As_long(obj0));
23625 if (SWIG_arg_fail(1)) SWIG_fail;
23626 }
23627 {
23628 PyThreadState* __tstate = wxPyBeginAllowThreads();
23629 result = wxTimeSpan::Weeks(arg1);
23630
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 {
23635 wxTimeSpan * resultptr;
23636 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23638 }
23639 return resultobj;
23640 fail:
23641 return NULL;
23642 }
23643
23644
23645 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23646 PyObject *resultobj;
23647 wxTimeSpan result;
23648 char *kwnames[] = {
23649 NULL
23650 };
23651
23652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23653 {
23654 PyThreadState* __tstate = wxPyBeginAllowThreads();
23655 result = wxTimeSpan::Week();
23656
23657 wxPyEndAllowThreads(__tstate);
23658 if (PyErr_Occurred()) SWIG_fail;
23659 }
23660 {
23661 wxTimeSpan * resultptr;
23662 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23663 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23664 }
23665 return resultobj;
23666 fail:
23667 return NULL;
23668 }
23669
23670
23671 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23672 PyObject *resultobj;
23673 long arg1 = (long) 0 ;
23674 long arg2 = (long) 0 ;
23675 long arg3 = (long) 0 ;
23676 long arg4 = (long) 0 ;
23677 wxTimeSpan *result;
23678 PyObject * obj0 = 0 ;
23679 PyObject * obj1 = 0 ;
23680 PyObject * obj2 = 0 ;
23681 PyObject * obj3 = 0 ;
23682 char *kwnames[] = {
23683 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23684 };
23685
23686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23687 if (obj0) {
23688 {
23689 arg1 = (long)(SWIG_As_long(obj0));
23690 if (SWIG_arg_fail(1)) SWIG_fail;
23691 }
23692 }
23693 if (obj1) {
23694 {
23695 arg2 = (long)(SWIG_As_long(obj1));
23696 if (SWIG_arg_fail(2)) SWIG_fail;
23697 }
23698 }
23699 if (obj2) {
23700 {
23701 arg3 = (long)(SWIG_As_long(obj2));
23702 if (SWIG_arg_fail(3)) SWIG_fail;
23703 }
23704 }
23705 if (obj3) {
23706 {
23707 arg4 = (long)(SWIG_As_long(obj3));
23708 if (SWIG_arg_fail(4)) SWIG_fail;
23709 }
23710 }
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23714
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23719 return resultobj;
23720 fail:
23721 return NULL;
23722 }
23723
23724
23725 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23726 PyObject *resultobj;
23727 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23728 PyObject * obj0 = 0 ;
23729 char *kwnames[] = {
23730 (char *) "self", NULL
23731 };
23732
23733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23735 if (SWIG_arg_fail(1)) SWIG_fail;
23736 {
23737 PyThreadState* __tstate = wxPyBeginAllowThreads();
23738 delete arg1;
23739
23740 wxPyEndAllowThreads(__tstate);
23741 if (PyErr_Occurred()) SWIG_fail;
23742 }
23743 Py_INCREF(Py_None); resultobj = Py_None;
23744 return resultobj;
23745 fail:
23746 return NULL;
23747 }
23748
23749
23750 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23751 PyObject *resultobj;
23752 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23753 wxTimeSpan *arg2 = 0 ;
23754 wxTimeSpan *result;
23755 PyObject * obj0 = 0 ;
23756 PyObject * obj1 = 0 ;
23757 char *kwnames[] = {
23758 (char *) "self",(char *) "diff", NULL
23759 };
23760
23761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23763 if (SWIG_arg_fail(1)) SWIG_fail;
23764 {
23765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23766 if (SWIG_arg_fail(2)) SWIG_fail;
23767 if (arg2 == NULL) {
23768 SWIG_null_ref("wxTimeSpan");
23769 }
23770 if (SWIG_arg_fail(2)) SWIG_fail;
23771 }
23772 {
23773 PyThreadState* __tstate = wxPyBeginAllowThreads();
23774 {
23775 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23776 result = (wxTimeSpan *) &_result_ref;
23777 }
23778
23779 wxPyEndAllowThreads(__tstate);
23780 if (PyErr_Occurred()) SWIG_fail;
23781 }
23782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23783 return resultobj;
23784 fail:
23785 return NULL;
23786 }
23787
23788
23789 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23790 PyObject *resultobj;
23791 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23792 wxTimeSpan *arg2 = 0 ;
23793 wxTimeSpan *result;
23794 PyObject * obj0 = 0 ;
23795 PyObject * obj1 = 0 ;
23796 char *kwnames[] = {
23797 (char *) "self",(char *) "diff", NULL
23798 };
23799
23800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
23801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23802 if (SWIG_arg_fail(1)) SWIG_fail;
23803 {
23804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23805 if (SWIG_arg_fail(2)) SWIG_fail;
23806 if (arg2 == NULL) {
23807 SWIG_null_ref("wxTimeSpan");
23808 }
23809 if (SWIG_arg_fail(2)) SWIG_fail;
23810 }
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 {
23814 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23815 result = (wxTimeSpan *) &_result_ref;
23816 }
23817
23818 wxPyEndAllowThreads(__tstate);
23819 if (PyErr_Occurred()) SWIG_fail;
23820 }
23821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23822 return resultobj;
23823 fail:
23824 return NULL;
23825 }
23826
23827
23828 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
23829 PyObject *resultobj;
23830 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23831 int arg2 ;
23832 wxTimeSpan *result;
23833 PyObject * obj0 = 0 ;
23834 PyObject * obj1 = 0 ;
23835 char *kwnames[] = {
23836 (char *) "self",(char *) "n", NULL
23837 };
23838
23839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
23840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23841 if (SWIG_arg_fail(1)) SWIG_fail;
23842 {
23843 arg2 = (int)(SWIG_As_int(obj1));
23844 if (SWIG_arg_fail(2)) SWIG_fail;
23845 }
23846 {
23847 PyThreadState* __tstate = wxPyBeginAllowThreads();
23848 {
23849 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
23850 result = (wxTimeSpan *) &_result_ref;
23851 }
23852
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23857 return resultobj;
23858 fail:
23859 return NULL;
23860 }
23861
23862
23863 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
23864 PyObject *resultobj;
23865 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23866 wxTimeSpan *result;
23867 PyObject * obj0 = 0 ;
23868 char *kwnames[] = {
23869 (char *) "self", NULL
23870 };
23871
23872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
23873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23874 if (SWIG_arg_fail(1)) SWIG_fail;
23875 {
23876 PyThreadState* __tstate = wxPyBeginAllowThreads();
23877 {
23878 wxTimeSpan &_result_ref = (arg1)->Neg();
23879 result = (wxTimeSpan *) &_result_ref;
23880 }
23881
23882 wxPyEndAllowThreads(__tstate);
23883 if (PyErr_Occurred()) SWIG_fail;
23884 }
23885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23886 return resultobj;
23887 fail:
23888 return NULL;
23889 }
23890
23891
23892 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj;
23894 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23895 wxTimeSpan result;
23896 PyObject * obj0 = 0 ;
23897 char *kwnames[] = {
23898 (char *) "self", NULL
23899 };
23900
23901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
23902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23903 if (SWIG_arg_fail(1)) SWIG_fail;
23904 {
23905 PyThreadState* __tstate = wxPyBeginAllowThreads();
23906 result = ((wxTimeSpan const *)arg1)->Abs();
23907
23908 wxPyEndAllowThreads(__tstate);
23909 if (PyErr_Occurred()) SWIG_fail;
23910 }
23911 {
23912 wxTimeSpan * resultptr;
23913 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23914 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23915 }
23916 return resultobj;
23917 fail:
23918 return NULL;
23919 }
23920
23921
23922 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
23923 PyObject *resultobj;
23924 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23925 wxTimeSpan *arg2 = 0 ;
23926 wxTimeSpan *result;
23927 PyObject * obj0 = 0 ;
23928 PyObject * obj1 = 0 ;
23929 char *kwnames[] = {
23930 (char *) "self",(char *) "diff", NULL
23931 };
23932
23933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
23934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23935 if (SWIG_arg_fail(1)) SWIG_fail;
23936 {
23937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23938 if (SWIG_arg_fail(2)) SWIG_fail;
23939 if (arg2 == NULL) {
23940 SWIG_null_ref("wxTimeSpan");
23941 }
23942 if (SWIG_arg_fail(2)) SWIG_fail;
23943 }
23944 {
23945 PyThreadState* __tstate = wxPyBeginAllowThreads();
23946 {
23947 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23948 result = (wxTimeSpan *) &_result_ref;
23949 }
23950
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
23962 PyObject *resultobj;
23963 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23964 wxTimeSpan *arg2 = 0 ;
23965 wxTimeSpan *result;
23966 PyObject * obj0 = 0 ;
23967 PyObject * obj1 = 0 ;
23968 char *kwnames[] = {
23969 (char *) "self",(char *) "diff", NULL
23970 };
23971
23972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
23973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23974 if (SWIG_arg_fail(1)) SWIG_fail;
23975 {
23976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23977 if (SWIG_arg_fail(2)) SWIG_fail;
23978 if (arg2 == NULL) {
23979 SWIG_null_ref("wxTimeSpan");
23980 }
23981 if (SWIG_arg_fail(2)) SWIG_fail;
23982 }
23983 {
23984 PyThreadState* __tstate = wxPyBeginAllowThreads();
23985 {
23986 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23987 result = (wxTimeSpan *) &_result_ref;
23988 }
23989
23990 wxPyEndAllowThreads(__tstate);
23991 if (PyErr_Occurred()) SWIG_fail;
23992 }
23993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23994 return resultobj;
23995 fail:
23996 return NULL;
23997 }
23998
23999
24000 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24001 PyObject *resultobj;
24002 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24003 int arg2 ;
24004 wxTimeSpan *result;
24005 PyObject * obj0 = 0 ;
24006 PyObject * obj1 = 0 ;
24007 char *kwnames[] = {
24008 (char *) "self",(char *) "n", NULL
24009 };
24010
24011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24013 if (SWIG_arg_fail(1)) SWIG_fail;
24014 {
24015 arg2 = (int)(SWIG_As_int(obj1));
24016 if (SWIG_arg_fail(2)) SWIG_fail;
24017 }
24018 {
24019 PyThreadState* __tstate = wxPyBeginAllowThreads();
24020 {
24021 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24022 result = (wxTimeSpan *) &_result_ref;
24023 }
24024
24025 wxPyEndAllowThreads(__tstate);
24026 if (PyErr_Occurred()) SWIG_fail;
24027 }
24028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24029 return resultobj;
24030 fail:
24031 return NULL;
24032 }
24033
24034
24035 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24036 PyObject *resultobj;
24037 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24038 wxTimeSpan *result;
24039 PyObject * obj0 = 0 ;
24040 char *kwnames[] = {
24041 (char *) "self", NULL
24042 };
24043
24044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24046 if (SWIG_arg_fail(1)) SWIG_fail;
24047 {
24048 PyThreadState* __tstate = wxPyBeginAllowThreads();
24049 {
24050 wxTimeSpan &_result_ref = (arg1)->operator -();
24051 result = (wxTimeSpan *) &_result_ref;
24052 }
24053
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24065 PyObject *resultobj;
24066 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24067 wxTimeSpan *arg2 = 0 ;
24068 wxTimeSpan result;
24069 PyObject * obj0 = 0 ;
24070 PyObject * obj1 = 0 ;
24071 char *kwnames[] = {
24072 (char *) "self",(char *) "other", NULL
24073 };
24074
24075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24077 if (SWIG_arg_fail(1)) SWIG_fail;
24078 {
24079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24080 if (SWIG_arg_fail(2)) SWIG_fail;
24081 if (arg2 == NULL) {
24082 SWIG_null_ref("wxTimeSpan");
24083 }
24084 if (SWIG_arg_fail(2)) SWIG_fail;
24085 }
24086 {
24087 PyThreadState* __tstate = wxPyBeginAllowThreads();
24088 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24089
24090 wxPyEndAllowThreads(__tstate);
24091 if (PyErr_Occurred()) SWIG_fail;
24092 }
24093 {
24094 wxTimeSpan * resultptr;
24095 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24097 }
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24105 PyObject *resultobj;
24106 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24107 wxTimeSpan *arg2 = 0 ;
24108 wxTimeSpan result;
24109 PyObject * obj0 = 0 ;
24110 PyObject * obj1 = 0 ;
24111 char *kwnames[] = {
24112 (char *) "self",(char *) "other", NULL
24113 };
24114
24115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24117 if (SWIG_arg_fail(1)) SWIG_fail;
24118 {
24119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24120 if (SWIG_arg_fail(2)) SWIG_fail;
24121 if (arg2 == NULL) {
24122 SWIG_null_ref("wxTimeSpan");
24123 }
24124 if (SWIG_arg_fail(2)) SWIG_fail;
24125 }
24126 {
24127 PyThreadState* __tstate = wxPyBeginAllowThreads();
24128 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24129
24130 wxPyEndAllowThreads(__tstate);
24131 if (PyErr_Occurred()) SWIG_fail;
24132 }
24133 {
24134 wxTimeSpan * resultptr;
24135 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24137 }
24138 return resultobj;
24139 fail:
24140 return NULL;
24141 }
24142
24143
24144 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24145 PyObject *resultobj;
24146 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24147 int arg2 ;
24148 wxTimeSpan result;
24149 PyObject * obj0 = 0 ;
24150 PyObject * obj1 = 0 ;
24151 char *kwnames[] = {
24152 (char *) "self",(char *) "n", NULL
24153 };
24154
24155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24157 if (SWIG_arg_fail(1)) SWIG_fail;
24158 {
24159 arg2 = (int)(SWIG_As_int(obj1));
24160 if (SWIG_arg_fail(2)) SWIG_fail;
24161 }
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 result = wxTimeSpan___mul__(arg1,arg2);
24165
24166 wxPyEndAllowThreads(__tstate);
24167 if (PyErr_Occurred()) SWIG_fail;
24168 }
24169 {
24170 wxTimeSpan * resultptr;
24171 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24173 }
24174 return resultobj;
24175 fail:
24176 return NULL;
24177 }
24178
24179
24180 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24181 PyObject *resultobj;
24182 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24183 int arg2 ;
24184 wxTimeSpan result;
24185 PyObject * obj0 = 0 ;
24186 PyObject * obj1 = 0 ;
24187 char *kwnames[] = {
24188 (char *) "self",(char *) "n", NULL
24189 };
24190
24191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24193 if (SWIG_arg_fail(1)) SWIG_fail;
24194 {
24195 arg2 = (int)(SWIG_As_int(obj1));
24196 if (SWIG_arg_fail(2)) SWIG_fail;
24197 }
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 result = wxTimeSpan___rmul__(arg1,arg2);
24201
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 {
24206 wxTimeSpan * resultptr;
24207 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24208 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24209 }
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24217 PyObject *resultobj;
24218 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24219 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24220 bool result;
24221 PyObject * obj0 = 0 ;
24222 PyObject * obj1 = 0 ;
24223 char *kwnames[] = {
24224 (char *) "self",(char *) "other", NULL
24225 };
24226
24227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24229 if (SWIG_arg_fail(1)) SWIG_fail;
24230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24231 if (SWIG_arg_fail(2)) SWIG_fail;
24232 {
24233 PyThreadState* __tstate = wxPyBeginAllowThreads();
24234 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24235
24236 wxPyEndAllowThreads(__tstate);
24237 if (PyErr_Occurred()) SWIG_fail;
24238 }
24239 {
24240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24241 }
24242 return resultobj;
24243 fail:
24244 return NULL;
24245 }
24246
24247
24248 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24249 PyObject *resultobj;
24250 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24251 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24252 bool result;
24253 PyObject * obj0 = 0 ;
24254 PyObject * obj1 = 0 ;
24255 char *kwnames[] = {
24256 (char *) "self",(char *) "other", NULL
24257 };
24258
24259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24261 if (SWIG_arg_fail(1)) SWIG_fail;
24262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24263 if (SWIG_arg_fail(2)) SWIG_fail;
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24267
24268 wxPyEndAllowThreads(__tstate);
24269 if (PyErr_Occurred()) SWIG_fail;
24270 }
24271 {
24272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24273 }
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24281 PyObject *resultobj;
24282 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24283 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24284 bool result;
24285 PyObject * obj0 = 0 ;
24286 PyObject * obj1 = 0 ;
24287 char *kwnames[] = {
24288 (char *) "self",(char *) "other", NULL
24289 };
24290
24291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24293 if (SWIG_arg_fail(1)) SWIG_fail;
24294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24295 if (SWIG_arg_fail(2)) SWIG_fail;
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24299
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 {
24304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24305 }
24306 return resultobj;
24307 fail:
24308 return NULL;
24309 }
24310
24311
24312 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24313 PyObject *resultobj;
24314 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24315 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24316 bool result;
24317 PyObject * obj0 = 0 ;
24318 PyObject * obj1 = 0 ;
24319 char *kwnames[] = {
24320 (char *) "self",(char *) "other", NULL
24321 };
24322
24323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24325 if (SWIG_arg_fail(1)) SWIG_fail;
24326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24327 if (SWIG_arg_fail(2)) SWIG_fail;
24328 {
24329 PyThreadState* __tstate = wxPyBeginAllowThreads();
24330 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24331
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 {
24336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24337 }
24338 return resultobj;
24339 fail:
24340 return NULL;
24341 }
24342
24343
24344 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24345 PyObject *resultobj;
24346 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24347 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24348 bool result;
24349 PyObject * obj0 = 0 ;
24350 PyObject * obj1 = 0 ;
24351 char *kwnames[] = {
24352 (char *) "self",(char *) "other", NULL
24353 };
24354
24355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24357 if (SWIG_arg_fail(1)) SWIG_fail;
24358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24359 if (SWIG_arg_fail(2)) SWIG_fail;
24360 {
24361 PyThreadState* __tstate = wxPyBeginAllowThreads();
24362 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24363
24364 wxPyEndAllowThreads(__tstate);
24365 if (PyErr_Occurred()) SWIG_fail;
24366 }
24367 {
24368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24369 }
24370 return resultobj;
24371 fail:
24372 return NULL;
24373 }
24374
24375
24376 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24377 PyObject *resultobj;
24378 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24379 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24380 bool result;
24381 PyObject * obj0 = 0 ;
24382 PyObject * obj1 = 0 ;
24383 char *kwnames[] = {
24384 (char *) "self",(char *) "other", NULL
24385 };
24386
24387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24389 if (SWIG_arg_fail(1)) SWIG_fail;
24390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24391 if (SWIG_arg_fail(2)) SWIG_fail;
24392 {
24393 PyThreadState* __tstate = wxPyBeginAllowThreads();
24394 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24395
24396 wxPyEndAllowThreads(__tstate);
24397 if (PyErr_Occurred()) SWIG_fail;
24398 }
24399 {
24400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24401 }
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj;
24410 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24411 bool result;
24412 PyObject * obj0 = 0 ;
24413 char *kwnames[] = {
24414 (char *) "self", NULL
24415 };
24416
24417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24419 if (SWIG_arg_fail(1)) SWIG_fail;
24420 {
24421 PyThreadState* __tstate = wxPyBeginAllowThreads();
24422 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24423
24424 wxPyEndAllowThreads(__tstate);
24425 if (PyErr_Occurred()) SWIG_fail;
24426 }
24427 {
24428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24429 }
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24437 PyObject *resultobj;
24438 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24439 bool result;
24440 PyObject * obj0 = 0 ;
24441 char *kwnames[] = {
24442 (char *) "self", NULL
24443 };
24444
24445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24447 if (SWIG_arg_fail(1)) SWIG_fail;
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24451
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 {
24456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24457 }
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24465 PyObject *resultobj;
24466 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24467 bool result;
24468 PyObject * obj0 = 0 ;
24469 char *kwnames[] = {
24470 (char *) "self", NULL
24471 };
24472
24473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24475 if (SWIG_arg_fail(1)) SWIG_fail;
24476 {
24477 PyThreadState* __tstate = wxPyBeginAllowThreads();
24478 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24479
24480 wxPyEndAllowThreads(__tstate);
24481 if (PyErr_Occurred()) SWIG_fail;
24482 }
24483 {
24484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24485 }
24486 return resultobj;
24487 fail:
24488 return NULL;
24489 }
24490
24491
24492 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24493 PyObject *resultobj;
24494 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24495 wxTimeSpan *arg2 = 0 ;
24496 bool result;
24497 PyObject * obj0 = 0 ;
24498 PyObject * obj1 = 0 ;
24499 char *kwnames[] = {
24500 (char *) "self",(char *) "ts", NULL
24501 };
24502
24503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24505 if (SWIG_arg_fail(1)) SWIG_fail;
24506 {
24507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24508 if (SWIG_arg_fail(2)) SWIG_fail;
24509 if (arg2 == NULL) {
24510 SWIG_null_ref("wxTimeSpan");
24511 }
24512 if (SWIG_arg_fail(2)) SWIG_fail;
24513 }
24514 {
24515 PyThreadState* __tstate = wxPyBeginAllowThreads();
24516 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24517
24518 wxPyEndAllowThreads(__tstate);
24519 if (PyErr_Occurred()) SWIG_fail;
24520 }
24521 {
24522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24523 }
24524 return resultobj;
24525 fail:
24526 return NULL;
24527 }
24528
24529
24530 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24531 PyObject *resultobj;
24532 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24533 wxTimeSpan *arg2 = 0 ;
24534 bool result;
24535 PyObject * obj0 = 0 ;
24536 PyObject * obj1 = 0 ;
24537 char *kwnames[] = {
24538 (char *) "self",(char *) "ts", NULL
24539 };
24540
24541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24543 if (SWIG_arg_fail(1)) SWIG_fail;
24544 {
24545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24546 if (SWIG_arg_fail(2)) SWIG_fail;
24547 if (arg2 == NULL) {
24548 SWIG_null_ref("wxTimeSpan");
24549 }
24550 if (SWIG_arg_fail(2)) SWIG_fail;
24551 }
24552 {
24553 PyThreadState* __tstate = wxPyBeginAllowThreads();
24554 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24555
24556 wxPyEndAllowThreads(__tstate);
24557 if (PyErr_Occurred()) SWIG_fail;
24558 }
24559 {
24560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24561 }
24562 return resultobj;
24563 fail:
24564 return NULL;
24565 }
24566
24567
24568 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24569 PyObject *resultobj;
24570 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24571 wxTimeSpan *arg2 = 0 ;
24572 bool result;
24573 PyObject * obj0 = 0 ;
24574 PyObject * obj1 = 0 ;
24575 char *kwnames[] = {
24576 (char *) "self",(char *) "t", NULL
24577 };
24578
24579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24581 if (SWIG_arg_fail(1)) SWIG_fail;
24582 {
24583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24584 if (SWIG_arg_fail(2)) SWIG_fail;
24585 if (arg2 == NULL) {
24586 SWIG_null_ref("wxTimeSpan");
24587 }
24588 if (SWIG_arg_fail(2)) SWIG_fail;
24589 }
24590 {
24591 PyThreadState* __tstate = wxPyBeginAllowThreads();
24592 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24593
24594 wxPyEndAllowThreads(__tstate);
24595 if (PyErr_Occurred()) SWIG_fail;
24596 }
24597 {
24598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24599 }
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24607 PyObject *resultobj;
24608 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24609 int result;
24610 PyObject * obj0 = 0 ;
24611 char *kwnames[] = {
24612 (char *) "self", NULL
24613 };
24614
24615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24617 if (SWIG_arg_fail(1)) SWIG_fail;
24618 {
24619 PyThreadState* __tstate = wxPyBeginAllowThreads();
24620 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24621
24622 wxPyEndAllowThreads(__tstate);
24623 if (PyErr_Occurred()) SWIG_fail;
24624 }
24625 {
24626 resultobj = SWIG_From_int((int)(result));
24627 }
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24635 PyObject *resultobj;
24636 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24637 int result;
24638 PyObject * obj0 = 0 ;
24639 char *kwnames[] = {
24640 (char *) "self", NULL
24641 };
24642
24643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24645 if (SWIG_arg_fail(1)) SWIG_fail;
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24649
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 {
24654 resultobj = SWIG_From_int((int)(result));
24655 }
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj;
24664 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24665 int result;
24666 PyObject * obj0 = 0 ;
24667 char *kwnames[] = {
24668 (char *) "self", NULL
24669 };
24670
24671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24673 if (SWIG_arg_fail(1)) SWIG_fail;
24674 {
24675 PyThreadState* __tstate = wxPyBeginAllowThreads();
24676 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24677
24678 wxPyEndAllowThreads(__tstate);
24679 if (PyErr_Occurred()) SWIG_fail;
24680 }
24681 {
24682 resultobj = SWIG_From_int((int)(result));
24683 }
24684 return resultobj;
24685 fail:
24686 return NULL;
24687 }
24688
24689
24690 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24691 PyObject *resultobj;
24692 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24693 int result;
24694 PyObject * obj0 = 0 ;
24695 char *kwnames[] = {
24696 (char *) "self", NULL
24697 };
24698
24699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24701 if (SWIG_arg_fail(1)) SWIG_fail;
24702 {
24703 PyThreadState* __tstate = wxPyBeginAllowThreads();
24704 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24705
24706 wxPyEndAllowThreads(__tstate);
24707 if (PyErr_Occurred()) SWIG_fail;
24708 }
24709 {
24710 resultobj = SWIG_From_int((int)(result));
24711 }
24712 return resultobj;
24713 fail:
24714 return NULL;
24715 }
24716
24717
24718 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24719 PyObject *resultobj;
24720 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24721 wxLongLong result;
24722 PyObject * obj0 = 0 ;
24723 char *kwnames[] = {
24724 (char *) "self", NULL
24725 };
24726
24727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24729 if (SWIG_arg_fail(1)) SWIG_fail;
24730 {
24731 PyThreadState* __tstate = wxPyBeginAllowThreads();
24732 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24733
24734 wxPyEndAllowThreads(__tstate);
24735 if (PyErr_Occurred()) SWIG_fail;
24736 }
24737 {
24738 PyObject *hi, *lo, *shifter, *shifted;
24739 hi = PyLong_FromLong( (&result)->GetHi() );
24740 lo = PyLong_FromLong( (&result)->GetLo() );
24741 shifter = PyLong_FromLong(32);
24742 shifted = PyNumber_Lshift(hi, shifter);
24743 resultobj = PyNumber_Or(shifted, lo);
24744 Py_DECREF(hi);
24745 Py_DECREF(lo);
24746 Py_DECREF(shifter);
24747 Py_DECREF(shifted);
24748 }
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj;
24757 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24758 wxLongLong result;
24759 PyObject * obj0 = 0 ;
24760 char *kwnames[] = {
24761 (char *) "self", NULL
24762 };
24763
24764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24766 if (SWIG_arg_fail(1)) SWIG_fail;
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24770
24771 wxPyEndAllowThreads(__tstate);
24772 if (PyErr_Occurred()) SWIG_fail;
24773 }
24774 {
24775 PyObject *hi, *lo, *shifter, *shifted;
24776 hi = PyLong_FromLong( (&result)->GetHi() );
24777 lo = PyLong_FromLong( (&result)->GetLo() );
24778 shifter = PyLong_FromLong(32);
24779 shifted = PyNumber_Lshift(hi, shifter);
24780 resultobj = PyNumber_Or(shifted, lo);
24781 Py_DECREF(hi);
24782 Py_DECREF(lo);
24783 Py_DECREF(shifter);
24784 Py_DECREF(shifted);
24785 }
24786 return resultobj;
24787 fail:
24788 return NULL;
24789 }
24790
24791
24792 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24793 PyObject *resultobj;
24794 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24795 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
24796 wxString *arg2 = (wxString *) &arg2_defvalue ;
24797 wxString result;
24798 bool temp2 = false ;
24799 PyObject * obj0 = 0 ;
24800 PyObject * obj1 = 0 ;
24801 char *kwnames[] = {
24802 (char *) "self",(char *) "format", NULL
24803 };
24804
24805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
24806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24807 if (SWIG_arg_fail(1)) SWIG_fail;
24808 if (obj1) {
24809 {
24810 arg2 = wxString_in_helper(obj1);
24811 if (arg2 == NULL) SWIG_fail;
24812 temp2 = true;
24813 }
24814 }
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 {
24823 #if wxUSE_UNICODE
24824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24825 #else
24826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24827 #endif
24828 }
24829 {
24830 if (temp2)
24831 delete arg2;
24832 }
24833 return resultobj;
24834 fail:
24835 {
24836 if (temp2)
24837 delete arg2;
24838 }
24839 return NULL;
24840 }
24841
24842
24843 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
24844 PyObject *obj;
24845 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24846 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
24847 Py_INCREF(obj);
24848 return Py_BuildValue((char *)"");
24849 }
24850 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj;
24852 int arg1 = (int) 0 ;
24853 int arg2 = (int) 0 ;
24854 int arg3 = (int) 0 ;
24855 int arg4 = (int) 0 ;
24856 wxDateSpan *result;
24857 PyObject * obj0 = 0 ;
24858 PyObject * obj1 = 0 ;
24859 PyObject * obj2 = 0 ;
24860 PyObject * obj3 = 0 ;
24861 char *kwnames[] = {
24862 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
24863 };
24864
24865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24866 if (obj0) {
24867 {
24868 arg1 = (int)(SWIG_As_int(obj0));
24869 if (SWIG_arg_fail(1)) SWIG_fail;
24870 }
24871 }
24872 if (obj1) {
24873 {
24874 arg2 = (int)(SWIG_As_int(obj1));
24875 if (SWIG_arg_fail(2)) SWIG_fail;
24876 }
24877 }
24878 if (obj2) {
24879 {
24880 arg3 = (int)(SWIG_As_int(obj2));
24881 if (SWIG_arg_fail(3)) SWIG_fail;
24882 }
24883 }
24884 if (obj3) {
24885 {
24886 arg4 = (int)(SWIG_As_int(obj3));
24887 if (SWIG_arg_fail(4)) SWIG_fail;
24888 }
24889 }
24890 {
24891 PyThreadState* __tstate = wxPyBeginAllowThreads();
24892 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
24893
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24905 PyObject *resultobj;
24906 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
24907 PyObject * obj0 = 0 ;
24908 char *kwnames[] = {
24909 (char *) "self", NULL
24910 };
24911
24912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
24913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24914 if (SWIG_arg_fail(1)) SWIG_fail;
24915 {
24916 PyThreadState* __tstate = wxPyBeginAllowThreads();
24917 delete arg1;
24918
24919 wxPyEndAllowThreads(__tstate);
24920 if (PyErr_Occurred()) SWIG_fail;
24921 }
24922 Py_INCREF(Py_None); resultobj = Py_None;
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj;
24931 int arg1 ;
24932 wxDateSpan result;
24933 PyObject * obj0 = 0 ;
24934 char *kwnames[] = {
24935 (char *) "days", NULL
24936 };
24937
24938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
24939 {
24940 arg1 = (int)(SWIG_As_int(obj0));
24941 if (SWIG_arg_fail(1)) SWIG_fail;
24942 }
24943 {
24944 PyThreadState* __tstate = wxPyBeginAllowThreads();
24945 result = wxDateSpan::Days(arg1);
24946
24947 wxPyEndAllowThreads(__tstate);
24948 if (PyErr_Occurred()) SWIG_fail;
24949 }
24950 {
24951 wxDateSpan * resultptr;
24952 resultptr = new wxDateSpan((wxDateSpan &)(result));
24953 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24954 }
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24962 PyObject *resultobj;
24963 wxDateSpan result;
24964 char *kwnames[] = {
24965 NULL
24966 };
24967
24968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 result = wxDateSpan::Day();
24972
24973 wxPyEndAllowThreads(__tstate);
24974 if (PyErr_Occurred()) SWIG_fail;
24975 }
24976 {
24977 wxDateSpan * resultptr;
24978 resultptr = new wxDateSpan((wxDateSpan &)(result));
24979 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24980 }
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24988 PyObject *resultobj;
24989 int arg1 ;
24990 wxDateSpan result;
24991 PyObject * obj0 = 0 ;
24992 char *kwnames[] = {
24993 (char *) "weeks", NULL
24994 };
24995
24996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
24997 {
24998 arg1 = (int)(SWIG_As_int(obj0));
24999 if (SWIG_arg_fail(1)) SWIG_fail;
25000 }
25001 {
25002 PyThreadState* __tstate = wxPyBeginAllowThreads();
25003 result = wxDateSpan::Weeks(arg1);
25004
25005 wxPyEndAllowThreads(__tstate);
25006 if (PyErr_Occurred()) SWIG_fail;
25007 }
25008 {
25009 wxDateSpan * resultptr;
25010 resultptr = new wxDateSpan((wxDateSpan &)(result));
25011 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25012 }
25013 return resultobj;
25014 fail:
25015 return NULL;
25016 }
25017
25018
25019 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25020 PyObject *resultobj;
25021 wxDateSpan result;
25022 char *kwnames[] = {
25023 NULL
25024 };
25025
25026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25027 {
25028 PyThreadState* __tstate = wxPyBeginAllowThreads();
25029 result = wxDateSpan::Week();
25030
25031 wxPyEndAllowThreads(__tstate);
25032 if (PyErr_Occurred()) SWIG_fail;
25033 }
25034 {
25035 wxDateSpan * resultptr;
25036 resultptr = new wxDateSpan((wxDateSpan &)(result));
25037 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25038 }
25039 return resultobj;
25040 fail:
25041 return NULL;
25042 }
25043
25044
25045 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25046 PyObject *resultobj;
25047 int arg1 ;
25048 wxDateSpan result;
25049 PyObject * obj0 = 0 ;
25050 char *kwnames[] = {
25051 (char *) "mon", NULL
25052 };
25053
25054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25055 {
25056 arg1 = (int)(SWIG_As_int(obj0));
25057 if (SWIG_arg_fail(1)) SWIG_fail;
25058 }
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 result = wxDateSpan::Months(arg1);
25062
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 {
25067 wxDateSpan * resultptr;
25068 resultptr = new wxDateSpan((wxDateSpan &)(result));
25069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25070 }
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25078 PyObject *resultobj;
25079 wxDateSpan result;
25080 char *kwnames[] = {
25081 NULL
25082 };
25083
25084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 result = wxDateSpan::Month();
25088
25089 wxPyEndAllowThreads(__tstate);
25090 if (PyErr_Occurred()) SWIG_fail;
25091 }
25092 {
25093 wxDateSpan * resultptr;
25094 resultptr = new wxDateSpan((wxDateSpan &)(result));
25095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25096 }
25097 return resultobj;
25098 fail:
25099 return NULL;
25100 }
25101
25102
25103 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25104 PyObject *resultobj;
25105 int arg1 ;
25106 wxDateSpan result;
25107 PyObject * obj0 = 0 ;
25108 char *kwnames[] = {
25109 (char *) "years", NULL
25110 };
25111
25112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25113 {
25114 arg1 = (int)(SWIG_As_int(obj0));
25115 if (SWIG_arg_fail(1)) SWIG_fail;
25116 }
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = wxDateSpan::Years(arg1);
25120
25121 wxPyEndAllowThreads(__tstate);
25122 if (PyErr_Occurred()) SWIG_fail;
25123 }
25124 {
25125 wxDateSpan * resultptr;
25126 resultptr = new wxDateSpan((wxDateSpan &)(result));
25127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25128 }
25129 return resultobj;
25130 fail:
25131 return NULL;
25132 }
25133
25134
25135 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25136 PyObject *resultobj;
25137 wxDateSpan result;
25138 char *kwnames[] = {
25139 NULL
25140 };
25141
25142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25143 {
25144 PyThreadState* __tstate = wxPyBeginAllowThreads();
25145 result = wxDateSpan::Year();
25146
25147 wxPyEndAllowThreads(__tstate);
25148 if (PyErr_Occurred()) SWIG_fail;
25149 }
25150 {
25151 wxDateSpan * resultptr;
25152 resultptr = new wxDateSpan((wxDateSpan &)(result));
25153 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25154 }
25155 return resultobj;
25156 fail:
25157 return NULL;
25158 }
25159
25160
25161 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25162 PyObject *resultobj;
25163 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25164 int arg2 ;
25165 wxDateSpan *result;
25166 PyObject * obj0 = 0 ;
25167 PyObject * obj1 = 0 ;
25168 char *kwnames[] = {
25169 (char *) "self",(char *) "n", NULL
25170 };
25171
25172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25174 if (SWIG_arg_fail(1)) SWIG_fail;
25175 {
25176 arg2 = (int)(SWIG_As_int(obj1));
25177 if (SWIG_arg_fail(2)) SWIG_fail;
25178 }
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 {
25182 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25183 result = (wxDateSpan *) &_result_ref;
25184 }
25185
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25197 PyObject *resultobj;
25198 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25199 int arg2 ;
25200 wxDateSpan *result;
25201 PyObject * obj0 = 0 ;
25202 PyObject * obj1 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "self",(char *) "n", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(1)) SWIG_fail;
25210 {
25211 arg2 = (int)(SWIG_As_int(obj1));
25212 if (SWIG_arg_fail(2)) SWIG_fail;
25213 }
25214 {
25215 PyThreadState* __tstate = wxPyBeginAllowThreads();
25216 {
25217 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25218 result = (wxDateSpan *) &_result_ref;
25219 }
25220
25221 wxPyEndAllowThreads(__tstate);
25222 if (PyErr_Occurred()) SWIG_fail;
25223 }
25224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25225 return resultobj;
25226 fail:
25227 return NULL;
25228 }
25229
25230
25231 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25232 PyObject *resultobj;
25233 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25234 int arg2 ;
25235 wxDateSpan *result;
25236 PyObject * obj0 = 0 ;
25237 PyObject * obj1 = 0 ;
25238 char *kwnames[] = {
25239 (char *) "self",(char *) "n", NULL
25240 };
25241
25242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25244 if (SWIG_arg_fail(1)) SWIG_fail;
25245 {
25246 arg2 = (int)(SWIG_As_int(obj1));
25247 if (SWIG_arg_fail(2)) SWIG_fail;
25248 }
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 {
25252 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25253 result = (wxDateSpan *) &_result_ref;
25254 }
25255
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25260 return resultobj;
25261 fail:
25262 return NULL;
25263 }
25264
25265
25266 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25267 PyObject *resultobj;
25268 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25269 int arg2 ;
25270 wxDateSpan *result;
25271 PyObject * obj0 = 0 ;
25272 PyObject * obj1 = 0 ;
25273 char *kwnames[] = {
25274 (char *) "self",(char *) "n", NULL
25275 };
25276
25277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25279 if (SWIG_arg_fail(1)) SWIG_fail;
25280 {
25281 arg2 = (int)(SWIG_As_int(obj1));
25282 if (SWIG_arg_fail(2)) SWIG_fail;
25283 }
25284 {
25285 PyThreadState* __tstate = wxPyBeginAllowThreads();
25286 {
25287 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25288 result = (wxDateSpan *) &_result_ref;
25289 }
25290
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25295 return resultobj;
25296 fail:
25297 return NULL;
25298 }
25299
25300
25301 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25302 PyObject *resultobj;
25303 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25304 int result;
25305 PyObject * obj0 = 0 ;
25306 char *kwnames[] = {
25307 (char *) "self", NULL
25308 };
25309
25310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25312 if (SWIG_arg_fail(1)) SWIG_fail;
25313 {
25314 PyThreadState* __tstate = wxPyBeginAllowThreads();
25315 result = (int)((wxDateSpan const *)arg1)->GetYears();
25316
25317 wxPyEndAllowThreads(__tstate);
25318 if (PyErr_Occurred()) SWIG_fail;
25319 }
25320 {
25321 resultobj = SWIG_From_int((int)(result));
25322 }
25323 return resultobj;
25324 fail:
25325 return NULL;
25326 }
25327
25328
25329 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25330 PyObject *resultobj;
25331 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25332 int result;
25333 PyObject * obj0 = 0 ;
25334 char *kwnames[] = {
25335 (char *) "self", NULL
25336 };
25337
25338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25340 if (SWIG_arg_fail(1)) SWIG_fail;
25341 {
25342 PyThreadState* __tstate = wxPyBeginAllowThreads();
25343 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25344
25345 wxPyEndAllowThreads(__tstate);
25346 if (PyErr_Occurred()) SWIG_fail;
25347 }
25348 {
25349 resultobj = SWIG_From_int((int)(result));
25350 }
25351 return resultobj;
25352 fail:
25353 return NULL;
25354 }
25355
25356
25357 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25358 PyObject *resultobj;
25359 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25360 int result;
25361 PyObject * obj0 = 0 ;
25362 char *kwnames[] = {
25363 (char *) "self", NULL
25364 };
25365
25366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25368 if (SWIG_arg_fail(1)) SWIG_fail;
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25372
25373 wxPyEndAllowThreads(__tstate);
25374 if (PyErr_Occurred()) SWIG_fail;
25375 }
25376 {
25377 resultobj = SWIG_From_int((int)(result));
25378 }
25379 return resultobj;
25380 fail:
25381 return NULL;
25382 }
25383
25384
25385 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25386 PyObject *resultobj;
25387 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25388 int result;
25389 PyObject * obj0 = 0 ;
25390 char *kwnames[] = {
25391 (char *) "self", NULL
25392 };
25393
25394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25396 if (SWIG_arg_fail(1)) SWIG_fail;
25397 {
25398 PyThreadState* __tstate = wxPyBeginAllowThreads();
25399 result = (int)((wxDateSpan const *)arg1)->GetDays();
25400
25401 wxPyEndAllowThreads(__tstate);
25402 if (PyErr_Occurred()) SWIG_fail;
25403 }
25404 {
25405 resultobj = SWIG_From_int((int)(result));
25406 }
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj;
25415 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25416 int result;
25417 PyObject * obj0 = 0 ;
25418 char *kwnames[] = {
25419 (char *) "self", NULL
25420 };
25421
25422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25424 if (SWIG_arg_fail(1)) SWIG_fail;
25425 {
25426 PyThreadState* __tstate = wxPyBeginAllowThreads();
25427 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25428
25429 wxPyEndAllowThreads(__tstate);
25430 if (PyErr_Occurred()) SWIG_fail;
25431 }
25432 {
25433 resultobj = SWIG_From_int((int)(result));
25434 }
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25442 PyObject *resultobj;
25443 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25444 wxDateSpan *arg2 = 0 ;
25445 wxDateSpan *result;
25446 PyObject * obj0 = 0 ;
25447 PyObject * obj1 = 0 ;
25448 char *kwnames[] = {
25449 (char *) "self",(char *) "other", NULL
25450 };
25451
25452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25454 if (SWIG_arg_fail(1)) SWIG_fail;
25455 {
25456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25457 if (SWIG_arg_fail(2)) SWIG_fail;
25458 if (arg2 == NULL) {
25459 SWIG_null_ref("wxDateSpan");
25460 }
25461 if (SWIG_arg_fail(2)) SWIG_fail;
25462 }
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 {
25466 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25467 result = (wxDateSpan *) &_result_ref;
25468 }
25469
25470 wxPyEndAllowThreads(__tstate);
25471 if (PyErr_Occurred()) SWIG_fail;
25472 }
25473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25481 PyObject *resultobj;
25482 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25483 wxDateSpan *arg2 = 0 ;
25484 wxDateSpan *result;
25485 PyObject * obj0 = 0 ;
25486 PyObject * obj1 = 0 ;
25487 char *kwnames[] = {
25488 (char *) "self",(char *) "other", NULL
25489 };
25490
25491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25493 if (SWIG_arg_fail(1)) SWIG_fail;
25494 {
25495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25496 if (SWIG_arg_fail(2)) SWIG_fail;
25497 if (arg2 == NULL) {
25498 SWIG_null_ref("wxDateSpan");
25499 }
25500 if (SWIG_arg_fail(2)) SWIG_fail;
25501 }
25502 {
25503 PyThreadState* __tstate = wxPyBeginAllowThreads();
25504 {
25505 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25506 result = (wxDateSpan *) &_result_ref;
25507 }
25508
25509 wxPyEndAllowThreads(__tstate);
25510 if (PyErr_Occurred()) SWIG_fail;
25511 }
25512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25513 return resultobj;
25514 fail:
25515 return NULL;
25516 }
25517
25518
25519 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25520 PyObject *resultobj;
25521 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25522 wxDateSpan *result;
25523 PyObject * obj0 = 0 ;
25524 char *kwnames[] = {
25525 (char *) "self", NULL
25526 };
25527
25528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25530 if (SWIG_arg_fail(1)) SWIG_fail;
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 {
25534 wxDateSpan &_result_ref = (arg1)->Neg();
25535 result = (wxDateSpan *) &_result_ref;
25536 }
25537
25538 wxPyEndAllowThreads(__tstate);
25539 if (PyErr_Occurred()) SWIG_fail;
25540 }
25541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25542 return resultobj;
25543 fail:
25544 return NULL;
25545 }
25546
25547
25548 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25549 PyObject *resultobj;
25550 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25551 int arg2 ;
25552 wxDateSpan *result;
25553 PyObject * obj0 = 0 ;
25554 PyObject * obj1 = 0 ;
25555 char *kwnames[] = {
25556 (char *) "self",(char *) "factor", NULL
25557 };
25558
25559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25561 if (SWIG_arg_fail(1)) SWIG_fail;
25562 {
25563 arg2 = (int)(SWIG_As_int(obj1));
25564 if (SWIG_arg_fail(2)) SWIG_fail;
25565 }
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 {
25569 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25570 result = (wxDateSpan *) &_result_ref;
25571 }
25572
25573 wxPyEndAllowThreads(__tstate);
25574 if (PyErr_Occurred()) SWIG_fail;
25575 }
25576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25584 PyObject *resultobj;
25585 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25586 wxDateSpan *arg2 = 0 ;
25587 wxDateSpan *result;
25588 PyObject * obj0 = 0 ;
25589 PyObject * obj1 = 0 ;
25590 char *kwnames[] = {
25591 (char *) "self",(char *) "other", NULL
25592 };
25593
25594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25596 if (SWIG_arg_fail(1)) SWIG_fail;
25597 {
25598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25599 if (SWIG_arg_fail(2)) SWIG_fail;
25600 if (arg2 == NULL) {
25601 SWIG_null_ref("wxDateSpan");
25602 }
25603 if (SWIG_arg_fail(2)) SWIG_fail;
25604 }
25605 {
25606 PyThreadState* __tstate = wxPyBeginAllowThreads();
25607 {
25608 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25609 result = (wxDateSpan *) &_result_ref;
25610 }
25611
25612 wxPyEndAllowThreads(__tstate);
25613 if (PyErr_Occurred()) SWIG_fail;
25614 }
25615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25616 return resultobj;
25617 fail:
25618 return NULL;
25619 }
25620
25621
25622 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25623 PyObject *resultobj;
25624 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25625 wxDateSpan *arg2 = 0 ;
25626 wxDateSpan *result;
25627 PyObject * obj0 = 0 ;
25628 PyObject * obj1 = 0 ;
25629 char *kwnames[] = {
25630 (char *) "self",(char *) "other", NULL
25631 };
25632
25633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25635 if (SWIG_arg_fail(1)) SWIG_fail;
25636 {
25637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25638 if (SWIG_arg_fail(2)) SWIG_fail;
25639 if (arg2 == NULL) {
25640 SWIG_null_ref("wxDateSpan");
25641 }
25642 if (SWIG_arg_fail(2)) SWIG_fail;
25643 }
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 {
25647 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25648 result = (wxDateSpan *) &_result_ref;
25649 }
25650
25651 wxPyEndAllowThreads(__tstate);
25652 if (PyErr_Occurred()) SWIG_fail;
25653 }
25654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25655 return resultobj;
25656 fail:
25657 return NULL;
25658 }
25659
25660
25661 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25662 PyObject *resultobj;
25663 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25664 wxDateSpan *result;
25665 PyObject * obj0 = 0 ;
25666 char *kwnames[] = {
25667 (char *) "self", NULL
25668 };
25669
25670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25672 if (SWIG_arg_fail(1)) SWIG_fail;
25673 {
25674 PyThreadState* __tstate = wxPyBeginAllowThreads();
25675 {
25676 wxDateSpan &_result_ref = (arg1)->operator -();
25677 result = (wxDateSpan *) &_result_ref;
25678 }
25679
25680 wxPyEndAllowThreads(__tstate);
25681 if (PyErr_Occurred()) SWIG_fail;
25682 }
25683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25684 return resultobj;
25685 fail:
25686 return NULL;
25687 }
25688
25689
25690 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25691 PyObject *resultobj;
25692 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25693 int arg2 ;
25694 wxDateSpan *result;
25695 PyObject * obj0 = 0 ;
25696 PyObject * obj1 = 0 ;
25697 char *kwnames[] = {
25698 (char *) "self",(char *) "factor", NULL
25699 };
25700
25701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25703 if (SWIG_arg_fail(1)) SWIG_fail;
25704 {
25705 arg2 = (int)(SWIG_As_int(obj1));
25706 if (SWIG_arg_fail(2)) SWIG_fail;
25707 }
25708 {
25709 PyThreadState* __tstate = wxPyBeginAllowThreads();
25710 {
25711 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25712 result = (wxDateSpan *) &_result_ref;
25713 }
25714
25715 wxPyEndAllowThreads(__tstate);
25716 if (PyErr_Occurred()) SWIG_fail;
25717 }
25718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25719 return resultobj;
25720 fail:
25721 return NULL;
25722 }
25723
25724
25725 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25726 PyObject *resultobj;
25727 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25728 wxDateSpan *arg2 = 0 ;
25729 wxDateSpan result;
25730 PyObject * obj0 = 0 ;
25731 PyObject * obj1 = 0 ;
25732 char *kwnames[] = {
25733 (char *) "self",(char *) "other", NULL
25734 };
25735
25736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25738 if (SWIG_arg_fail(1)) SWIG_fail;
25739 {
25740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25741 if (SWIG_arg_fail(2)) SWIG_fail;
25742 if (arg2 == NULL) {
25743 SWIG_null_ref("wxDateSpan");
25744 }
25745 if (SWIG_arg_fail(2)) SWIG_fail;
25746 }
25747 {
25748 PyThreadState* __tstate = wxPyBeginAllowThreads();
25749 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25750
25751 wxPyEndAllowThreads(__tstate);
25752 if (PyErr_Occurred()) SWIG_fail;
25753 }
25754 {
25755 wxDateSpan * resultptr;
25756 resultptr = new wxDateSpan((wxDateSpan &)(result));
25757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25758 }
25759 return resultobj;
25760 fail:
25761 return NULL;
25762 }
25763
25764
25765 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25766 PyObject *resultobj;
25767 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25768 wxDateSpan *arg2 = 0 ;
25769 wxDateSpan result;
25770 PyObject * obj0 = 0 ;
25771 PyObject * obj1 = 0 ;
25772 char *kwnames[] = {
25773 (char *) "self",(char *) "other", NULL
25774 };
25775
25776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25778 if (SWIG_arg_fail(1)) SWIG_fail;
25779 {
25780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25781 if (SWIG_arg_fail(2)) SWIG_fail;
25782 if (arg2 == NULL) {
25783 SWIG_null_ref("wxDateSpan");
25784 }
25785 if (SWIG_arg_fail(2)) SWIG_fail;
25786 }
25787 {
25788 PyThreadState* __tstate = wxPyBeginAllowThreads();
25789 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
25790
25791 wxPyEndAllowThreads(__tstate);
25792 if (PyErr_Occurred()) SWIG_fail;
25793 }
25794 {
25795 wxDateSpan * resultptr;
25796 resultptr = new wxDateSpan((wxDateSpan &)(result));
25797 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25798 }
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj;
25807 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25808 int arg2 ;
25809 wxDateSpan result;
25810 PyObject * obj0 = 0 ;
25811 PyObject * obj1 = 0 ;
25812 char *kwnames[] = {
25813 (char *) "self",(char *) "n", NULL
25814 };
25815
25816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25818 if (SWIG_arg_fail(1)) SWIG_fail;
25819 {
25820 arg2 = (int)(SWIG_As_int(obj1));
25821 if (SWIG_arg_fail(2)) SWIG_fail;
25822 }
25823 {
25824 PyThreadState* __tstate = wxPyBeginAllowThreads();
25825 result = wxDateSpan___mul__(arg1,arg2);
25826
25827 wxPyEndAllowThreads(__tstate);
25828 if (PyErr_Occurred()) SWIG_fail;
25829 }
25830 {
25831 wxDateSpan * resultptr;
25832 resultptr = new wxDateSpan((wxDateSpan &)(result));
25833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25834 }
25835 return resultobj;
25836 fail:
25837 return NULL;
25838 }
25839
25840
25841 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25842 PyObject *resultobj;
25843 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25844 int arg2 ;
25845 wxDateSpan result;
25846 PyObject * obj0 = 0 ;
25847 PyObject * obj1 = 0 ;
25848 char *kwnames[] = {
25849 (char *) "self",(char *) "n", NULL
25850 };
25851
25852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25854 if (SWIG_arg_fail(1)) SWIG_fail;
25855 {
25856 arg2 = (int)(SWIG_As_int(obj1));
25857 if (SWIG_arg_fail(2)) SWIG_fail;
25858 }
25859 {
25860 PyThreadState* __tstate = wxPyBeginAllowThreads();
25861 result = wxDateSpan___rmul__(arg1,arg2);
25862
25863 wxPyEndAllowThreads(__tstate);
25864 if (PyErr_Occurred()) SWIG_fail;
25865 }
25866 {
25867 wxDateSpan * resultptr;
25868 resultptr = new wxDateSpan((wxDateSpan &)(result));
25869 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25870 }
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj;
25879 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25880 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25881 bool result;
25882 PyObject * obj0 = 0 ;
25883 PyObject * obj1 = 0 ;
25884 char *kwnames[] = {
25885 (char *) "self",(char *) "other", NULL
25886 };
25887
25888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
25889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25890 if (SWIG_arg_fail(1)) SWIG_fail;
25891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25892 if (SWIG_arg_fail(2)) SWIG_fail;
25893 {
25894 PyThreadState* __tstate = wxPyBeginAllowThreads();
25895 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
25896
25897 wxPyEndAllowThreads(__tstate);
25898 if (PyErr_Occurred()) SWIG_fail;
25899 }
25900 {
25901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25902 }
25903 return resultobj;
25904 fail:
25905 return NULL;
25906 }
25907
25908
25909 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
25910 PyObject *resultobj;
25911 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25912 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25913 bool result;
25914 PyObject * obj0 = 0 ;
25915 PyObject * obj1 = 0 ;
25916 char *kwnames[] = {
25917 (char *) "self",(char *) "other", NULL
25918 };
25919
25920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25922 if (SWIG_arg_fail(1)) SWIG_fail;
25923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25924 if (SWIG_arg_fail(2)) SWIG_fail;
25925 {
25926 PyThreadState* __tstate = wxPyBeginAllowThreads();
25927 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
25928
25929 wxPyEndAllowThreads(__tstate);
25930 if (PyErr_Occurred()) SWIG_fail;
25931 }
25932 {
25933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25934 }
25935 return resultobj;
25936 fail:
25937 return NULL;
25938 }
25939
25940
25941 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
25942 PyObject *obj;
25943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25944 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
25945 Py_INCREF(obj);
25946 return Py_BuildValue((char *)"");
25947 }
25948 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj;
25950 long result;
25951 char *kwnames[] = {
25952 NULL
25953 };
25954
25955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
25956 {
25957 PyThreadState* __tstate = wxPyBeginAllowThreads();
25958 result = (long)wxGetLocalTime();
25959
25960 wxPyEndAllowThreads(__tstate);
25961 if (PyErr_Occurred()) SWIG_fail;
25962 }
25963 {
25964 resultobj = SWIG_From_long((long)(result));
25965 }
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
25973 PyObject *resultobj;
25974 long result;
25975 char *kwnames[] = {
25976 NULL
25977 };
25978
25979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
25980 {
25981 PyThreadState* __tstate = wxPyBeginAllowThreads();
25982 result = (long)wxGetUTCTime();
25983
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 {
25988 resultobj = SWIG_From_long((long)(result));
25989 }
25990 return resultobj;
25991 fail:
25992 return NULL;
25993 }
25994
25995
25996 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
25997 PyObject *resultobj;
25998 long result;
25999 char *kwnames[] = {
26000 NULL
26001 };
26002
26003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26004 {
26005 PyThreadState* __tstate = wxPyBeginAllowThreads();
26006 result = (long)wxGetCurrentTime();
26007
26008 wxPyEndAllowThreads(__tstate);
26009 if (PyErr_Occurred()) SWIG_fail;
26010 }
26011 {
26012 resultobj = SWIG_From_long((long)(result));
26013 }
26014 return resultobj;
26015 fail:
26016 return NULL;
26017 }
26018
26019
26020 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26021 PyObject *resultobj;
26022 wxLongLong result;
26023 char *kwnames[] = {
26024 NULL
26025 };
26026
26027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 result = wxGetLocalTimeMillis();
26031
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 {
26036 PyObject *hi, *lo, *shifter, *shifted;
26037 hi = PyLong_FromLong( (&result)->GetHi() );
26038 lo = PyLong_FromLong( (&result)->GetLo() );
26039 shifter = PyLong_FromLong(32);
26040 shifted = PyNumber_Lshift(hi, shifter);
26041 resultobj = PyNumber_Or(shifted, lo);
26042 Py_DECREF(hi);
26043 Py_DECREF(lo);
26044 Py_DECREF(shifter);
26045 Py_DECREF(shifted);
26046 }
26047 return resultobj;
26048 fail:
26049 return NULL;
26050 }
26051
26052
26053 static int _wrap_DefaultDateTime_set(PyObject *) {
26054 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26055 return 1;
26056 }
26057
26058
26059 static PyObject *_wrap_DefaultDateTime_get(void) {
26060 PyObject *pyobj;
26061
26062 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26063 return pyobj;
26064 }
26065
26066
26067 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26068 PyObject *resultobj;
26069 wxDataFormatId arg1 ;
26070 wxDataFormat *result;
26071 PyObject * obj0 = 0 ;
26072 char *kwnames[] = {
26073 (char *) "type", NULL
26074 };
26075
26076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26077 {
26078 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26079 if (SWIG_arg_fail(1)) SWIG_fail;
26080 }
26081 {
26082 PyThreadState* __tstate = wxPyBeginAllowThreads();
26083 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26084
26085 wxPyEndAllowThreads(__tstate);
26086 if (PyErr_Occurred()) SWIG_fail;
26087 }
26088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26089 return resultobj;
26090 fail:
26091 return NULL;
26092 }
26093
26094
26095 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26096 PyObject *resultobj;
26097 wxString *arg1 = 0 ;
26098 wxDataFormat *result;
26099 bool temp1 = false ;
26100 PyObject * obj0 = 0 ;
26101 char *kwnames[] = {
26102 (char *) "format", NULL
26103 };
26104
26105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26106 {
26107 arg1 = wxString_in_helper(obj0);
26108 if (arg1 == NULL) SWIG_fail;
26109 temp1 = true;
26110 }
26111 {
26112 PyThreadState* __tstate = wxPyBeginAllowThreads();
26113 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26114
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26119 {
26120 if (temp1)
26121 delete arg1;
26122 }
26123 return resultobj;
26124 fail:
26125 {
26126 if (temp1)
26127 delete arg1;
26128 }
26129 return NULL;
26130 }
26131
26132
26133 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26134 PyObject *resultobj;
26135 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26136 PyObject * obj0 = 0 ;
26137 char *kwnames[] = {
26138 (char *) "self", NULL
26139 };
26140
26141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26143 if (SWIG_arg_fail(1)) SWIG_fail;
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 delete arg1;
26147
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 Py_INCREF(Py_None); resultobj = Py_None;
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26159 PyObject *resultobj;
26160 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26161 wxDataFormatId arg2 ;
26162 bool result;
26163 PyObject * obj0 = 0 ;
26164 PyObject * obj1 = 0 ;
26165
26166 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26168 if (SWIG_arg_fail(1)) SWIG_fail;
26169 {
26170 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26171 if (SWIG_arg_fail(2)) SWIG_fail;
26172 }
26173 {
26174 PyThreadState* __tstate = wxPyBeginAllowThreads();
26175 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26176
26177 wxPyEndAllowThreads(__tstate);
26178 if (PyErr_Occurred()) SWIG_fail;
26179 }
26180 {
26181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26182 }
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26190 PyObject *resultobj;
26191 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26192 wxDataFormatId arg2 ;
26193 bool result;
26194 PyObject * obj0 = 0 ;
26195 PyObject * obj1 = 0 ;
26196
26197 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26199 if (SWIG_arg_fail(1)) SWIG_fail;
26200 {
26201 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26202 if (SWIG_arg_fail(2)) SWIG_fail;
26203 }
26204 {
26205 PyThreadState* __tstate = wxPyBeginAllowThreads();
26206 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26207
26208 wxPyEndAllowThreads(__tstate);
26209 if (PyErr_Occurred()) SWIG_fail;
26210 }
26211 {
26212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26213 }
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26221 PyObject *resultobj;
26222 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26223 wxDataFormat *arg2 = 0 ;
26224 bool result;
26225 PyObject * obj0 = 0 ;
26226 PyObject * obj1 = 0 ;
26227
26228 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26230 if (SWIG_arg_fail(1)) SWIG_fail;
26231 {
26232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26233 if (SWIG_arg_fail(2)) SWIG_fail;
26234 if (arg2 == NULL) {
26235 SWIG_null_ref("wxDataFormat");
26236 }
26237 if (SWIG_arg_fail(2)) SWIG_fail;
26238 }
26239 {
26240 PyThreadState* __tstate = wxPyBeginAllowThreads();
26241 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26242
26243 wxPyEndAllowThreads(__tstate);
26244 if (PyErr_Occurred()) SWIG_fail;
26245 }
26246 {
26247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26248 }
26249 return resultobj;
26250 fail:
26251 return NULL;
26252 }
26253
26254
26255 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26256 int argc;
26257 PyObject *argv[3];
26258 int ii;
26259
26260 argc = PyObject_Length(args);
26261 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26262 argv[ii] = PyTuple_GetItem(args,ii);
26263 }
26264 if (argc == 2) {
26265 int _v;
26266 {
26267 void *ptr;
26268 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26269 _v = 0;
26270 PyErr_Clear();
26271 } else {
26272 _v = 1;
26273 }
26274 }
26275 if (_v) {
26276 {
26277 void *ptr = 0;
26278 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26279 _v = 0;
26280 PyErr_Clear();
26281 } else {
26282 _v = (ptr != 0);
26283 }
26284 }
26285 if (_v) {
26286 return _wrap_DataFormat___eq____SWIG_1(self,args);
26287 }
26288 }
26289 }
26290 if (argc == 2) {
26291 int _v;
26292 {
26293 void *ptr;
26294 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26295 _v = 0;
26296 PyErr_Clear();
26297 } else {
26298 _v = 1;
26299 }
26300 }
26301 if (_v) {
26302 _v = SWIG_Check_int(argv[1]);
26303 if (_v) {
26304 return _wrap_DataFormat___eq____SWIG_0(self,args);
26305 }
26306 }
26307 }
26308
26309 Py_INCREF(Py_NotImplemented);
26310 return Py_NotImplemented;
26311 }
26312
26313
26314 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26315 PyObject *resultobj;
26316 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26317 wxDataFormat *arg2 = 0 ;
26318 bool result;
26319 PyObject * obj0 = 0 ;
26320 PyObject * obj1 = 0 ;
26321
26322 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26324 if (SWIG_arg_fail(1)) SWIG_fail;
26325 {
26326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26327 if (SWIG_arg_fail(2)) SWIG_fail;
26328 if (arg2 == NULL) {
26329 SWIG_null_ref("wxDataFormat");
26330 }
26331 if (SWIG_arg_fail(2)) SWIG_fail;
26332 }
26333 {
26334 PyThreadState* __tstate = wxPyBeginAllowThreads();
26335 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26336
26337 wxPyEndAllowThreads(__tstate);
26338 if (PyErr_Occurred()) SWIG_fail;
26339 }
26340 {
26341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26342 }
26343 return resultobj;
26344 fail:
26345 return NULL;
26346 }
26347
26348
26349 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26350 int argc;
26351 PyObject *argv[3];
26352 int ii;
26353
26354 argc = PyObject_Length(args);
26355 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26356 argv[ii] = PyTuple_GetItem(args,ii);
26357 }
26358 if (argc == 2) {
26359 int _v;
26360 {
26361 void *ptr;
26362 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26363 _v = 0;
26364 PyErr_Clear();
26365 } else {
26366 _v = 1;
26367 }
26368 }
26369 if (_v) {
26370 {
26371 void *ptr = 0;
26372 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26373 _v = 0;
26374 PyErr_Clear();
26375 } else {
26376 _v = (ptr != 0);
26377 }
26378 }
26379 if (_v) {
26380 return _wrap_DataFormat___ne____SWIG_1(self,args);
26381 }
26382 }
26383 }
26384 if (argc == 2) {
26385 int _v;
26386 {
26387 void *ptr;
26388 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26389 _v = 0;
26390 PyErr_Clear();
26391 } else {
26392 _v = 1;
26393 }
26394 }
26395 if (_v) {
26396 _v = SWIG_Check_int(argv[1]);
26397 if (_v) {
26398 return _wrap_DataFormat___ne____SWIG_0(self,args);
26399 }
26400 }
26401 }
26402
26403 Py_INCREF(Py_NotImplemented);
26404 return Py_NotImplemented;
26405 }
26406
26407
26408 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26409 PyObject *resultobj;
26410 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26411 wxDataFormatId arg2 ;
26412 PyObject * obj0 = 0 ;
26413 PyObject * obj1 = 0 ;
26414 char *kwnames[] = {
26415 (char *) "self",(char *) "format", NULL
26416 };
26417
26418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26420 if (SWIG_arg_fail(1)) SWIG_fail;
26421 {
26422 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26423 if (SWIG_arg_fail(2)) SWIG_fail;
26424 }
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 (arg1)->SetType((wxDataFormatId )arg2);
26428
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 Py_INCREF(Py_None); resultobj = Py_None;
26433 return resultobj;
26434 fail:
26435 return NULL;
26436 }
26437
26438
26439 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26440 PyObject *resultobj;
26441 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26442 wxDataFormatId result;
26443 PyObject * obj0 = 0 ;
26444 char *kwnames[] = {
26445 (char *) "self", NULL
26446 };
26447
26448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26450 if (SWIG_arg_fail(1)) SWIG_fail;
26451 {
26452 PyThreadState* __tstate = wxPyBeginAllowThreads();
26453 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26454
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 resultobj = SWIG_From_int((result));
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26466 PyObject *resultobj;
26467 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26468 wxString result;
26469 PyObject * obj0 = 0 ;
26470 char *kwnames[] = {
26471 (char *) "self", NULL
26472 };
26473
26474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26476 if (SWIG_arg_fail(1)) SWIG_fail;
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 result = ((wxDataFormat const *)arg1)->GetId();
26480
26481 wxPyEndAllowThreads(__tstate);
26482 if (PyErr_Occurred()) SWIG_fail;
26483 }
26484 {
26485 #if wxUSE_UNICODE
26486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26487 #else
26488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26489 #endif
26490 }
26491 return resultobj;
26492 fail:
26493 return NULL;
26494 }
26495
26496
26497 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26498 PyObject *resultobj;
26499 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26500 wxString *arg2 = 0 ;
26501 bool temp2 = false ;
26502 PyObject * obj0 = 0 ;
26503 PyObject * obj1 = 0 ;
26504 char *kwnames[] = {
26505 (char *) "self",(char *) "format", NULL
26506 };
26507
26508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26510 if (SWIG_arg_fail(1)) SWIG_fail;
26511 {
26512 arg2 = wxString_in_helper(obj1);
26513 if (arg2 == NULL) SWIG_fail;
26514 temp2 = true;
26515 }
26516 {
26517 PyThreadState* __tstate = wxPyBeginAllowThreads();
26518 (arg1)->SetId((wxString const &)*arg2);
26519
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 Py_INCREF(Py_None); resultobj = Py_None;
26524 {
26525 if (temp2)
26526 delete arg2;
26527 }
26528 return resultobj;
26529 fail:
26530 {
26531 if (temp2)
26532 delete arg2;
26533 }
26534 return NULL;
26535 }
26536
26537
26538 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26539 PyObject *obj;
26540 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26541 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26542 Py_INCREF(obj);
26543 return Py_BuildValue((char *)"");
26544 }
26545 static int _wrap_FormatInvalid_set(PyObject *) {
26546 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26547 return 1;
26548 }
26549
26550
26551 static PyObject *_wrap_FormatInvalid_get(void) {
26552 PyObject *pyobj;
26553
26554 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26555 return pyobj;
26556 }
26557
26558
26559 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj;
26561 wxDataObject *arg1 = (wxDataObject *) 0 ;
26562 PyObject * obj0 = 0 ;
26563 char *kwnames[] = {
26564 (char *) "self", NULL
26565 };
26566
26567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26569 if (SWIG_arg_fail(1)) SWIG_fail;
26570 {
26571 PyThreadState* __tstate = wxPyBeginAllowThreads();
26572 delete arg1;
26573
26574 wxPyEndAllowThreads(__tstate);
26575 if (PyErr_Occurred()) SWIG_fail;
26576 }
26577 Py_INCREF(Py_None); resultobj = Py_None;
26578 return resultobj;
26579 fail:
26580 return NULL;
26581 }
26582
26583
26584 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26585 PyObject *resultobj;
26586 wxDataObject *arg1 = (wxDataObject *) 0 ;
26587 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26588 SwigValueWrapper<wxDataFormat > result;
26589 PyObject * obj0 = 0 ;
26590 PyObject * obj1 = 0 ;
26591 char *kwnames[] = {
26592 (char *) "self",(char *) "dir", NULL
26593 };
26594
26595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26597 if (SWIG_arg_fail(1)) SWIG_fail;
26598 if (obj1) {
26599 {
26600 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26601 if (SWIG_arg_fail(2)) SWIG_fail;
26602 }
26603 }
26604 {
26605 PyThreadState* __tstate = wxPyBeginAllowThreads();
26606 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26607
26608 wxPyEndAllowThreads(__tstate);
26609 if (PyErr_Occurred()) SWIG_fail;
26610 }
26611 {
26612 wxDataFormat * resultptr;
26613 resultptr = new wxDataFormat((wxDataFormat &)(result));
26614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26615 }
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26623 PyObject *resultobj;
26624 wxDataObject *arg1 = (wxDataObject *) 0 ;
26625 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26626 size_t result;
26627 PyObject * obj0 = 0 ;
26628 PyObject * obj1 = 0 ;
26629 char *kwnames[] = {
26630 (char *) "self",(char *) "dir", NULL
26631 };
26632
26633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26635 if (SWIG_arg_fail(1)) SWIG_fail;
26636 if (obj1) {
26637 {
26638 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26639 if (SWIG_arg_fail(2)) SWIG_fail;
26640 }
26641 }
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26645
26646 wxPyEndAllowThreads(__tstate);
26647 if (PyErr_Occurred()) SWIG_fail;
26648 }
26649 {
26650 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26651 }
26652 return resultobj;
26653 fail:
26654 return NULL;
26655 }
26656
26657
26658 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26659 PyObject *resultobj;
26660 wxDataObject *arg1 = (wxDataObject *) 0 ;
26661 wxDataFormat *arg2 = 0 ;
26662 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26663 bool result;
26664 PyObject * obj0 = 0 ;
26665 PyObject * obj1 = 0 ;
26666 PyObject * obj2 = 0 ;
26667 char *kwnames[] = {
26668 (char *) "self",(char *) "format",(char *) "dir", NULL
26669 };
26670
26671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26673 if (SWIG_arg_fail(1)) SWIG_fail;
26674 {
26675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26676 if (SWIG_arg_fail(2)) SWIG_fail;
26677 if (arg2 == NULL) {
26678 SWIG_null_ref("wxDataFormat");
26679 }
26680 if (SWIG_arg_fail(2)) SWIG_fail;
26681 }
26682 if (obj2) {
26683 {
26684 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26685 if (SWIG_arg_fail(3)) SWIG_fail;
26686 }
26687 }
26688 {
26689 PyThreadState* __tstate = wxPyBeginAllowThreads();
26690 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26691
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 {
26696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26697 }
26698 return resultobj;
26699 fail:
26700 return NULL;
26701 }
26702
26703
26704 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26705 PyObject *resultobj;
26706 wxDataObject *arg1 = (wxDataObject *) 0 ;
26707 wxDataFormat *arg2 = 0 ;
26708 size_t result;
26709 PyObject * obj0 = 0 ;
26710 PyObject * obj1 = 0 ;
26711 char *kwnames[] = {
26712 (char *) "self",(char *) "format", NULL
26713 };
26714
26715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26717 if (SWIG_arg_fail(1)) SWIG_fail;
26718 {
26719 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26720 if (SWIG_arg_fail(2)) SWIG_fail;
26721 if (arg2 == NULL) {
26722 SWIG_null_ref("wxDataFormat");
26723 }
26724 if (SWIG_arg_fail(2)) SWIG_fail;
26725 }
26726 {
26727 PyThreadState* __tstate = wxPyBeginAllowThreads();
26728 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26729
26730 wxPyEndAllowThreads(__tstate);
26731 if (PyErr_Occurred()) SWIG_fail;
26732 }
26733 {
26734 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26735 }
26736 return resultobj;
26737 fail:
26738 return NULL;
26739 }
26740
26741
26742 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26743 PyObject *resultobj;
26744 wxDataObject *arg1 = (wxDataObject *) 0 ;
26745 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26746 PyObject *result;
26747 PyObject * obj0 = 0 ;
26748 PyObject * obj1 = 0 ;
26749 char *kwnames[] = {
26750 (char *) "self",(char *) "dir", NULL
26751 };
26752
26753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26755 if (SWIG_arg_fail(1)) SWIG_fail;
26756 if (obj1) {
26757 {
26758 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26759 if (SWIG_arg_fail(2)) SWIG_fail;
26760 }
26761 }
26762 {
26763 PyThreadState* __tstate = wxPyBeginAllowThreads();
26764 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26765
26766 wxPyEndAllowThreads(__tstate);
26767 if (PyErr_Occurred()) SWIG_fail;
26768 }
26769 resultobj = result;
26770 return resultobj;
26771 fail:
26772 return NULL;
26773 }
26774
26775
26776 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26777 PyObject *resultobj;
26778 wxDataObject *arg1 = (wxDataObject *) 0 ;
26779 wxDataFormat *arg2 = 0 ;
26780 PyObject *result;
26781 PyObject * obj0 = 0 ;
26782 PyObject * obj1 = 0 ;
26783 char *kwnames[] = {
26784 (char *) "self",(char *) "format", NULL
26785 };
26786
26787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26789 if (SWIG_arg_fail(1)) SWIG_fail;
26790 {
26791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26792 if (SWIG_arg_fail(2)) SWIG_fail;
26793 if (arg2 == NULL) {
26794 SWIG_null_ref("wxDataFormat");
26795 }
26796 if (SWIG_arg_fail(2)) SWIG_fail;
26797 }
26798 {
26799 PyThreadState* __tstate = wxPyBeginAllowThreads();
26800 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
26801
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 resultobj = result;
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
26813 PyObject *resultobj;
26814 wxDataObject *arg1 = (wxDataObject *) 0 ;
26815 wxDataFormat *arg2 = 0 ;
26816 PyObject *arg3 = (PyObject *) 0 ;
26817 bool result;
26818 PyObject * obj0 = 0 ;
26819 PyObject * obj1 = 0 ;
26820 PyObject * obj2 = 0 ;
26821 char *kwnames[] = {
26822 (char *) "self",(char *) "format",(char *) "data", NULL
26823 };
26824
26825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
26826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26827 if (SWIG_arg_fail(1)) SWIG_fail;
26828 {
26829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26830 if (SWIG_arg_fail(2)) SWIG_fail;
26831 if (arg2 == NULL) {
26832 SWIG_null_ref("wxDataFormat");
26833 }
26834 if (SWIG_arg_fail(2)) SWIG_fail;
26835 }
26836 arg3 = obj2;
26837 {
26838 PyThreadState* __tstate = wxPyBeginAllowThreads();
26839 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
26840
26841 wxPyEndAllowThreads(__tstate);
26842 if (PyErr_Occurred()) SWIG_fail;
26843 }
26844 {
26845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26846 }
26847 return resultobj;
26848 fail:
26849 return NULL;
26850 }
26851
26852
26853 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
26854 PyObject *obj;
26855 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26856 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
26857 Py_INCREF(obj);
26858 return Py_BuildValue((char *)"");
26859 }
26860 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
26861 PyObject *resultobj;
26862 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
26863 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
26864 wxDataObjectSimple *result;
26865 PyObject * obj0 = 0 ;
26866 char *kwnames[] = {
26867 (char *) "format", NULL
26868 };
26869
26870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
26871 if (obj0) {
26872 {
26873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26874 if (SWIG_arg_fail(1)) SWIG_fail;
26875 if (arg1 == NULL) {
26876 SWIG_null_ref("wxDataFormat");
26877 }
26878 if (SWIG_arg_fail(1)) SWIG_fail;
26879 }
26880 }
26881 {
26882 PyThreadState* __tstate = wxPyBeginAllowThreads();
26883 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
26884
26885 wxPyEndAllowThreads(__tstate);
26886 if (PyErr_Occurred()) SWIG_fail;
26887 }
26888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
26889 return resultobj;
26890 fail:
26891 return NULL;
26892 }
26893
26894
26895 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26896 PyObject *resultobj;
26897 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26898 wxDataFormat *result;
26899 PyObject * obj0 = 0 ;
26900 char *kwnames[] = {
26901 (char *) "self", NULL
26902 };
26903
26904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
26905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26906 if (SWIG_arg_fail(1)) SWIG_fail;
26907 {
26908 PyThreadState* __tstate = wxPyBeginAllowThreads();
26909 {
26910 wxDataFormat const &_result_ref = (arg1)->GetFormat();
26911 result = (wxDataFormat *) &_result_ref;
26912 }
26913
26914 wxPyEndAllowThreads(__tstate);
26915 if (PyErr_Occurred()) SWIG_fail;
26916 }
26917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
26918 return resultobj;
26919 fail:
26920 return NULL;
26921 }
26922
26923
26924 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26925 PyObject *resultobj;
26926 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26927 wxDataFormat *arg2 = 0 ;
26928 PyObject * obj0 = 0 ;
26929 PyObject * obj1 = 0 ;
26930 char *kwnames[] = {
26931 (char *) "self",(char *) "format", NULL
26932 };
26933
26934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
26935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26936 if (SWIG_arg_fail(1)) SWIG_fail;
26937 {
26938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26939 if (SWIG_arg_fail(2)) SWIG_fail;
26940 if (arg2 == NULL) {
26941 SWIG_null_ref("wxDataFormat");
26942 }
26943 if (SWIG_arg_fail(2)) SWIG_fail;
26944 }
26945 {
26946 PyThreadState* __tstate = wxPyBeginAllowThreads();
26947 (arg1)->SetFormat((wxDataFormat const &)*arg2);
26948
26949 wxPyEndAllowThreads(__tstate);
26950 if (PyErr_Occurred()) SWIG_fail;
26951 }
26952 Py_INCREF(Py_None); resultobj = Py_None;
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj;
26961 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26962 size_t result;
26963 PyObject * obj0 = 0 ;
26964 char *kwnames[] = {
26965 (char *) "self", NULL
26966 };
26967
26968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
26969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26970 if (SWIG_arg_fail(1)) SWIG_fail;
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
26974
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 {
26979 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26980 }
26981 return resultobj;
26982 fail:
26983 return NULL;
26984 }
26985
26986
26987 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26988 PyObject *resultobj;
26989 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26990 PyObject *result;
26991 PyObject * obj0 = 0 ;
26992 char *kwnames[] = {
26993 (char *) "self", NULL
26994 };
26995
26996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
26997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26998 if (SWIG_arg_fail(1)) SWIG_fail;
26999 {
27000 PyThreadState* __tstate = wxPyBeginAllowThreads();
27001 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27002
27003 wxPyEndAllowThreads(__tstate);
27004 if (PyErr_Occurred()) SWIG_fail;
27005 }
27006 resultobj = result;
27007 return resultobj;
27008 fail:
27009 return NULL;
27010 }
27011
27012
27013 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27014 PyObject *resultobj;
27015 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27016 PyObject *arg2 = (PyObject *) 0 ;
27017 bool result;
27018 PyObject * obj0 = 0 ;
27019 PyObject * obj1 = 0 ;
27020 char *kwnames[] = {
27021 (char *) "self",(char *) "data", NULL
27022 };
27023
27024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27026 if (SWIG_arg_fail(1)) SWIG_fail;
27027 arg2 = obj1;
27028 {
27029 PyThreadState* __tstate = wxPyBeginAllowThreads();
27030 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27031
27032 wxPyEndAllowThreads(__tstate);
27033 if (PyErr_Occurred()) SWIG_fail;
27034 }
27035 {
27036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27037 }
27038 return resultobj;
27039 fail:
27040 return NULL;
27041 }
27042
27043
27044 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27045 PyObject *obj;
27046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27047 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27048 Py_INCREF(obj);
27049 return Py_BuildValue((char *)"");
27050 }
27051 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27052 PyObject *resultobj;
27053 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27054 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27055 wxPyDataObjectSimple *result;
27056 PyObject * obj0 = 0 ;
27057 char *kwnames[] = {
27058 (char *) "format", NULL
27059 };
27060
27061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27062 if (obj0) {
27063 {
27064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27065 if (SWIG_arg_fail(1)) SWIG_fail;
27066 if (arg1 == NULL) {
27067 SWIG_null_ref("wxDataFormat");
27068 }
27069 if (SWIG_arg_fail(1)) SWIG_fail;
27070 }
27071 }
27072 {
27073 PyThreadState* __tstate = wxPyBeginAllowThreads();
27074 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27075
27076 wxPyEndAllowThreads(__tstate);
27077 if (PyErr_Occurred()) SWIG_fail;
27078 }
27079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27080 return resultobj;
27081 fail:
27082 return NULL;
27083 }
27084
27085
27086 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27087 PyObject *resultobj;
27088 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27089 PyObject *arg2 = (PyObject *) 0 ;
27090 PyObject *arg3 = (PyObject *) 0 ;
27091 PyObject * obj0 = 0 ;
27092 PyObject * obj1 = 0 ;
27093 PyObject * obj2 = 0 ;
27094 char *kwnames[] = {
27095 (char *) "self",(char *) "self",(char *) "_class", NULL
27096 };
27097
27098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27100 if (SWIG_arg_fail(1)) SWIG_fail;
27101 arg2 = obj1;
27102 arg3 = obj2;
27103 {
27104 PyThreadState* __tstate = wxPyBeginAllowThreads();
27105 (arg1)->_setCallbackInfo(arg2,arg3);
27106
27107 wxPyEndAllowThreads(__tstate);
27108 if (PyErr_Occurred()) SWIG_fail;
27109 }
27110 Py_INCREF(Py_None); resultobj = Py_None;
27111 return resultobj;
27112 fail:
27113 return NULL;
27114 }
27115
27116
27117 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27118 PyObject *obj;
27119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27120 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27121 Py_INCREF(obj);
27122 return Py_BuildValue((char *)"");
27123 }
27124 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27125 PyObject *resultobj;
27126 wxDataObjectComposite *result;
27127 char *kwnames[] = {
27128 NULL
27129 };
27130
27131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27132 {
27133 PyThreadState* __tstate = wxPyBeginAllowThreads();
27134 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27135
27136 wxPyEndAllowThreads(__tstate);
27137 if (PyErr_Occurred()) SWIG_fail;
27138 }
27139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27140 return resultobj;
27141 fail:
27142 return NULL;
27143 }
27144
27145
27146 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27147 PyObject *resultobj;
27148 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27149 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27150 bool arg3 = (bool) false ;
27151 PyObject * obj0 = 0 ;
27152 PyObject * obj1 = 0 ;
27153 PyObject * obj2 = 0 ;
27154 char *kwnames[] = {
27155 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27156 };
27157
27158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27160 if (SWIG_arg_fail(1)) SWIG_fail;
27161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27162 if (SWIG_arg_fail(2)) SWIG_fail;
27163 if (obj2) {
27164 {
27165 arg3 = (bool)(SWIG_As_bool(obj2));
27166 if (SWIG_arg_fail(3)) SWIG_fail;
27167 }
27168 }
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 (arg1)->Add(arg2,arg3);
27172
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 Py_INCREF(Py_None); resultobj = Py_None;
27177 return resultobj;
27178 fail:
27179 return NULL;
27180 }
27181
27182
27183 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27184 PyObject *obj;
27185 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27186 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27187 Py_INCREF(obj);
27188 return Py_BuildValue((char *)"");
27189 }
27190 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27191 PyObject *resultobj;
27192 wxString const &arg1_defvalue = wxPyEmptyString ;
27193 wxString *arg1 = (wxString *) &arg1_defvalue ;
27194 wxTextDataObject *result;
27195 bool temp1 = false ;
27196 PyObject * obj0 = 0 ;
27197 char *kwnames[] = {
27198 (char *) "text", NULL
27199 };
27200
27201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27202 if (obj0) {
27203 {
27204 arg1 = wxString_in_helper(obj0);
27205 if (arg1 == NULL) SWIG_fail;
27206 temp1 = true;
27207 }
27208 }
27209 {
27210 PyThreadState* __tstate = wxPyBeginAllowThreads();
27211 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27212
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27217 {
27218 if (temp1)
27219 delete arg1;
27220 }
27221 return resultobj;
27222 fail:
27223 {
27224 if (temp1)
27225 delete arg1;
27226 }
27227 return NULL;
27228 }
27229
27230
27231 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27232 PyObject *resultobj;
27233 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27234 size_t result;
27235 PyObject * obj0 = 0 ;
27236 char *kwnames[] = {
27237 (char *) "self", NULL
27238 };
27239
27240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27242 if (SWIG_arg_fail(1)) SWIG_fail;
27243 {
27244 PyThreadState* __tstate = wxPyBeginAllowThreads();
27245 result = (size_t)(arg1)->GetTextLength();
27246
27247 wxPyEndAllowThreads(__tstate);
27248 if (PyErr_Occurred()) SWIG_fail;
27249 }
27250 {
27251 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27252 }
27253 return resultobj;
27254 fail:
27255 return NULL;
27256 }
27257
27258
27259 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27260 PyObject *resultobj;
27261 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27262 wxString result;
27263 PyObject * obj0 = 0 ;
27264 char *kwnames[] = {
27265 (char *) "self", NULL
27266 };
27267
27268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27270 if (SWIG_arg_fail(1)) SWIG_fail;
27271 {
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 result = (arg1)->GetText();
27274
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 {
27279 #if wxUSE_UNICODE
27280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27281 #else
27282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27283 #endif
27284 }
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27292 PyObject *resultobj;
27293 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27294 wxString *arg2 = 0 ;
27295 bool temp2 = false ;
27296 PyObject * obj0 = 0 ;
27297 PyObject * obj1 = 0 ;
27298 char *kwnames[] = {
27299 (char *) "self",(char *) "text", NULL
27300 };
27301
27302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27304 if (SWIG_arg_fail(1)) SWIG_fail;
27305 {
27306 arg2 = wxString_in_helper(obj1);
27307 if (arg2 == NULL) SWIG_fail;
27308 temp2 = true;
27309 }
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 (arg1)->SetText((wxString const &)*arg2);
27313
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 Py_INCREF(Py_None); resultobj = Py_None;
27318 {
27319 if (temp2)
27320 delete arg2;
27321 }
27322 return resultobj;
27323 fail:
27324 {
27325 if (temp2)
27326 delete arg2;
27327 }
27328 return NULL;
27329 }
27330
27331
27332 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27333 PyObject *obj;
27334 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27335 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27336 Py_INCREF(obj);
27337 return Py_BuildValue((char *)"");
27338 }
27339 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27340 PyObject *resultobj;
27341 wxString const &arg1_defvalue = wxPyEmptyString ;
27342 wxString *arg1 = (wxString *) &arg1_defvalue ;
27343 wxPyTextDataObject *result;
27344 bool temp1 = false ;
27345 PyObject * obj0 = 0 ;
27346 char *kwnames[] = {
27347 (char *) "text", NULL
27348 };
27349
27350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27351 if (obj0) {
27352 {
27353 arg1 = wxString_in_helper(obj0);
27354 if (arg1 == NULL) SWIG_fail;
27355 temp1 = true;
27356 }
27357 }
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27361
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27366 {
27367 if (temp1)
27368 delete arg1;
27369 }
27370 return resultobj;
27371 fail:
27372 {
27373 if (temp1)
27374 delete arg1;
27375 }
27376 return NULL;
27377 }
27378
27379
27380 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27381 PyObject *resultobj;
27382 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27383 PyObject *arg2 = (PyObject *) 0 ;
27384 PyObject *arg3 = (PyObject *) 0 ;
27385 PyObject * obj0 = 0 ;
27386 PyObject * obj1 = 0 ;
27387 PyObject * obj2 = 0 ;
27388 char *kwnames[] = {
27389 (char *) "self",(char *) "self",(char *) "_class", NULL
27390 };
27391
27392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27394 if (SWIG_arg_fail(1)) SWIG_fail;
27395 arg2 = obj1;
27396 arg3 = obj2;
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 (arg1)->_setCallbackInfo(arg2,arg3);
27400
27401 wxPyEndAllowThreads(__tstate);
27402 if (PyErr_Occurred()) SWIG_fail;
27403 }
27404 Py_INCREF(Py_None); resultobj = Py_None;
27405 return resultobj;
27406 fail:
27407 return NULL;
27408 }
27409
27410
27411 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27412 PyObject *obj;
27413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27414 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27415 Py_INCREF(obj);
27416 return Py_BuildValue((char *)"");
27417 }
27418 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27419 PyObject *resultobj;
27420 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27421 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27422 wxBitmapDataObject *result;
27423 PyObject * obj0 = 0 ;
27424 char *kwnames[] = {
27425 (char *) "bitmap", NULL
27426 };
27427
27428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27429 if (obj0) {
27430 {
27431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27432 if (SWIG_arg_fail(1)) SWIG_fail;
27433 if (arg1 == NULL) {
27434 SWIG_null_ref("wxBitmap");
27435 }
27436 if (SWIG_arg_fail(1)) SWIG_fail;
27437 }
27438 }
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27442
27443 wxPyEndAllowThreads(__tstate);
27444 if (PyErr_Occurred()) SWIG_fail;
27445 }
27446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27447 return resultobj;
27448 fail:
27449 return NULL;
27450 }
27451
27452
27453 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27454 PyObject *resultobj;
27455 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27456 wxBitmap result;
27457 PyObject * obj0 = 0 ;
27458 char *kwnames[] = {
27459 (char *) "self", NULL
27460 };
27461
27462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27464 if (SWIG_arg_fail(1)) SWIG_fail;
27465 {
27466 PyThreadState* __tstate = wxPyBeginAllowThreads();
27467 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27468
27469 wxPyEndAllowThreads(__tstate);
27470 if (PyErr_Occurred()) SWIG_fail;
27471 }
27472 {
27473 wxBitmap * resultptr;
27474 resultptr = new wxBitmap((wxBitmap &)(result));
27475 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27476 }
27477 return resultobj;
27478 fail:
27479 return NULL;
27480 }
27481
27482
27483 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27484 PyObject *resultobj;
27485 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27486 wxBitmap *arg2 = 0 ;
27487 PyObject * obj0 = 0 ;
27488 PyObject * obj1 = 0 ;
27489 char *kwnames[] = {
27490 (char *) "self",(char *) "bitmap", NULL
27491 };
27492
27493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27495 if (SWIG_arg_fail(1)) SWIG_fail;
27496 {
27497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27498 if (SWIG_arg_fail(2)) SWIG_fail;
27499 if (arg2 == NULL) {
27500 SWIG_null_ref("wxBitmap");
27501 }
27502 if (SWIG_arg_fail(2)) SWIG_fail;
27503 }
27504 {
27505 PyThreadState* __tstate = wxPyBeginAllowThreads();
27506 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27507
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 Py_INCREF(Py_None); resultobj = Py_None;
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27519 PyObject *obj;
27520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27521 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27522 Py_INCREF(obj);
27523 return Py_BuildValue((char *)"");
27524 }
27525 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27526 PyObject *resultobj;
27527 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27528 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27529 wxPyBitmapDataObject *result;
27530 PyObject * obj0 = 0 ;
27531 char *kwnames[] = {
27532 (char *) "bitmap", NULL
27533 };
27534
27535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27536 if (obj0) {
27537 {
27538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27539 if (SWIG_arg_fail(1)) SWIG_fail;
27540 if (arg1 == NULL) {
27541 SWIG_null_ref("wxBitmap");
27542 }
27543 if (SWIG_arg_fail(1)) SWIG_fail;
27544 }
27545 }
27546 {
27547 PyThreadState* __tstate = wxPyBeginAllowThreads();
27548 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27549
27550 wxPyEndAllowThreads(__tstate);
27551 if (PyErr_Occurred()) SWIG_fail;
27552 }
27553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27554 return resultobj;
27555 fail:
27556 return NULL;
27557 }
27558
27559
27560 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27561 PyObject *resultobj;
27562 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27563 PyObject *arg2 = (PyObject *) 0 ;
27564 PyObject *arg3 = (PyObject *) 0 ;
27565 PyObject * obj0 = 0 ;
27566 PyObject * obj1 = 0 ;
27567 PyObject * obj2 = 0 ;
27568 char *kwnames[] = {
27569 (char *) "self",(char *) "self",(char *) "_class", NULL
27570 };
27571
27572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27574 if (SWIG_arg_fail(1)) SWIG_fail;
27575 arg2 = obj1;
27576 arg3 = obj2;
27577 {
27578 PyThreadState* __tstate = wxPyBeginAllowThreads();
27579 (arg1)->_setCallbackInfo(arg2,arg3);
27580
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 Py_INCREF(Py_None); resultobj = Py_None;
27585 return resultobj;
27586 fail:
27587 return NULL;
27588 }
27589
27590
27591 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27592 PyObject *obj;
27593 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27594 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27595 Py_INCREF(obj);
27596 return Py_BuildValue((char *)"");
27597 }
27598 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27599 PyObject *resultobj;
27600 wxFileDataObject *result;
27601 char *kwnames[] = {
27602 NULL
27603 };
27604
27605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27606 {
27607 PyThreadState* __tstate = wxPyBeginAllowThreads();
27608 result = (wxFileDataObject *)new wxFileDataObject();
27609
27610 wxPyEndAllowThreads(__tstate);
27611 if (PyErr_Occurred()) SWIG_fail;
27612 }
27613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27614 return resultobj;
27615 fail:
27616 return NULL;
27617 }
27618
27619
27620 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27621 PyObject *resultobj;
27622 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27623 wxArrayString *result;
27624 PyObject * obj0 = 0 ;
27625 char *kwnames[] = {
27626 (char *) "self", NULL
27627 };
27628
27629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27631 if (SWIG_arg_fail(1)) SWIG_fail;
27632 {
27633 PyThreadState* __tstate = wxPyBeginAllowThreads();
27634 {
27635 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27636 result = (wxArrayString *) &_result_ref;
27637 }
27638
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = wxArrayString2PyList_helper(*result);
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj;
27653 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27654 wxString *arg2 = 0 ;
27655 bool temp2 = false ;
27656 PyObject * obj0 = 0 ;
27657 PyObject * obj1 = 0 ;
27658 char *kwnames[] = {
27659 (char *) "self",(char *) "filename", NULL
27660 };
27661
27662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27664 if (SWIG_arg_fail(1)) SWIG_fail;
27665 {
27666 arg2 = wxString_in_helper(obj1);
27667 if (arg2 == NULL) SWIG_fail;
27668 temp2 = true;
27669 }
27670 {
27671 PyThreadState* __tstate = wxPyBeginAllowThreads();
27672 (arg1)->AddFile((wxString const &)*arg2);
27673
27674 wxPyEndAllowThreads(__tstate);
27675 if (PyErr_Occurred()) SWIG_fail;
27676 }
27677 Py_INCREF(Py_None); resultobj = Py_None;
27678 {
27679 if (temp2)
27680 delete arg2;
27681 }
27682 return resultobj;
27683 fail:
27684 {
27685 if (temp2)
27686 delete arg2;
27687 }
27688 return NULL;
27689 }
27690
27691
27692 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27693 PyObject *obj;
27694 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27695 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27696 Py_INCREF(obj);
27697 return Py_BuildValue((char *)"");
27698 }
27699 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
27700 PyObject *resultobj;
27701 wxDataFormat *arg1 = 0 ;
27702 wxCustomDataObject *result;
27703 PyObject * obj0 = 0 ;
27704
27705 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27706 {
27707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27708 if (SWIG_arg_fail(1)) SWIG_fail;
27709 if (arg1 == NULL) {
27710 SWIG_null_ref("wxDataFormat");
27711 }
27712 if (SWIG_arg_fail(1)) SWIG_fail;
27713 }
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27717
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27722 return resultobj;
27723 fail:
27724 return NULL;
27725 }
27726
27727
27728 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
27729 PyObject *resultobj;
27730 wxString *arg1 = 0 ;
27731 wxCustomDataObject *result;
27732 bool temp1 = false ;
27733 PyObject * obj0 = 0 ;
27734
27735 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27736 {
27737 arg1 = wxString_in_helper(obj0);
27738 if (arg1 == NULL) SWIG_fail;
27739 temp1 = true;
27740 }
27741 {
27742 PyThreadState* __tstate = wxPyBeginAllowThreads();
27743 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
27744
27745 wxPyEndAllowThreads(__tstate);
27746 if (PyErr_Occurred()) SWIG_fail;
27747 }
27748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27749 {
27750 if (temp1)
27751 delete arg1;
27752 }
27753 return resultobj;
27754 fail:
27755 {
27756 if (temp1)
27757 delete arg1;
27758 }
27759 return NULL;
27760 }
27761
27762
27763 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
27764 PyObject *resultobj;
27765 wxCustomDataObject *result;
27766
27767 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
27768 {
27769 PyThreadState* __tstate = wxPyBeginAllowThreads();
27770 result = (wxCustomDataObject *)new wxCustomDataObject();
27771
27772 wxPyEndAllowThreads(__tstate);
27773 if (PyErr_Occurred()) SWIG_fail;
27774 }
27775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27776 return resultobj;
27777 fail:
27778 return NULL;
27779 }
27780
27781
27782 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
27783 int argc;
27784 PyObject *argv[2];
27785 int ii;
27786
27787 argc = PyObject_Length(args);
27788 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
27789 argv[ii] = PyTuple_GetItem(args,ii);
27790 }
27791 if (argc == 0) {
27792 return _wrap_new_CustomDataObject__SWIG_2(self,args);
27793 }
27794 if (argc == 1) {
27795 int _v;
27796 {
27797 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
27798 }
27799 if (_v) {
27800 return _wrap_new_CustomDataObject__SWIG_1(self,args);
27801 }
27802 }
27803 if (argc == 1) {
27804 int _v;
27805 {
27806 void *ptr = 0;
27807 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27808 _v = 0;
27809 PyErr_Clear();
27810 } else {
27811 _v = (ptr != 0);
27812 }
27813 }
27814 if (_v) {
27815 return _wrap_new_CustomDataObject__SWIG_0(self,args);
27816 }
27817 }
27818
27819 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
27820 return NULL;
27821 }
27822
27823
27824 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27825 PyObject *resultobj;
27826 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27827 PyObject *arg2 = (PyObject *) 0 ;
27828 bool result;
27829 PyObject * obj0 = 0 ;
27830 PyObject * obj1 = 0 ;
27831 char *kwnames[] = {
27832 (char *) "self",(char *) "data", NULL
27833 };
27834
27835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27837 if (SWIG_arg_fail(1)) SWIG_fail;
27838 arg2 = obj1;
27839 {
27840 PyThreadState* __tstate = wxPyBeginAllowThreads();
27841 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27842
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 {
27847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27848 }
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27856 PyObject *resultobj;
27857 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27858 size_t result;
27859 PyObject * obj0 = 0 ;
27860 char *kwnames[] = {
27861 (char *) "self", NULL
27862 };
27863
27864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27866 if (SWIG_arg_fail(1)) SWIG_fail;
27867 {
27868 PyThreadState* __tstate = wxPyBeginAllowThreads();
27869 result = (size_t)(arg1)->GetSize();
27870
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 {
27875 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27876 }
27877 return resultobj;
27878 fail:
27879 return NULL;
27880 }
27881
27882
27883 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27884 PyObject *resultobj;
27885 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27886 PyObject *result;
27887 PyObject * obj0 = 0 ;
27888 char *kwnames[] = {
27889 (char *) "self", NULL
27890 };
27891
27892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
27893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27894 if (SWIG_arg_fail(1)) SWIG_fail;
27895 {
27896 PyThreadState* __tstate = wxPyBeginAllowThreads();
27897 result = (PyObject *)wxCustomDataObject_GetData(arg1);
27898
27899 wxPyEndAllowThreads(__tstate);
27900 if (PyErr_Occurred()) SWIG_fail;
27901 }
27902 resultobj = result;
27903 return resultobj;
27904 fail:
27905 return NULL;
27906 }
27907
27908
27909 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
27910 PyObject *obj;
27911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27912 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
27913 Py_INCREF(obj);
27914 return Py_BuildValue((char *)"");
27915 }
27916 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj;
27918 wxURLDataObject *result;
27919 char *kwnames[] = {
27920 NULL
27921 };
27922
27923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 result = (wxURLDataObject *)new wxURLDataObject();
27927
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
27932 return resultobj;
27933 fail:
27934 return NULL;
27935 }
27936
27937
27938 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27939 PyObject *resultobj;
27940 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27941 wxString result;
27942 PyObject * obj0 = 0 ;
27943 char *kwnames[] = {
27944 (char *) "self", NULL
27945 };
27946
27947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
27948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27949 if (SWIG_arg_fail(1)) SWIG_fail;
27950 {
27951 PyThreadState* __tstate = wxPyBeginAllowThreads();
27952 result = (arg1)->GetURL();
27953
27954 wxPyEndAllowThreads(__tstate);
27955 if (PyErr_Occurred()) SWIG_fail;
27956 }
27957 {
27958 #if wxUSE_UNICODE
27959 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27960 #else
27961 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27962 #endif
27963 }
27964 return resultobj;
27965 fail:
27966 return NULL;
27967 }
27968
27969
27970 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27971 PyObject *resultobj;
27972 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27973 wxString *arg2 = 0 ;
27974 bool temp2 = false ;
27975 PyObject * obj0 = 0 ;
27976 PyObject * obj1 = 0 ;
27977 char *kwnames[] = {
27978 (char *) "self",(char *) "url", NULL
27979 };
27980
27981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
27982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27983 if (SWIG_arg_fail(1)) SWIG_fail;
27984 {
27985 arg2 = wxString_in_helper(obj1);
27986 if (arg2 == NULL) SWIG_fail;
27987 temp2 = true;
27988 }
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 (arg1)->SetURL((wxString const &)*arg2);
27992
27993 wxPyEndAllowThreads(__tstate);
27994 if (PyErr_Occurred()) SWIG_fail;
27995 }
27996 Py_INCREF(Py_None); resultobj = Py_None;
27997 {
27998 if (temp2)
27999 delete arg2;
28000 }
28001 return resultobj;
28002 fail:
28003 {
28004 if (temp2)
28005 delete arg2;
28006 }
28007 return NULL;
28008 }
28009
28010
28011 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28012 PyObject *obj;
28013 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28014 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28015 Py_INCREF(obj);
28016 return Py_BuildValue((char *)"");
28017 }
28018 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28019 PyObject *resultobj;
28020 wxMetafileDataObject *result;
28021 char *kwnames[] = {
28022 NULL
28023 };
28024
28025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28029
28030 wxPyEndAllowThreads(__tstate);
28031 if (PyErr_Occurred()) SWIG_fail;
28032 }
28033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28034 return resultobj;
28035 fail:
28036 return NULL;
28037 }
28038
28039
28040 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28041 PyObject *resultobj;
28042 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28043 wxMetafile *arg2 = 0 ;
28044 PyObject * obj0 = 0 ;
28045 PyObject * obj1 = 0 ;
28046 char *kwnames[] = {
28047 (char *) "self",(char *) "metafile", NULL
28048 };
28049
28050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28052 if (SWIG_arg_fail(1)) SWIG_fail;
28053 {
28054 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28055 if (SWIG_arg_fail(2)) SWIG_fail;
28056 if (arg2 == NULL) {
28057 SWIG_null_ref("wxMetafile");
28058 }
28059 if (SWIG_arg_fail(2)) SWIG_fail;
28060 }
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28064
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 Py_INCREF(Py_None); resultobj = Py_None;
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28076 PyObject *resultobj;
28077 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28078 wxMetafile result;
28079 PyObject * obj0 = 0 ;
28080 char *kwnames[] = {
28081 (char *) "self", NULL
28082 };
28083
28084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28086 if (SWIG_arg_fail(1)) SWIG_fail;
28087 {
28088 PyThreadState* __tstate = wxPyBeginAllowThreads();
28089 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28090
28091 wxPyEndAllowThreads(__tstate);
28092 if (PyErr_Occurred()) SWIG_fail;
28093 }
28094 {
28095 wxMetafile * resultptr;
28096 resultptr = new wxMetafile((wxMetafile &)(result));
28097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28098 }
28099 return resultobj;
28100 fail:
28101 return NULL;
28102 }
28103
28104
28105 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28106 PyObject *obj;
28107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28108 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28109 Py_INCREF(obj);
28110 return Py_BuildValue((char *)"");
28111 }
28112 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj;
28114 wxDragResult arg1 ;
28115 bool result;
28116 PyObject * obj0 = 0 ;
28117 char *kwnames[] = {
28118 (char *) "res", NULL
28119 };
28120
28121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28122 {
28123 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28124 if (SWIG_arg_fail(1)) SWIG_fail;
28125 }
28126 {
28127 PyThreadState* __tstate = wxPyBeginAllowThreads();
28128 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28129
28130 wxPyEndAllowThreads(__tstate);
28131 if (PyErr_Occurred()) SWIG_fail;
28132 }
28133 {
28134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28135 }
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28143 PyObject *resultobj;
28144 wxWindow *arg1 = (wxWindow *) 0 ;
28145 wxCursor const &arg2_defvalue = wxNullCursor ;
28146 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28147 wxCursor const &arg3_defvalue = wxNullCursor ;
28148 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28149 wxCursor const &arg4_defvalue = wxNullCursor ;
28150 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28151 wxPyDropSource *result;
28152 PyObject * obj0 = 0 ;
28153 PyObject * obj1 = 0 ;
28154 PyObject * obj2 = 0 ;
28155 PyObject * obj3 = 0 ;
28156 char *kwnames[] = {
28157 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28158 };
28159
28160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28162 if (SWIG_arg_fail(1)) SWIG_fail;
28163 if (obj1) {
28164 {
28165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28166 if (SWIG_arg_fail(2)) SWIG_fail;
28167 if (arg2 == NULL) {
28168 SWIG_null_ref("wxCursor");
28169 }
28170 if (SWIG_arg_fail(2)) SWIG_fail;
28171 }
28172 }
28173 if (obj2) {
28174 {
28175 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28176 if (SWIG_arg_fail(3)) SWIG_fail;
28177 if (arg3 == NULL) {
28178 SWIG_null_ref("wxCursor");
28179 }
28180 if (SWIG_arg_fail(3)) SWIG_fail;
28181 }
28182 }
28183 if (obj3) {
28184 {
28185 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28186 if (SWIG_arg_fail(4)) SWIG_fail;
28187 if (arg4 == NULL) {
28188 SWIG_null_ref("wxCursor");
28189 }
28190 if (SWIG_arg_fail(4)) SWIG_fail;
28191 }
28192 }
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28196
28197 wxPyEndAllowThreads(__tstate);
28198 if (PyErr_Occurred()) SWIG_fail;
28199 }
28200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28201 return resultobj;
28202 fail:
28203 return NULL;
28204 }
28205
28206
28207 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28208 PyObject *resultobj;
28209 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28210 PyObject *arg2 = (PyObject *) 0 ;
28211 PyObject *arg3 = (PyObject *) 0 ;
28212 int arg4 ;
28213 PyObject * obj0 = 0 ;
28214 PyObject * obj1 = 0 ;
28215 PyObject * obj2 = 0 ;
28216 PyObject * obj3 = 0 ;
28217 char *kwnames[] = {
28218 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28219 };
28220
28221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28223 if (SWIG_arg_fail(1)) SWIG_fail;
28224 arg2 = obj1;
28225 arg3 = obj2;
28226 {
28227 arg4 = (int)(SWIG_As_int(obj3));
28228 if (SWIG_arg_fail(4)) SWIG_fail;
28229 }
28230 {
28231 PyThreadState* __tstate = wxPyBeginAllowThreads();
28232 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28233
28234 wxPyEndAllowThreads(__tstate);
28235 if (PyErr_Occurred()) SWIG_fail;
28236 }
28237 Py_INCREF(Py_None); resultobj = Py_None;
28238 return resultobj;
28239 fail:
28240 return NULL;
28241 }
28242
28243
28244 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28245 PyObject *resultobj;
28246 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28247 PyObject * obj0 = 0 ;
28248 char *kwnames[] = {
28249 (char *) "self", NULL
28250 };
28251
28252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28254 if (SWIG_arg_fail(1)) SWIG_fail;
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 delete arg1;
28258
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 Py_INCREF(Py_None); resultobj = Py_None;
28263 return resultobj;
28264 fail:
28265 return NULL;
28266 }
28267
28268
28269 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28270 PyObject *resultobj;
28271 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28272 wxDataObject *arg2 = 0 ;
28273 PyObject * obj0 = 0 ;
28274 PyObject * obj1 = 0 ;
28275 char *kwnames[] = {
28276 (char *) "self",(char *) "data", NULL
28277 };
28278
28279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28281 if (SWIG_arg_fail(1)) SWIG_fail;
28282 {
28283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28284 if (SWIG_arg_fail(2)) SWIG_fail;
28285 if (arg2 == NULL) {
28286 SWIG_null_ref("wxDataObject");
28287 }
28288 if (SWIG_arg_fail(2)) SWIG_fail;
28289 }
28290 {
28291 PyThreadState* __tstate = wxPyBeginAllowThreads();
28292 (arg1)->SetData(*arg2);
28293
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 Py_INCREF(Py_None); resultobj = Py_None;
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28305 PyObject *resultobj;
28306 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28307 wxDataObject *result;
28308 PyObject * obj0 = 0 ;
28309 char *kwnames[] = {
28310 (char *) "self", NULL
28311 };
28312
28313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28315 if (SWIG_arg_fail(1)) SWIG_fail;
28316 {
28317 PyThreadState* __tstate = wxPyBeginAllowThreads();
28318 result = (wxDataObject *)(arg1)->GetDataObject();
28319
28320 wxPyEndAllowThreads(__tstate);
28321 if (PyErr_Occurred()) SWIG_fail;
28322 }
28323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28324 return resultobj;
28325 fail:
28326 return NULL;
28327 }
28328
28329
28330 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28331 PyObject *resultobj;
28332 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28333 wxDragResult arg2 ;
28334 wxCursor *arg3 = 0 ;
28335 PyObject * obj0 = 0 ;
28336 PyObject * obj1 = 0 ;
28337 PyObject * obj2 = 0 ;
28338 char *kwnames[] = {
28339 (char *) "self",(char *) "res",(char *) "cursor", NULL
28340 };
28341
28342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28344 if (SWIG_arg_fail(1)) SWIG_fail;
28345 {
28346 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28347 if (SWIG_arg_fail(2)) SWIG_fail;
28348 }
28349 {
28350 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28351 if (SWIG_arg_fail(3)) SWIG_fail;
28352 if (arg3 == NULL) {
28353 SWIG_null_ref("wxCursor");
28354 }
28355 if (SWIG_arg_fail(3)) SWIG_fail;
28356 }
28357 {
28358 PyThreadState* __tstate = wxPyBeginAllowThreads();
28359 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28360
28361 wxPyEndAllowThreads(__tstate);
28362 if (PyErr_Occurred()) SWIG_fail;
28363 }
28364 Py_INCREF(Py_None); resultobj = Py_None;
28365 return resultobj;
28366 fail:
28367 return NULL;
28368 }
28369
28370
28371 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28372 PyObject *resultobj;
28373 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28374 int arg2 = (int) wxDrag_CopyOnly ;
28375 wxDragResult result;
28376 PyObject * obj0 = 0 ;
28377 PyObject * obj1 = 0 ;
28378 char *kwnames[] = {
28379 (char *) "self",(char *) "flags", NULL
28380 };
28381
28382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28384 if (SWIG_arg_fail(1)) SWIG_fail;
28385 if (obj1) {
28386 {
28387 arg2 = (int)(SWIG_As_int(obj1));
28388 if (SWIG_arg_fail(2)) SWIG_fail;
28389 }
28390 }
28391 {
28392 PyThreadState* __tstate = wxPyBeginAllowThreads();
28393 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28394
28395 wxPyEndAllowThreads(__tstate);
28396 if (PyErr_Occurred()) SWIG_fail;
28397 }
28398 resultobj = SWIG_From_int((result));
28399 return resultobj;
28400 fail:
28401 return NULL;
28402 }
28403
28404
28405 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28406 PyObject *resultobj;
28407 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28408 wxDragResult arg2 ;
28409 bool result;
28410 PyObject * obj0 = 0 ;
28411 PyObject * obj1 = 0 ;
28412 char *kwnames[] = {
28413 (char *) "self",(char *) "effect", NULL
28414 };
28415
28416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28418 if (SWIG_arg_fail(1)) SWIG_fail;
28419 {
28420 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28421 if (SWIG_arg_fail(2)) SWIG_fail;
28422 }
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28426
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 {
28431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28432 }
28433 return resultobj;
28434 fail:
28435 return NULL;
28436 }
28437
28438
28439 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28440 PyObject *obj;
28441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28442 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28443 Py_INCREF(obj);
28444 return Py_BuildValue((char *)"");
28445 }
28446 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj;
28448 wxDataObject *arg1 = (wxDataObject *) NULL ;
28449 wxPyDropTarget *result;
28450 PyObject * obj0 = 0 ;
28451 char *kwnames[] = {
28452 (char *) "dataObject", NULL
28453 };
28454
28455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28456 if (obj0) {
28457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28458 if (SWIG_arg_fail(1)) SWIG_fail;
28459 }
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28463
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28475 PyObject *resultobj;
28476 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28477 PyObject *arg2 = (PyObject *) 0 ;
28478 PyObject *arg3 = (PyObject *) 0 ;
28479 PyObject * obj0 = 0 ;
28480 PyObject * obj1 = 0 ;
28481 PyObject * obj2 = 0 ;
28482 char *kwnames[] = {
28483 (char *) "self",(char *) "self",(char *) "_class", NULL
28484 };
28485
28486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28488 if (SWIG_arg_fail(1)) SWIG_fail;
28489 arg2 = obj1;
28490 arg3 = obj2;
28491 {
28492 PyThreadState* __tstate = wxPyBeginAllowThreads();
28493 (arg1)->_setCallbackInfo(arg2,arg3);
28494
28495 wxPyEndAllowThreads(__tstate);
28496 if (PyErr_Occurred()) SWIG_fail;
28497 }
28498 Py_INCREF(Py_None); resultobj = Py_None;
28499 return resultobj;
28500 fail:
28501 return NULL;
28502 }
28503
28504
28505 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28506 PyObject *resultobj;
28507 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28508 PyObject * obj0 = 0 ;
28509 char *kwnames[] = {
28510 (char *) "self", NULL
28511 };
28512
28513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28515 if (SWIG_arg_fail(1)) SWIG_fail;
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 delete arg1;
28519
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 Py_INCREF(Py_None); resultobj = Py_None;
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28531 PyObject *resultobj;
28532 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28533 wxDataObject *result;
28534 PyObject * obj0 = 0 ;
28535 char *kwnames[] = {
28536 (char *) "self", NULL
28537 };
28538
28539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28541 if (SWIG_arg_fail(1)) SWIG_fail;
28542 {
28543 PyThreadState* __tstate = wxPyBeginAllowThreads();
28544 result = (wxDataObject *)(arg1)->GetDataObject();
28545
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28550 return resultobj;
28551 fail:
28552 return NULL;
28553 }
28554
28555
28556 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28557 PyObject *resultobj;
28558 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28559 wxDataObject *arg2 = (wxDataObject *) 0 ;
28560 PyObject * obj0 = 0 ;
28561 PyObject * obj1 = 0 ;
28562 char *kwnames[] = {
28563 (char *) "self",(char *) "dataObject", NULL
28564 };
28565
28566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28568 if (SWIG_arg_fail(1)) SWIG_fail;
28569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28570 if (SWIG_arg_fail(2)) SWIG_fail;
28571 {
28572 PyThreadState* __tstate = wxPyBeginAllowThreads();
28573 (arg1)->SetDataObject(arg2);
28574
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 Py_INCREF(Py_None); resultobj = Py_None;
28579 return resultobj;
28580 fail:
28581 return NULL;
28582 }
28583
28584
28585 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28586 PyObject *resultobj;
28587 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28588 int arg2 ;
28589 int arg3 ;
28590 wxDragResult arg4 ;
28591 wxDragResult result;
28592 PyObject * obj0 = 0 ;
28593 PyObject * obj1 = 0 ;
28594 PyObject * obj2 = 0 ;
28595 PyObject * obj3 = 0 ;
28596 char *kwnames[] = {
28597 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28598 };
28599
28600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28602 if (SWIG_arg_fail(1)) SWIG_fail;
28603 {
28604 arg2 = (int)(SWIG_As_int(obj1));
28605 if (SWIG_arg_fail(2)) SWIG_fail;
28606 }
28607 {
28608 arg3 = (int)(SWIG_As_int(obj2));
28609 if (SWIG_arg_fail(3)) SWIG_fail;
28610 }
28611 {
28612 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28613 if (SWIG_arg_fail(4)) SWIG_fail;
28614 }
28615 {
28616 PyThreadState* __tstate = wxPyBeginAllowThreads();
28617 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28618
28619 wxPyEndAllowThreads(__tstate);
28620 if (PyErr_Occurred()) SWIG_fail;
28621 }
28622 resultobj = SWIG_From_int((result));
28623 return resultobj;
28624 fail:
28625 return NULL;
28626 }
28627
28628
28629 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28630 PyObject *resultobj;
28631 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28632 int arg2 ;
28633 int arg3 ;
28634 wxDragResult arg4 ;
28635 wxDragResult result;
28636 PyObject * obj0 = 0 ;
28637 PyObject * obj1 = 0 ;
28638 PyObject * obj2 = 0 ;
28639 PyObject * obj3 = 0 ;
28640 char *kwnames[] = {
28641 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28642 };
28643
28644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28646 if (SWIG_arg_fail(1)) SWIG_fail;
28647 {
28648 arg2 = (int)(SWIG_As_int(obj1));
28649 if (SWIG_arg_fail(2)) SWIG_fail;
28650 }
28651 {
28652 arg3 = (int)(SWIG_As_int(obj2));
28653 if (SWIG_arg_fail(3)) SWIG_fail;
28654 }
28655 {
28656 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28657 if (SWIG_arg_fail(4)) SWIG_fail;
28658 }
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28662
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 resultobj = SWIG_From_int((result));
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28674 PyObject *resultobj;
28675 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28676 PyObject * obj0 = 0 ;
28677 char *kwnames[] = {
28678 (char *) "self", NULL
28679 };
28680
28681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28683 if (SWIG_arg_fail(1)) SWIG_fail;
28684 {
28685 PyThreadState* __tstate = wxPyBeginAllowThreads();
28686 (arg1)->base_OnLeave();
28687
28688 wxPyEndAllowThreads(__tstate);
28689 if (PyErr_Occurred()) SWIG_fail;
28690 }
28691 Py_INCREF(Py_None); resultobj = Py_None;
28692 return resultobj;
28693 fail:
28694 return NULL;
28695 }
28696
28697
28698 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28699 PyObject *resultobj;
28700 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28701 int arg2 ;
28702 int arg3 ;
28703 bool result;
28704 PyObject * obj0 = 0 ;
28705 PyObject * obj1 = 0 ;
28706 PyObject * obj2 = 0 ;
28707 char *kwnames[] = {
28708 (char *) "self",(char *) "x",(char *) "y", NULL
28709 };
28710
28711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28713 if (SWIG_arg_fail(1)) SWIG_fail;
28714 {
28715 arg2 = (int)(SWIG_As_int(obj1));
28716 if (SWIG_arg_fail(2)) SWIG_fail;
28717 }
28718 {
28719 arg3 = (int)(SWIG_As_int(obj2));
28720 if (SWIG_arg_fail(3)) SWIG_fail;
28721 }
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28725
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 {
28730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28731 }
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28739 PyObject *resultobj;
28740 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28741 bool result;
28742 PyObject * obj0 = 0 ;
28743 char *kwnames[] = {
28744 (char *) "self", NULL
28745 };
28746
28747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28749 if (SWIG_arg_fail(1)) SWIG_fail;
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (bool)(arg1)->GetData();
28753
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 {
28758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28759 }
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28767 PyObject *obj;
28768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28769 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28770 Py_INCREF(obj);
28771 return Py_BuildValue((char *)"");
28772 }
28773 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28774 PyObject *resultobj;
28775 wxPyTextDropTarget *result;
28776 char *kwnames[] = {
28777 NULL
28778 };
28779
28780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28784
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28796 PyObject *resultobj;
28797 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28798 PyObject *arg2 = (PyObject *) 0 ;
28799 PyObject *arg3 = (PyObject *) 0 ;
28800 PyObject * obj0 = 0 ;
28801 PyObject * obj1 = 0 ;
28802 PyObject * obj2 = 0 ;
28803 char *kwnames[] = {
28804 (char *) "self",(char *) "self",(char *) "_class", NULL
28805 };
28806
28807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28809 if (SWIG_arg_fail(1)) SWIG_fail;
28810 arg2 = obj1;
28811 arg3 = obj2;
28812 {
28813 PyThreadState* __tstate = wxPyBeginAllowThreads();
28814 (arg1)->_setCallbackInfo(arg2,arg3);
28815
28816 wxPyEndAllowThreads(__tstate);
28817 if (PyErr_Occurred()) SWIG_fail;
28818 }
28819 Py_INCREF(Py_None); resultobj = Py_None;
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28827 PyObject *resultobj;
28828 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28829 int arg2 ;
28830 int arg3 ;
28831 wxDragResult arg4 ;
28832 wxDragResult result;
28833 PyObject * obj0 = 0 ;
28834 PyObject * obj1 = 0 ;
28835 PyObject * obj2 = 0 ;
28836 PyObject * obj3 = 0 ;
28837 char *kwnames[] = {
28838 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28839 };
28840
28841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28843 if (SWIG_arg_fail(1)) SWIG_fail;
28844 {
28845 arg2 = (int)(SWIG_As_int(obj1));
28846 if (SWIG_arg_fail(2)) SWIG_fail;
28847 }
28848 {
28849 arg3 = (int)(SWIG_As_int(obj2));
28850 if (SWIG_arg_fail(3)) SWIG_fail;
28851 }
28852 {
28853 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28854 if (SWIG_arg_fail(4)) SWIG_fail;
28855 }
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28859
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 resultobj = SWIG_From_int((result));
28864 return resultobj;
28865 fail:
28866 return NULL;
28867 }
28868
28869
28870 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28871 PyObject *resultobj;
28872 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28873 int arg2 ;
28874 int arg3 ;
28875 wxDragResult arg4 ;
28876 wxDragResult result;
28877 PyObject * obj0 = 0 ;
28878 PyObject * obj1 = 0 ;
28879 PyObject * obj2 = 0 ;
28880 PyObject * obj3 = 0 ;
28881 char *kwnames[] = {
28882 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28883 };
28884
28885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28887 if (SWIG_arg_fail(1)) SWIG_fail;
28888 {
28889 arg2 = (int)(SWIG_As_int(obj1));
28890 if (SWIG_arg_fail(2)) SWIG_fail;
28891 }
28892 {
28893 arg3 = (int)(SWIG_As_int(obj2));
28894 if (SWIG_arg_fail(3)) SWIG_fail;
28895 }
28896 {
28897 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28898 if (SWIG_arg_fail(4)) SWIG_fail;
28899 }
28900 {
28901 PyThreadState* __tstate = wxPyBeginAllowThreads();
28902 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28903
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 resultobj = SWIG_From_int((result));
28908 return resultobj;
28909 fail:
28910 return NULL;
28911 }
28912
28913
28914 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28915 PyObject *resultobj;
28916 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28917 PyObject * obj0 = 0 ;
28918 char *kwnames[] = {
28919 (char *) "self", NULL
28920 };
28921
28922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28924 if (SWIG_arg_fail(1)) SWIG_fail;
28925 {
28926 PyThreadState* __tstate = wxPyBeginAllowThreads();
28927 (arg1)->base_OnLeave();
28928
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 Py_INCREF(Py_None); resultobj = Py_None;
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28940 PyObject *resultobj;
28941 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28942 int arg2 ;
28943 int arg3 ;
28944 bool result;
28945 PyObject * obj0 = 0 ;
28946 PyObject * obj1 = 0 ;
28947 PyObject * obj2 = 0 ;
28948 char *kwnames[] = {
28949 (char *) "self",(char *) "x",(char *) "y", NULL
28950 };
28951
28952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28954 if (SWIG_arg_fail(1)) SWIG_fail;
28955 {
28956 arg2 = (int)(SWIG_As_int(obj1));
28957 if (SWIG_arg_fail(2)) SWIG_fail;
28958 }
28959 {
28960 arg3 = (int)(SWIG_As_int(obj2));
28961 if (SWIG_arg_fail(3)) SWIG_fail;
28962 }
28963 {
28964 PyThreadState* __tstate = wxPyBeginAllowThreads();
28965 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28966
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 {
28971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28972 }
28973 return resultobj;
28974 fail:
28975 return NULL;
28976 }
28977
28978
28979 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
28980 PyObject *resultobj;
28981 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28982 int arg2 ;
28983 int arg3 ;
28984 wxDragResult arg4 ;
28985 wxDragResult result;
28986 PyObject * obj0 = 0 ;
28987 PyObject * obj1 = 0 ;
28988 PyObject * obj2 = 0 ;
28989 PyObject * obj3 = 0 ;
28990 char *kwnames[] = {
28991 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28992 };
28993
28994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28996 if (SWIG_arg_fail(1)) SWIG_fail;
28997 {
28998 arg2 = (int)(SWIG_As_int(obj1));
28999 if (SWIG_arg_fail(2)) SWIG_fail;
29000 }
29001 {
29002 arg3 = (int)(SWIG_As_int(obj2));
29003 if (SWIG_arg_fail(3)) SWIG_fail;
29004 }
29005 {
29006 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29007 if (SWIG_arg_fail(4)) SWIG_fail;
29008 }
29009 {
29010 PyThreadState* __tstate = wxPyBeginAllowThreads();
29011 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29012
29013 wxPyEndAllowThreads(__tstate);
29014 if (PyErr_Occurred()) SWIG_fail;
29015 }
29016 resultobj = SWIG_From_int((result));
29017 return resultobj;
29018 fail:
29019 return NULL;
29020 }
29021
29022
29023 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29024 PyObject *obj;
29025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29026 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29027 Py_INCREF(obj);
29028 return Py_BuildValue((char *)"");
29029 }
29030 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj;
29032 wxPyFileDropTarget *result;
29033 char *kwnames[] = {
29034 NULL
29035 };
29036
29037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29041
29042 wxPyEndAllowThreads(__tstate);
29043 if (PyErr_Occurred()) SWIG_fail;
29044 }
29045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29046 return resultobj;
29047 fail:
29048 return NULL;
29049 }
29050
29051
29052 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29053 PyObject *resultobj;
29054 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29055 PyObject *arg2 = (PyObject *) 0 ;
29056 PyObject *arg3 = (PyObject *) 0 ;
29057 PyObject * obj0 = 0 ;
29058 PyObject * obj1 = 0 ;
29059 PyObject * obj2 = 0 ;
29060 char *kwnames[] = {
29061 (char *) "self",(char *) "self",(char *) "_class", NULL
29062 };
29063
29064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29066 if (SWIG_arg_fail(1)) SWIG_fail;
29067 arg2 = obj1;
29068 arg3 = obj2;
29069 {
29070 PyThreadState* __tstate = wxPyBeginAllowThreads();
29071 (arg1)->_setCallbackInfo(arg2,arg3);
29072
29073 wxPyEndAllowThreads(__tstate);
29074 if (PyErr_Occurred()) SWIG_fail;
29075 }
29076 Py_INCREF(Py_None); resultobj = Py_None;
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29084 PyObject *resultobj;
29085 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29086 int arg2 ;
29087 int arg3 ;
29088 wxDragResult arg4 ;
29089 wxDragResult result;
29090 PyObject * obj0 = 0 ;
29091 PyObject * obj1 = 0 ;
29092 PyObject * obj2 = 0 ;
29093 PyObject * obj3 = 0 ;
29094 char *kwnames[] = {
29095 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29096 };
29097
29098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29100 if (SWIG_arg_fail(1)) SWIG_fail;
29101 {
29102 arg2 = (int)(SWIG_As_int(obj1));
29103 if (SWIG_arg_fail(2)) SWIG_fail;
29104 }
29105 {
29106 arg3 = (int)(SWIG_As_int(obj2));
29107 if (SWIG_arg_fail(3)) SWIG_fail;
29108 }
29109 {
29110 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29111 if (SWIG_arg_fail(4)) SWIG_fail;
29112 }
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29116
29117 wxPyEndAllowThreads(__tstate);
29118 if (PyErr_Occurred()) SWIG_fail;
29119 }
29120 resultobj = SWIG_From_int((result));
29121 return resultobj;
29122 fail:
29123 return NULL;
29124 }
29125
29126
29127 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29128 PyObject *resultobj;
29129 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29130 int arg2 ;
29131 int arg3 ;
29132 wxDragResult arg4 ;
29133 wxDragResult result;
29134 PyObject * obj0 = 0 ;
29135 PyObject * obj1 = 0 ;
29136 PyObject * obj2 = 0 ;
29137 PyObject * obj3 = 0 ;
29138 char *kwnames[] = {
29139 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29140 };
29141
29142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29144 if (SWIG_arg_fail(1)) SWIG_fail;
29145 {
29146 arg2 = (int)(SWIG_As_int(obj1));
29147 if (SWIG_arg_fail(2)) SWIG_fail;
29148 }
29149 {
29150 arg3 = (int)(SWIG_As_int(obj2));
29151 if (SWIG_arg_fail(3)) SWIG_fail;
29152 }
29153 {
29154 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29155 if (SWIG_arg_fail(4)) SWIG_fail;
29156 }
29157 {
29158 PyThreadState* __tstate = wxPyBeginAllowThreads();
29159 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29160
29161 wxPyEndAllowThreads(__tstate);
29162 if (PyErr_Occurred()) SWIG_fail;
29163 }
29164 resultobj = SWIG_From_int((result));
29165 return resultobj;
29166 fail:
29167 return NULL;
29168 }
29169
29170
29171 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29172 PyObject *resultobj;
29173 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29174 PyObject * obj0 = 0 ;
29175 char *kwnames[] = {
29176 (char *) "self", NULL
29177 };
29178
29179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29181 if (SWIG_arg_fail(1)) SWIG_fail;
29182 {
29183 PyThreadState* __tstate = wxPyBeginAllowThreads();
29184 (arg1)->base_OnLeave();
29185
29186 wxPyEndAllowThreads(__tstate);
29187 if (PyErr_Occurred()) SWIG_fail;
29188 }
29189 Py_INCREF(Py_None); resultobj = Py_None;
29190 return resultobj;
29191 fail:
29192 return NULL;
29193 }
29194
29195
29196 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29197 PyObject *resultobj;
29198 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29199 int arg2 ;
29200 int arg3 ;
29201 bool result;
29202 PyObject * obj0 = 0 ;
29203 PyObject * obj1 = 0 ;
29204 PyObject * obj2 = 0 ;
29205 char *kwnames[] = {
29206 (char *) "self",(char *) "x",(char *) "y", NULL
29207 };
29208
29209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29211 if (SWIG_arg_fail(1)) SWIG_fail;
29212 {
29213 arg2 = (int)(SWIG_As_int(obj1));
29214 if (SWIG_arg_fail(2)) SWIG_fail;
29215 }
29216 {
29217 arg3 = (int)(SWIG_As_int(obj2));
29218 if (SWIG_arg_fail(3)) SWIG_fail;
29219 }
29220 {
29221 PyThreadState* __tstate = wxPyBeginAllowThreads();
29222 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29223
29224 wxPyEndAllowThreads(__tstate);
29225 if (PyErr_Occurred()) SWIG_fail;
29226 }
29227 {
29228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29229 }
29230 return resultobj;
29231 fail:
29232 return NULL;
29233 }
29234
29235
29236 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29237 PyObject *resultobj;
29238 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29239 int arg2 ;
29240 int arg3 ;
29241 wxDragResult arg4 ;
29242 wxDragResult result;
29243 PyObject * obj0 = 0 ;
29244 PyObject * obj1 = 0 ;
29245 PyObject * obj2 = 0 ;
29246 PyObject * obj3 = 0 ;
29247 char *kwnames[] = {
29248 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29249 };
29250
29251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29253 if (SWIG_arg_fail(1)) SWIG_fail;
29254 {
29255 arg2 = (int)(SWIG_As_int(obj1));
29256 if (SWIG_arg_fail(2)) SWIG_fail;
29257 }
29258 {
29259 arg3 = (int)(SWIG_As_int(obj2));
29260 if (SWIG_arg_fail(3)) SWIG_fail;
29261 }
29262 {
29263 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29264 if (SWIG_arg_fail(4)) SWIG_fail;
29265 }
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29269
29270 wxPyEndAllowThreads(__tstate);
29271 if (PyErr_Occurred()) SWIG_fail;
29272 }
29273 resultobj = SWIG_From_int((result));
29274 return resultobj;
29275 fail:
29276 return NULL;
29277 }
29278
29279
29280 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29281 PyObject *obj;
29282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29283 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29284 Py_INCREF(obj);
29285 return Py_BuildValue((char *)"");
29286 }
29287 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29288 PyObject *resultobj;
29289 wxClipboard *result;
29290 char *kwnames[] = {
29291 NULL
29292 };
29293
29294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29295 {
29296 PyThreadState* __tstate = wxPyBeginAllowThreads();
29297 result = (wxClipboard *)new wxClipboard();
29298
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29310 PyObject *resultobj;
29311 wxClipboard *arg1 = (wxClipboard *) 0 ;
29312 PyObject * obj0 = 0 ;
29313 char *kwnames[] = {
29314 (char *) "self", NULL
29315 };
29316
29317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29319 if (SWIG_arg_fail(1)) SWIG_fail;
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 delete arg1;
29323
29324 wxPyEndAllowThreads(__tstate);
29325 if (PyErr_Occurred()) SWIG_fail;
29326 }
29327 Py_INCREF(Py_None); resultobj = Py_None;
29328 return resultobj;
29329 fail:
29330 return NULL;
29331 }
29332
29333
29334 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29335 PyObject *resultobj;
29336 wxClipboard *arg1 = (wxClipboard *) 0 ;
29337 bool result;
29338 PyObject * obj0 = 0 ;
29339 char *kwnames[] = {
29340 (char *) "self", NULL
29341 };
29342
29343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29345 if (SWIG_arg_fail(1)) SWIG_fail;
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 result = (bool)(arg1)->Open();
29349
29350 wxPyEndAllowThreads(__tstate);
29351 if (PyErr_Occurred()) SWIG_fail;
29352 }
29353 {
29354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29355 }
29356 return resultobj;
29357 fail:
29358 return NULL;
29359 }
29360
29361
29362 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29363 PyObject *resultobj;
29364 wxClipboard *arg1 = (wxClipboard *) 0 ;
29365 PyObject * obj0 = 0 ;
29366 char *kwnames[] = {
29367 (char *) "self", NULL
29368 };
29369
29370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29372 if (SWIG_arg_fail(1)) SWIG_fail;
29373 {
29374 PyThreadState* __tstate = wxPyBeginAllowThreads();
29375 (arg1)->Close();
29376
29377 wxPyEndAllowThreads(__tstate);
29378 if (PyErr_Occurred()) SWIG_fail;
29379 }
29380 Py_INCREF(Py_None); resultobj = Py_None;
29381 return resultobj;
29382 fail:
29383 return NULL;
29384 }
29385
29386
29387 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29388 PyObject *resultobj;
29389 wxClipboard *arg1 = (wxClipboard *) 0 ;
29390 bool result;
29391 PyObject * obj0 = 0 ;
29392 char *kwnames[] = {
29393 (char *) "self", NULL
29394 };
29395
29396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29398 if (SWIG_arg_fail(1)) SWIG_fail;
29399 {
29400 PyThreadState* __tstate = wxPyBeginAllowThreads();
29401 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29402
29403 wxPyEndAllowThreads(__tstate);
29404 if (PyErr_Occurred()) SWIG_fail;
29405 }
29406 {
29407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29408 }
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29416 PyObject *resultobj;
29417 wxClipboard *arg1 = (wxClipboard *) 0 ;
29418 wxDataObject *arg2 = (wxDataObject *) 0 ;
29419 bool result;
29420 PyObject * obj0 = 0 ;
29421 PyObject * obj1 = 0 ;
29422 char *kwnames[] = {
29423 (char *) "self",(char *) "data", NULL
29424 };
29425
29426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29428 if (SWIG_arg_fail(1)) SWIG_fail;
29429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29430 if (SWIG_arg_fail(2)) SWIG_fail;
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 result = (bool)(arg1)->AddData(arg2);
29434
29435 wxPyEndAllowThreads(__tstate);
29436 if (PyErr_Occurred()) SWIG_fail;
29437 }
29438 {
29439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29440 }
29441 return resultobj;
29442 fail:
29443 return NULL;
29444 }
29445
29446
29447 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29448 PyObject *resultobj;
29449 wxClipboard *arg1 = (wxClipboard *) 0 ;
29450 wxDataObject *arg2 = (wxDataObject *) 0 ;
29451 bool result;
29452 PyObject * obj0 = 0 ;
29453 PyObject * obj1 = 0 ;
29454 char *kwnames[] = {
29455 (char *) "self",(char *) "data", NULL
29456 };
29457
29458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29460 if (SWIG_arg_fail(1)) SWIG_fail;
29461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29462 if (SWIG_arg_fail(2)) SWIG_fail;
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (bool)(arg1)->SetData(arg2);
29466
29467 wxPyEndAllowThreads(__tstate);
29468 if (PyErr_Occurred()) SWIG_fail;
29469 }
29470 {
29471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29472 }
29473 return resultobj;
29474 fail:
29475 return NULL;
29476 }
29477
29478
29479 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29480 PyObject *resultobj;
29481 wxClipboard *arg1 = (wxClipboard *) 0 ;
29482 wxDataFormat *arg2 = 0 ;
29483 bool result;
29484 PyObject * obj0 = 0 ;
29485 PyObject * obj1 = 0 ;
29486 char *kwnames[] = {
29487 (char *) "self",(char *) "format", NULL
29488 };
29489
29490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29492 if (SWIG_arg_fail(1)) SWIG_fail;
29493 {
29494 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29495 if (SWIG_arg_fail(2)) SWIG_fail;
29496 if (arg2 == NULL) {
29497 SWIG_null_ref("wxDataFormat");
29498 }
29499 if (SWIG_arg_fail(2)) SWIG_fail;
29500 }
29501 {
29502 PyThreadState* __tstate = wxPyBeginAllowThreads();
29503 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29504
29505 wxPyEndAllowThreads(__tstate);
29506 if (PyErr_Occurred()) SWIG_fail;
29507 }
29508 {
29509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29510 }
29511 return resultobj;
29512 fail:
29513 return NULL;
29514 }
29515
29516
29517 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29518 PyObject *resultobj;
29519 wxClipboard *arg1 = (wxClipboard *) 0 ;
29520 wxDataObject *arg2 = 0 ;
29521 bool result;
29522 PyObject * obj0 = 0 ;
29523 PyObject * obj1 = 0 ;
29524 char *kwnames[] = {
29525 (char *) "self",(char *) "data", NULL
29526 };
29527
29528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29530 if (SWIG_arg_fail(1)) SWIG_fail;
29531 {
29532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29533 if (SWIG_arg_fail(2)) SWIG_fail;
29534 if (arg2 == NULL) {
29535 SWIG_null_ref("wxDataObject");
29536 }
29537 if (SWIG_arg_fail(2)) SWIG_fail;
29538 }
29539 {
29540 PyThreadState* __tstate = wxPyBeginAllowThreads();
29541 result = (bool)(arg1)->GetData(*arg2);
29542
29543 wxPyEndAllowThreads(__tstate);
29544 if (PyErr_Occurred()) SWIG_fail;
29545 }
29546 {
29547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29548 }
29549 return resultobj;
29550 fail:
29551 return NULL;
29552 }
29553
29554
29555 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29556 PyObject *resultobj;
29557 wxClipboard *arg1 = (wxClipboard *) 0 ;
29558 PyObject * obj0 = 0 ;
29559 char *kwnames[] = {
29560 (char *) "self", NULL
29561 };
29562
29563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29565 if (SWIG_arg_fail(1)) SWIG_fail;
29566 {
29567 PyThreadState* __tstate = wxPyBeginAllowThreads();
29568 (arg1)->Clear();
29569
29570 wxPyEndAllowThreads(__tstate);
29571 if (PyErr_Occurred()) SWIG_fail;
29572 }
29573 Py_INCREF(Py_None); resultobj = Py_None;
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj;
29582 wxClipboard *arg1 = (wxClipboard *) 0 ;
29583 bool result;
29584 PyObject * obj0 = 0 ;
29585 char *kwnames[] = {
29586 (char *) "self", NULL
29587 };
29588
29589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29591 if (SWIG_arg_fail(1)) SWIG_fail;
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (bool)(arg1)->Flush();
29595
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 {
29600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29601 }
29602 return resultobj;
29603 fail:
29604 return NULL;
29605 }
29606
29607
29608 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29609 PyObject *resultobj;
29610 wxClipboard *arg1 = (wxClipboard *) 0 ;
29611 bool arg2 = (bool) true ;
29612 PyObject * obj0 = 0 ;
29613 PyObject * obj1 = 0 ;
29614 char *kwnames[] = {
29615 (char *) "self",(char *) "primary", NULL
29616 };
29617
29618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29620 if (SWIG_arg_fail(1)) SWIG_fail;
29621 if (obj1) {
29622 {
29623 arg2 = (bool)(SWIG_As_bool(obj1));
29624 if (SWIG_arg_fail(2)) SWIG_fail;
29625 }
29626 }
29627 {
29628 PyThreadState* __tstate = wxPyBeginAllowThreads();
29629 (arg1)->UsePrimarySelection(arg2);
29630
29631 wxPyEndAllowThreads(__tstate);
29632 if (PyErr_Occurred()) SWIG_fail;
29633 }
29634 Py_INCREF(Py_None); resultobj = Py_None;
29635 return resultobj;
29636 fail:
29637 return NULL;
29638 }
29639
29640
29641 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29642 PyObject *resultobj;
29643 wxClipboard *result;
29644 char *kwnames[] = {
29645 NULL
29646 };
29647
29648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = (wxClipboard *)wxClipboard::Get();
29652
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29664 PyObject *obj;
29665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29666 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29667 Py_INCREF(obj);
29668 return Py_BuildValue((char *)"");
29669 }
29670 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29671 PyObject *resultobj;
29672 wxClipboard *arg1 = (wxClipboard *) NULL ;
29673 wxClipboardLocker *result;
29674 PyObject * obj0 = 0 ;
29675 char *kwnames[] = {
29676 (char *) "clipboard", NULL
29677 };
29678
29679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29680 if (obj0) {
29681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29682 if (SWIG_arg_fail(1)) SWIG_fail;
29683 }
29684 {
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29687
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29692 return resultobj;
29693 fail:
29694 return NULL;
29695 }
29696
29697
29698 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29699 PyObject *resultobj;
29700 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29701 PyObject * obj0 = 0 ;
29702 char *kwnames[] = {
29703 (char *) "self", NULL
29704 };
29705
29706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29708 if (SWIG_arg_fail(1)) SWIG_fail;
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 delete arg1;
29712
29713 wxPyEndAllowThreads(__tstate);
29714 if (PyErr_Occurred()) SWIG_fail;
29715 }
29716 Py_INCREF(Py_None); resultobj = Py_None;
29717 return resultobj;
29718 fail:
29719 return NULL;
29720 }
29721
29722
29723 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29724 PyObject *resultobj;
29725 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29726 bool result;
29727 PyObject * obj0 = 0 ;
29728 char *kwnames[] = {
29729 (char *) "self", NULL
29730 };
29731
29732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29734 if (SWIG_arg_fail(1)) SWIG_fail;
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 result = (bool)wxClipboardLocker___nonzero__(arg1);
29738
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 {
29743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29744 }
29745 return resultobj;
29746 fail:
29747 return NULL;
29748 }
29749
29750
29751 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29752 PyObject *obj;
29753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29754 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29755 Py_INCREF(obj);
29756 return Py_BuildValue((char *)"");
29757 }
29758 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29759 PyObject *resultobj;
29760 int arg1 = (int) 0 ;
29761 int arg2 = (int) 0 ;
29762 int arg3 = (int) 0 ;
29763 int arg4 = (int) 0 ;
29764 wxVideoMode *result;
29765 PyObject * obj0 = 0 ;
29766 PyObject * obj1 = 0 ;
29767 PyObject * obj2 = 0 ;
29768 PyObject * obj3 = 0 ;
29769 char *kwnames[] = {
29770 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29771 };
29772
29773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29774 if (obj0) {
29775 {
29776 arg1 = (int)(SWIG_As_int(obj0));
29777 if (SWIG_arg_fail(1)) SWIG_fail;
29778 }
29779 }
29780 if (obj1) {
29781 {
29782 arg2 = (int)(SWIG_As_int(obj1));
29783 if (SWIG_arg_fail(2)) SWIG_fail;
29784 }
29785 }
29786 if (obj2) {
29787 {
29788 arg3 = (int)(SWIG_As_int(obj2));
29789 if (SWIG_arg_fail(3)) SWIG_fail;
29790 }
29791 }
29792 if (obj3) {
29793 {
29794 arg4 = (int)(SWIG_As_int(obj3));
29795 if (SWIG_arg_fail(4)) SWIG_fail;
29796 }
29797 }
29798 {
29799 PyThreadState* __tstate = wxPyBeginAllowThreads();
29800 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29801
29802 wxPyEndAllowThreads(__tstate);
29803 if (PyErr_Occurred()) SWIG_fail;
29804 }
29805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29806 return resultobj;
29807 fail:
29808 return NULL;
29809 }
29810
29811
29812 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29813 PyObject *resultobj;
29814 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29815 PyObject * obj0 = 0 ;
29816 char *kwnames[] = {
29817 (char *) "self", NULL
29818 };
29819
29820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29822 if (SWIG_arg_fail(1)) SWIG_fail;
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 delete arg1;
29826
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 Py_INCREF(Py_None); resultobj = Py_None;
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29838 PyObject *resultobj;
29839 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29840 wxVideoMode *arg2 = 0 ;
29841 bool result;
29842 PyObject * obj0 = 0 ;
29843 PyObject * obj1 = 0 ;
29844 char *kwnames[] = {
29845 (char *) "self",(char *) "other", NULL
29846 };
29847
29848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29850 if (SWIG_arg_fail(1)) SWIG_fail;
29851 {
29852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29853 if (SWIG_arg_fail(2)) SWIG_fail;
29854 if (arg2 == NULL) {
29855 SWIG_null_ref("wxVideoMode");
29856 }
29857 if (SWIG_arg_fail(2)) SWIG_fail;
29858 }
29859 {
29860 PyThreadState* __tstate = wxPyBeginAllowThreads();
29861 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
29862
29863 wxPyEndAllowThreads(__tstate);
29864 if (PyErr_Occurred()) SWIG_fail;
29865 }
29866 {
29867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29868 }
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj;
29877 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29878 int result;
29879 PyObject * obj0 = 0 ;
29880 char *kwnames[] = {
29881 (char *) "self", NULL
29882 };
29883
29884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29886 if (SWIG_arg_fail(1)) SWIG_fail;
29887 {
29888 PyThreadState* __tstate = wxPyBeginAllowThreads();
29889 result = (int)((wxVideoMode const *)arg1)->GetWidth();
29890
29891 wxPyEndAllowThreads(__tstate);
29892 if (PyErr_Occurred()) SWIG_fail;
29893 }
29894 {
29895 resultobj = SWIG_From_int((int)(result));
29896 }
29897 return resultobj;
29898 fail:
29899 return NULL;
29900 }
29901
29902
29903 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29904 PyObject *resultobj;
29905 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29906 int result;
29907 PyObject * obj0 = 0 ;
29908 char *kwnames[] = {
29909 (char *) "self", NULL
29910 };
29911
29912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
29913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29914 if (SWIG_arg_fail(1)) SWIG_fail;
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 result = (int)((wxVideoMode const *)arg1)->GetHeight();
29918
29919 wxPyEndAllowThreads(__tstate);
29920 if (PyErr_Occurred()) SWIG_fail;
29921 }
29922 {
29923 resultobj = SWIG_From_int((int)(result));
29924 }
29925 return resultobj;
29926 fail:
29927 return NULL;
29928 }
29929
29930
29931 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
29932 PyObject *resultobj;
29933 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29934 int result;
29935 PyObject * obj0 = 0 ;
29936 char *kwnames[] = {
29937 (char *) "self", NULL
29938 };
29939
29940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
29941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29942 if (SWIG_arg_fail(1)) SWIG_fail;
29943 {
29944 PyThreadState* __tstate = wxPyBeginAllowThreads();
29945 result = (int)((wxVideoMode const *)arg1)->GetDepth();
29946
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 {
29951 resultobj = SWIG_From_int((int)(result));
29952 }
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
29960 PyObject *resultobj;
29961 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29962 bool result;
29963 PyObject * obj0 = 0 ;
29964 char *kwnames[] = {
29965 (char *) "self", NULL
29966 };
29967
29968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
29969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29970 if (SWIG_arg_fail(1)) SWIG_fail;
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (bool)((wxVideoMode const *)arg1)->IsOk();
29974
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 {
29979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj;
29989 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29990 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29991 bool result;
29992 PyObject * obj0 = 0 ;
29993 PyObject * obj1 = 0 ;
29994 char *kwnames[] = {
29995 (char *) "self",(char *) "other", NULL
29996 };
29997
29998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
29999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30000 if (SWIG_arg_fail(1)) SWIG_fail;
30001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30002 if (SWIG_arg_fail(2)) SWIG_fail;
30003 {
30004 PyThreadState* __tstate = wxPyBeginAllowThreads();
30005 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30006
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 {
30011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30012 }
30013 return resultobj;
30014 fail:
30015 return NULL;
30016 }
30017
30018
30019 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj;
30021 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30022 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30023 bool result;
30024 PyObject * obj0 = 0 ;
30025 PyObject * obj1 = 0 ;
30026 char *kwnames[] = {
30027 (char *) "self",(char *) "other", NULL
30028 };
30029
30030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30032 if (SWIG_arg_fail(1)) SWIG_fail;
30033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30034 if (SWIG_arg_fail(2)) SWIG_fail;
30035 {
30036 PyThreadState* __tstate = wxPyBeginAllowThreads();
30037 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30038
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 {
30043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30044 }
30045 return resultobj;
30046 fail:
30047 return NULL;
30048 }
30049
30050
30051 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30052 PyObject *resultobj;
30053 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30054 int arg2 ;
30055 PyObject * obj0 = 0 ;
30056 PyObject * obj1 = 0 ;
30057 char *kwnames[] = {
30058 (char *) "self",(char *) "w", NULL
30059 };
30060
30061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30063 if (SWIG_arg_fail(1)) SWIG_fail;
30064 {
30065 arg2 = (int)(SWIG_As_int(obj1));
30066 if (SWIG_arg_fail(2)) SWIG_fail;
30067 }
30068 if (arg1) (arg1)->w = arg2;
30069
30070 Py_INCREF(Py_None); resultobj = Py_None;
30071 return resultobj;
30072 fail:
30073 return NULL;
30074 }
30075
30076
30077 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30078 PyObject *resultobj;
30079 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30080 int result;
30081 PyObject * obj0 = 0 ;
30082 char *kwnames[] = {
30083 (char *) "self", NULL
30084 };
30085
30086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30088 if (SWIG_arg_fail(1)) SWIG_fail;
30089 result = (int) ((arg1)->w);
30090
30091 {
30092 resultobj = SWIG_From_int((int)(result));
30093 }
30094 return resultobj;
30095 fail:
30096 return NULL;
30097 }
30098
30099
30100 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30101 PyObject *resultobj;
30102 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30103 int arg2 ;
30104 PyObject * obj0 = 0 ;
30105 PyObject * obj1 = 0 ;
30106 char *kwnames[] = {
30107 (char *) "self",(char *) "h", NULL
30108 };
30109
30110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30112 if (SWIG_arg_fail(1)) SWIG_fail;
30113 {
30114 arg2 = (int)(SWIG_As_int(obj1));
30115 if (SWIG_arg_fail(2)) SWIG_fail;
30116 }
30117 if (arg1) (arg1)->h = arg2;
30118
30119 Py_INCREF(Py_None); resultobj = Py_None;
30120 return resultobj;
30121 fail:
30122 return NULL;
30123 }
30124
30125
30126 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30127 PyObject *resultobj;
30128 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30129 int result;
30130 PyObject * obj0 = 0 ;
30131 char *kwnames[] = {
30132 (char *) "self", NULL
30133 };
30134
30135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30137 if (SWIG_arg_fail(1)) SWIG_fail;
30138 result = (int) ((arg1)->h);
30139
30140 {
30141 resultobj = SWIG_From_int((int)(result));
30142 }
30143 return resultobj;
30144 fail:
30145 return NULL;
30146 }
30147
30148
30149 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30150 PyObject *resultobj;
30151 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30152 int arg2 ;
30153 PyObject * obj0 = 0 ;
30154 PyObject * obj1 = 0 ;
30155 char *kwnames[] = {
30156 (char *) "self",(char *) "bpp", NULL
30157 };
30158
30159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30161 if (SWIG_arg_fail(1)) SWIG_fail;
30162 {
30163 arg2 = (int)(SWIG_As_int(obj1));
30164 if (SWIG_arg_fail(2)) SWIG_fail;
30165 }
30166 if (arg1) (arg1)->bpp = arg2;
30167
30168 Py_INCREF(Py_None); resultobj = Py_None;
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj;
30177 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30178 int result;
30179 PyObject * obj0 = 0 ;
30180 char *kwnames[] = {
30181 (char *) "self", NULL
30182 };
30183
30184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30186 if (SWIG_arg_fail(1)) SWIG_fail;
30187 result = (int) ((arg1)->bpp);
30188
30189 {
30190 resultobj = SWIG_From_int((int)(result));
30191 }
30192 return resultobj;
30193 fail:
30194 return NULL;
30195 }
30196
30197
30198 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30199 PyObject *resultobj;
30200 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30201 int arg2 ;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204 char *kwnames[] = {
30205 (char *) "self",(char *) "refresh", NULL
30206 };
30207
30208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30210 if (SWIG_arg_fail(1)) SWIG_fail;
30211 {
30212 arg2 = (int)(SWIG_As_int(obj1));
30213 if (SWIG_arg_fail(2)) SWIG_fail;
30214 }
30215 if (arg1) (arg1)->refresh = arg2;
30216
30217 Py_INCREF(Py_None); resultobj = Py_None;
30218 return resultobj;
30219 fail:
30220 return NULL;
30221 }
30222
30223
30224 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30225 PyObject *resultobj;
30226 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30227 int result;
30228 PyObject * obj0 = 0 ;
30229 char *kwnames[] = {
30230 (char *) "self", NULL
30231 };
30232
30233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30235 if (SWIG_arg_fail(1)) SWIG_fail;
30236 result = (int) ((arg1)->refresh);
30237
30238 {
30239 resultobj = SWIG_From_int((int)(result));
30240 }
30241 return resultobj;
30242 fail:
30243 return NULL;
30244 }
30245
30246
30247 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30248 PyObject *obj;
30249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30250 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30251 Py_INCREF(obj);
30252 return Py_BuildValue((char *)"");
30253 }
30254 static int _wrap_DefaultVideoMode_set(PyObject *) {
30255 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30256 return 1;
30257 }
30258
30259
30260 static PyObject *_wrap_DefaultVideoMode_get(void) {
30261 PyObject *pyobj;
30262
30263 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30264 return pyobj;
30265 }
30266
30267
30268 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj;
30270 size_t arg1 = (size_t) 0 ;
30271 wxDisplay *result;
30272 PyObject * obj0 = 0 ;
30273 char *kwnames[] = {
30274 (char *) "index", NULL
30275 };
30276
30277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30278 if (obj0) {
30279 {
30280 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30281 if (SWIG_arg_fail(1)) SWIG_fail;
30282 }
30283 }
30284 {
30285 PyThreadState* __tstate = wxPyBeginAllowThreads();
30286 result = (wxDisplay *)new wxDisplay(arg1);
30287
30288 wxPyEndAllowThreads(__tstate);
30289 if (PyErr_Occurred()) SWIG_fail;
30290 }
30291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30292 return resultobj;
30293 fail:
30294 return NULL;
30295 }
30296
30297
30298 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30299 PyObject *resultobj;
30300 wxDisplay *arg1 = (wxDisplay *) 0 ;
30301 PyObject * obj0 = 0 ;
30302 char *kwnames[] = {
30303 (char *) "self", NULL
30304 };
30305
30306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30308 if (SWIG_arg_fail(1)) SWIG_fail;
30309 {
30310 PyThreadState* __tstate = wxPyBeginAllowThreads();
30311 delete arg1;
30312
30313 wxPyEndAllowThreads(__tstate);
30314 if (PyErr_Occurred()) SWIG_fail;
30315 }
30316 Py_INCREF(Py_None); resultobj = Py_None;
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30324 PyObject *resultobj;
30325 size_t result;
30326 char *kwnames[] = {
30327 NULL
30328 };
30329
30330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30331 {
30332 PyThreadState* __tstate = wxPyBeginAllowThreads();
30333 result = (size_t)wxDisplay::GetCount();
30334
30335 wxPyEndAllowThreads(__tstate);
30336 if (PyErr_Occurred()) SWIG_fail;
30337 }
30338 {
30339 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30340 }
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30348 PyObject *resultobj;
30349 wxPoint *arg1 = 0 ;
30350 int result;
30351 wxPoint temp1 ;
30352 PyObject * obj0 = 0 ;
30353 char *kwnames[] = {
30354 (char *) "pt", NULL
30355 };
30356
30357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30358 {
30359 arg1 = &temp1;
30360 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30361 }
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30365
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 {
30370 resultobj = SWIG_From_int((int)(result));
30371 }
30372 return resultobj;
30373 fail:
30374 return NULL;
30375 }
30376
30377
30378 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30379 PyObject *resultobj;
30380 wxWindow *arg1 = (wxWindow *) 0 ;
30381 int result;
30382 PyObject * obj0 = 0 ;
30383 char *kwnames[] = {
30384 (char *) "window", NULL
30385 };
30386
30387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30389 if (SWIG_arg_fail(1)) SWIG_fail;
30390 {
30391 PyThreadState* __tstate = wxPyBeginAllowThreads();
30392 result = (int)Display_GetFromWindow(arg1);
30393
30394 wxPyEndAllowThreads(__tstate);
30395 if (PyErr_Occurred()) SWIG_fail;
30396 }
30397 {
30398 resultobj = SWIG_From_int((int)(result));
30399 }
30400 return resultobj;
30401 fail:
30402 return NULL;
30403 }
30404
30405
30406 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30407 PyObject *resultobj;
30408 wxDisplay *arg1 = (wxDisplay *) 0 ;
30409 bool result;
30410 PyObject * obj0 = 0 ;
30411 char *kwnames[] = {
30412 (char *) "self", NULL
30413 };
30414
30415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30417 if (SWIG_arg_fail(1)) SWIG_fail;
30418 {
30419 PyThreadState* __tstate = wxPyBeginAllowThreads();
30420 result = (bool)((wxDisplay const *)arg1)->IsOk();
30421
30422 wxPyEndAllowThreads(__tstate);
30423 if (PyErr_Occurred()) SWIG_fail;
30424 }
30425 {
30426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30427 }
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30435 PyObject *resultobj;
30436 wxDisplay *arg1 = (wxDisplay *) 0 ;
30437 wxRect result;
30438 PyObject * obj0 = 0 ;
30439 char *kwnames[] = {
30440 (char *) "self", NULL
30441 };
30442
30443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30445 if (SWIG_arg_fail(1)) SWIG_fail;
30446 {
30447 PyThreadState* __tstate = wxPyBeginAllowThreads();
30448 result = ((wxDisplay const *)arg1)->GetGeometry();
30449
30450 wxPyEndAllowThreads(__tstate);
30451 if (PyErr_Occurred()) SWIG_fail;
30452 }
30453 {
30454 wxRect * resultptr;
30455 resultptr = new wxRect((wxRect &)(result));
30456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30457 }
30458 return resultobj;
30459 fail:
30460 return NULL;
30461 }
30462
30463
30464 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30465 PyObject *resultobj;
30466 wxDisplay *arg1 = (wxDisplay *) 0 ;
30467 wxString result;
30468 PyObject * obj0 = 0 ;
30469 char *kwnames[] = {
30470 (char *) "self", NULL
30471 };
30472
30473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30475 if (SWIG_arg_fail(1)) SWIG_fail;
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = ((wxDisplay const *)arg1)->GetName();
30479
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 {
30484 #if wxUSE_UNICODE
30485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30486 #else
30487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30488 #endif
30489 }
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30497 PyObject *resultobj;
30498 wxDisplay *arg1 = (wxDisplay *) 0 ;
30499 bool result;
30500 PyObject * obj0 = 0 ;
30501 char *kwnames[] = {
30502 (char *) "self", NULL
30503 };
30504
30505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30507 if (SWIG_arg_fail(1)) SWIG_fail;
30508 {
30509 PyThreadState* __tstate = wxPyBeginAllowThreads();
30510 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30511
30512 wxPyEndAllowThreads(__tstate);
30513 if (PyErr_Occurred()) SWIG_fail;
30514 }
30515 {
30516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30517 }
30518 return resultobj;
30519 fail:
30520 return NULL;
30521 }
30522
30523
30524 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30525 PyObject *resultobj;
30526 wxDisplay *arg1 = (wxDisplay *) 0 ;
30527 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30528 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30529 PyObject *result;
30530 PyObject * obj0 = 0 ;
30531 PyObject * obj1 = 0 ;
30532 char *kwnames[] = {
30533 (char *) "self",(char *) "mode", NULL
30534 };
30535
30536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30538 if (SWIG_arg_fail(1)) SWIG_fail;
30539 if (obj1) {
30540 {
30541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30542 if (SWIG_arg_fail(2)) SWIG_fail;
30543 if (arg2 == NULL) {
30544 SWIG_null_ref("wxVideoMode");
30545 }
30546 if (SWIG_arg_fail(2)) SWIG_fail;
30547 }
30548 }
30549 {
30550 PyThreadState* __tstate = wxPyBeginAllowThreads();
30551 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30552
30553 wxPyEndAllowThreads(__tstate);
30554 if (PyErr_Occurred()) SWIG_fail;
30555 }
30556 resultobj = result;
30557 return resultobj;
30558 fail:
30559 return NULL;
30560 }
30561
30562
30563 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30564 PyObject *resultobj;
30565 wxDisplay *arg1 = (wxDisplay *) 0 ;
30566 wxVideoMode result;
30567 PyObject * obj0 = 0 ;
30568 char *kwnames[] = {
30569 (char *) "self", NULL
30570 };
30571
30572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30574 if (SWIG_arg_fail(1)) SWIG_fail;
30575 {
30576 PyThreadState* __tstate = wxPyBeginAllowThreads();
30577 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30578
30579 wxPyEndAllowThreads(__tstate);
30580 if (PyErr_Occurred()) SWIG_fail;
30581 }
30582 {
30583 wxVideoMode * resultptr;
30584 resultptr = new wxVideoMode((wxVideoMode &)(result));
30585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30586 }
30587 return resultobj;
30588 fail:
30589 return NULL;
30590 }
30591
30592
30593 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30594 PyObject *resultobj;
30595 wxDisplay *arg1 = (wxDisplay *) 0 ;
30596 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30597 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30598 bool result;
30599 PyObject * obj0 = 0 ;
30600 PyObject * obj1 = 0 ;
30601 char *kwnames[] = {
30602 (char *) "self",(char *) "mode", NULL
30603 };
30604
30605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30607 if (SWIG_arg_fail(1)) SWIG_fail;
30608 if (obj1) {
30609 {
30610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30611 if (SWIG_arg_fail(2)) SWIG_fail;
30612 if (arg2 == NULL) {
30613 SWIG_null_ref("wxVideoMode");
30614 }
30615 if (SWIG_arg_fail(2)) SWIG_fail;
30616 }
30617 }
30618 {
30619 PyThreadState* __tstate = wxPyBeginAllowThreads();
30620 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30621
30622 wxPyEndAllowThreads(__tstate);
30623 if (PyErr_Occurred()) SWIG_fail;
30624 }
30625 {
30626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30627 }
30628 return resultobj;
30629 fail:
30630 return NULL;
30631 }
30632
30633
30634 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30635 PyObject *resultobj;
30636 wxDisplay *arg1 = (wxDisplay *) 0 ;
30637 PyObject * obj0 = 0 ;
30638 char *kwnames[] = {
30639 (char *) "self", NULL
30640 };
30641
30642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30644 if (SWIG_arg_fail(1)) SWIG_fail;
30645 {
30646 PyThreadState* __tstate = wxPyBeginAllowThreads();
30647 (arg1)->ResetMode();
30648
30649 wxPyEndAllowThreads(__tstate);
30650 if (PyErr_Occurred()) SWIG_fail;
30651 }
30652 Py_INCREF(Py_None); resultobj = Py_None;
30653 return resultobj;
30654 fail:
30655 return NULL;
30656 }
30657
30658
30659 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30660 PyObject *obj;
30661 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30662 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30663 Py_INCREF(obj);
30664 return Py_BuildValue((char *)"");
30665 }
30666 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30667 PyObject *resultobj;
30668 wxStandardPaths *result;
30669 char *kwnames[] = {
30670 NULL
30671 };
30672
30673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30674 {
30675 PyThreadState* __tstate = wxPyBeginAllowThreads();
30676 result = (wxStandardPaths *)StandardPaths_Get();
30677
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30689 PyObject *resultobj;
30690 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30691 wxString result;
30692 PyObject * obj0 = 0 ;
30693 char *kwnames[] = {
30694 (char *) "self", NULL
30695 };
30696
30697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30699 if (SWIG_arg_fail(1)) SWIG_fail;
30700 {
30701 PyThreadState* __tstate = wxPyBeginAllowThreads();
30702 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30703
30704 wxPyEndAllowThreads(__tstate);
30705 if (PyErr_Occurred()) SWIG_fail;
30706 }
30707 {
30708 #if wxUSE_UNICODE
30709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30710 #else
30711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30712 #endif
30713 }
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30721 PyObject *resultobj;
30722 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30723 wxString result;
30724 PyObject * obj0 = 0 ;
30725 char *kwnames[] = {
30726 (char *) "self", NULL
30727 };
30728
30729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30731 if (SWIG_arg_fail(1)) SWIG_fail;
30732 {
30733 PyThreadState* __tstate = wxPyBeginAllowThreads();
30734 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30735
30736 wxPyEndAllowThreads(__tstate);
30737 if (PyErr_Occurred()) SWIG_fail;
30738 }
30739 {
30740 #if wxUSE_UNICODE
30741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30742 #else
30743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30744 #endif
30745 }
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30753 PyObject *resultobj;
30754 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30755 wxString result;
30756 PyObject * obj0 = 0 ;
30757 char *kwnames[] = {
30758 (char *) "self", NULL
30759 };
30760
30761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30763 if (SWIG_arg_fail(1)) SWIG_fail;
30764 {
30765 PyThreadState* __tstate = wxPyBeginAllowThreads();
30766 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30767
30768 wxPyEndAllowThreads(__tstate);
30769 if (PyErr_Occurred()) SWIG_fail;
30770 }
30771 {
30772 #if wxUSE_UNICODE
30773 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30774 #else
30775 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30776 #endif
30777 }
30778 return resultobj;
30779 fail:
30780 return NULL;
30781 }
30782
30783
30784 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30785 PyObject *resultobj;
30786 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30787 wxString result;
30788 PyObject * obj0 = 0 ;
30789 char *kwnames[] = {
30790 (char *) "self", NULL
30791 };
30792
30793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30795 if (SWIG_arg_fail(1)) SWIG_fail;
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30799
30800 wxPyEndAllowThreads(__tstate);
30801 if (PyErr_Occurred()) SWIG_fail;
30802 }
30803 {
30804 #if wxUSE_UNICODE
30805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30806 #else
30807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30808 #endif
30809 }
30810 return resultobj;
30811 fail:
30812 return NULL;
30813 }
30814
30815
30816 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30817 PyObject *resultobj;
30818 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30819 wxString result;
30820 PyObject * obj0 = 0 ;
30821 char *kwnames[] = {
30822 (char *) "self", NULL
30823 };
30824
30825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30827 if (SWIG_arg_fail(1)) SWIG_fail;
30828 {
30829 PyThreadState* __tstate = wxPyBeginAllowThreads();
30830 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30831
30832 wxPyEndAllowThreads(__tstate);
30833 if (PyErr_Occurred()) SWIG_fail;
30834 }
30835 {
30836 #if wxUSE_UNICODE
30837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30838 #else
30839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30840 #endif
30841 }
30842 return resultobj;
30843 fail:
30844 return NULL;
30845 }
30846
30847
30848 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30849 PyObject *resultobj;
30850 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30851 wxString result;
30852 PyObject * obj0 = 0 ;
30853 char *kwnames[] = {
30854 (char *) "self", NULL
30855 };
30856
30857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30859 if (SWIG_arg_fail(1)) SWIG_fail;
30860 {
30861 PyThreadState* __tstate = wxPyBeginAllowThreads();
30862 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30863
30864 wxPyEndAllowThreads(__tstate);
30865 if (PyErr_Occurred()) SWIG_fail;
30866 }
30867 {
30868 #if wxUSE_UNICODE
30869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30870 #else
30871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30872 #endif
30873 }
30874 return resultobj;
30875 fail:
30876 return NULL;
30877 }
30878
30879
30880 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30881 PyObject *resultobj;
30882 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30883 wxString result;
30884 PyObject * obj0 = 0 ;
30885 char *kwnames[] = {
30886 (char *) "self", NULL
30887 };
30888
30889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
30890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30891 if (SWIG_arg_fail(1)) SWIG_fail;
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
30895
30896 wxPyEndAllowThreads(__tstate);
30897 if (PyErr_Occurred()) SWIG_fail;
30898 }
30899 {
30900 #if wxUSE_UNICODE
30901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30902 #else
30903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30904 #endif
30905 }
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30913 PyObject *resultobj;
30914 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30915 wxString *arg2 = 0 ;
30916 bool temp2 = false ;
30917 PyObject * obj0 = 0 ;
30918 PyObject * obj1 = 0 ;
30919 char *kwnames[] = {
30920 (char *) "self",(char *) "prefix", NULL
30921 };
30922
30923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
30924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30925 if (SWIG_arg_fail(1)) SWIG_fail;
30926 {
30927 arg2 = wxString_in_helper(obj1);
30928 if (arg2 == NULL) SWIG_fail;
30929 temp2 = true;
30930 }
30931 {
30932 PyThreadState* __tstate = wxPyBeginAllowThreads();
30933 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
30934
30935 wxPyEndAllowThreads(__tstate);
30936 if (PyErr_Occurred()) SWIG_fail;
30937 }
30938 Py_INCREF(Py_None); resultobj = Py_None;
30939 {
30940 if (temp2)
30941 delete arg2;
30942 }
30943 return resultobj;
30944 fail:
30945 {
30946 if (temp2)
30947 delete arg2;
30948 }
30949 return NULL;
30950 }
30951
30952
30953 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30954 PyObject *resultobj;
30955 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30956 wxString result;
30957 PyObject * obj0 = 0 ;
30958 char *kwnames[] = {
30959 (char *) "self", NULL
30960 };
30961
30962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
30963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30964 if (SWIG_arg_fail(1)) SWIG_fail;
30965 {
30966 PyThreadState* __tstate = wxPyBeginAllowThreads();
30967 result = wxStandardPaths_GetInstallPrefix(arg1);
30968
30969 wxPyEndAllowThreads(__tstate);
30970 if (PyErr_Occurred()) SWIG_fail;
30971 }
30972 {
30973 #if wxUSE_UNICODE
30974 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30975 #else
30976 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30977 #endif
30978 }
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
30986 PyObject *obj;
30987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30988 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
30989 Py_INCREF(obj);
30990 return Py_BuildValue((char *)"");
30991 }
30992 static PyMethodDef SwigMethods[] = {
30993 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30994 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
30995 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
30996 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
30997 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30998 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30999 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31000 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31001 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31002 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31003 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31004 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31005 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31006 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31007 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31008 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31009 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31010 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31011 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31012 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31013 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31014 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31015 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31016 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31017 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31018 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31019 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31020 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31021 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31022 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31023 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31024 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31025 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31026 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31027 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31028 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31029 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31030 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31031 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31032 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31033 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31034 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31035 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31036 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31037 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31038 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31039 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31040 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31041 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31042 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31043 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31044 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31045 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31046 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31047 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31048 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31049 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31051 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31052 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31053 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31055 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31056 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31057 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31058 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31060 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31061 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31063 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31064 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31065 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31066 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31067 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31068 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31069 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31070 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31071 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31072 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31073 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31074 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31075 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31076 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31077 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31078 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31079 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31080 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31081 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31082 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31083 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31085 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31086 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31087 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31088 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31089 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31090 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31091 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31092 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31093 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31094 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31095 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31096 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31097 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31098 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31099 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31100 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31101 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31102 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31103 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31104 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31105 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31106 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31111 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31112 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31114 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31125 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31126 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31131 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31132 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31135 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31137 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31140 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31144 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31151 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31154 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31156 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31157 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31158 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31160 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31161 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31168 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31187 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31188 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31190 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31192 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31194 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31201 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31207 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31221 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31225 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31228 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31245 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31253 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31300 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31318 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31328 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31344 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31360 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31374 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31383 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31426 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31429 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31432 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31436 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31529 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31530 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31531 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31532 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31549 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31594 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31628 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31636 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31637 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31642 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31651 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31658 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31661 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31664 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31669 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31672 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31676 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31679 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31683 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31684 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31688 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31692 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31696 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31706 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31717 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31725 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31733 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31747 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31751 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31769 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31783 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31794 { NULL, NULL, 0, NULL }
31795 };
31796
31797
31798 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31799
31800 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31801 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31802 }
31803 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31804 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31805 }
31806 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31807 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31808 }
31809 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31810 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31811 }
31812 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31813 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31814 }
31815 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31816 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31817 }
31818 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31819 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31820 }
31821 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31822 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31823 }
31824 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31825 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31826 }
31827 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31828 return (void *)((wxEvent *) ((wxPyEvent *) x));
31829 }
31830 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31831 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31832 }
31833 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31834 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31835 }
31836 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31837 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31838 }
31839 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31840 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31841 }
31842 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31843 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31844 }
31845 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31846 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31847 }
31848 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31849 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31850 }
31851 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31852 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31853 }
31854 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31855 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31856 }
31857 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31858 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31859 }
31860 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31861 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31862 }
31863 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31864 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31865 }
31866 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31867 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31868 }
31869 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31870 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31871 }
31872 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31873 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31874 }
31875 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
31876 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31877 }
31878 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
31879 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
31880 }
31881 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
31882 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
31883 }
31884 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
31885 return (void *)((wxEvent *) ((wxFocusEvent *) x));
31886 }
31887 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
31888 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
31889 }
31890 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
31891 return (void *)((wxEvent *) ((wxProcessEvent *) x));
31892 }
31893 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
31894 return (void *)((wxEvent *) ((wxShowEvent *) x));
31895 }
31896 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
31897 return (void *)((wxEvent *) ((wxCommandEvent *) x));
31898 }
31899 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
31900 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
31901 }
31902 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
31903 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31904 }
31905 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
31906 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
31907 }
31908 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
31909 return (void *)((wxEvent *) ((wxKeyEvent *) x));
31910 }
31911 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
31912 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
31913 }
31914 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
31915 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
31916 }
31917 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
31918 return (void *)((wxConfigBase *) ((wxConfig *) x));
31919 }
31920 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
31921 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31922 }
31923 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
31924 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
31925 }
31926 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
31927 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
31928 }
31929 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
31930 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31931 }
31932 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
31933 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
31934 }
31935 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
31936 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
31937 }
31938 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
31939 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
31940 }
31941 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
31942 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31943 }
31944 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
31945 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31946 }
31947 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
31948 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
31949 }
31950 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
31951 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
31952 }
31953 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
31954 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
31955 }
31956 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
31957 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31958 }
31959 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
31960 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
31961 }
31962 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
31963 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31964 }
31965 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31966 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
31967 }
31968 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31969 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
31970 }
31971 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31972 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31973 }
31974 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31975 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31976 }
31977 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
31978 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
31979 }
31980 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
31981 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
31982 }
31983 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
31984 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31985 }
31986 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
31987 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
31988 }
31989 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
31990 return (void *)((wxEvtHandler *) ((wxWindow *) x));
31991 }
31992 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
31993 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
31994 }
31995 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
31996 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
31997 }
31998 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
31999 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32000 }
32001 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32002 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32003 }
32004 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32005 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32006 }
32007 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32008 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32009 }
32010 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32011 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32012 }
32013 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32014 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32015 }
32016 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32017 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32018 }
32019 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32020 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32021 }
32022 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32023 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32024 }
32025 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32026 return (void *)((wxObject *) ((wxSizerItem *) x));
32027 }
32028 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32029 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32030 }
32031 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32032 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32033 }
32034 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32035 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32036 }
32037 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32038 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32039 }
32040 static void *_p_wxSizerTo_p_wxObject(void *x) {
32041 return (void *)((wxObject *) ((wxSizer *) x));
32042 }
32043 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32044 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32045 }
32046 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32047 return (void *)((wxObject *) ((wxFileHistory *) x));
32048 }
32049 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32050 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32051 }
32052 static void *_p_wxEventTo_p_wxObject(void *x) {
32053 return (void *)((wxObject *) ((wxEvent *) x));
32054 }
32055 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32056 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32057 }
32058 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32059 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32060 }
32061 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32062 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32063 }
32064 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32065 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32066 }
32067 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32068 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32069 }
32070 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32071 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32072 }
32073 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32074 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32075 }
32076 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32077 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32078 }
32079 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32080 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32081 }
32082 static void *_p_wxControlTo_p_wxObject(void *x) {
32083 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32084 }
32085 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32086 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32087 }
32088 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32089 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32090 }
32091 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32092 return (void *)((wxObject *) ((wxFSFile *) x));
32093 }
32094 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32095 return (void *)((wxObject *) ((wxClipboard *) x));
32096 }
32097 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32098 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32099 }
32100 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32101 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32102 }
32103 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32104 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32105 }
32106 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32107 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32108 }
32109 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32110 return (void *)((wxObject *) ((wxToolTip *) x));
32111 }
32112 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32113 return (void *)((wxObject *) ((wxMenuItem *) x));
32114 }
32115 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32116 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32117 }
32118 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32119 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32120 }
32121 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32122 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32123 }
32124 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32125 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32126 }
32127 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32128 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32129 }
32130 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32131 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32132 }
32133 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32134 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32135 }
32136 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32137 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32138 }
32139 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32140 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32141 }
32142 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32143 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32144 }
32145 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32146 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32147 }
32148 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32149 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32150 }
32151 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32152 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32153 }
32154 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32155 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32156 }
32157 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32158 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32159 }
32160 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32161 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32162 }
32163 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32164 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32165 }
32166 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32167 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32168 }
32169 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32170 return (void *)((wxObject *) ((wxImageHandler *) x));
32171 }
32172 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32173 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32174 }
32175 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32176 return (void *)((wxObject *) ((wxEvtHandler *) x));
32177 }
32178 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32179 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32180 }
32181 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32182 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32183 }
32184 static void *_p_wxImageTo_p_wxObject(void *x) {
32185 return (void *)((wxObject *) ((wxImage *) x));
32186 }
32187 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32188 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32189 }
32190 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32191 return (void *)((wxObject *) ((wxSystemOptions *) x));
32192 }
32193 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32194 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32195 }
32196 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32197 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32198 }
32199 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32200 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32201 }
32202 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32203 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32204 }
32205 static void *_p_wxWindowTo_p_wxObject(void *x) {
32206 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32207 }
32208 static void *_p_wxMenuTo_p_wxObject(void *x) {
32209 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32210 }
32211 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32212 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32213 }
32214 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32215 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32216 }
32217 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32218 return (void *)((wxObject *) ((wxFileSystem *) x));
32219 }
32220 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32221 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32222 }
32223 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32224 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32225 }
32226 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32227 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32228 }
32229 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32230 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32231 }
32232 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32233 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32234 }
32235 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32236 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32237 }
32238 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32239 return (void *)((wxObject *) ((wxBusyInfo *) x));
32240 }
32241 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32242 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32243 }
32244 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32245 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32246 }
32247 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32248 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32249 }
32250 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32251 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32252 }
32253 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32254 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32255 }
32256 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32257 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32258 }
32259 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32260 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32261 }
32262 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32263 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32264 }
32265 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32266 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32267 }
32268 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32269 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32270 }
32271 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32272 return (void *)((wxLog *) ((wxLogStderr *) x));
32273 }
32274 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32275 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32276 }
32277 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32278 return (void *)((wxLog *) ((wxLogWindow *) x));
32279 }
32280 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32281 return (void *)((wxLog *) ((wxLogChain *) x));
32282 }
32283 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32284 return (void *)((wxLog *) ((wxLogGui *) x));
32285 }
32286 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32287 return (void *)((wxLog *) ((wxPyLog *) x));
32288 }
32289 static void *_p_wxControlTo_p_wxWindow(void *x) {
32290 return (void *)((wxWindow *) ((wxControl *) x));
32291 }
32292 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32293 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32294 }
32295 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32296 return (void *)((wxWindow *) ((wxMenuBar *) x));
32297 }
32298 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32299 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32300 }
32301 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32302 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32303 }
32304 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}};
32305 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}};
32306 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}};
32307 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}};
32308 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}};
32309 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}};
32310 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}};
32311 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}};
32312 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}};
32313 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}};
32314 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}};
32315 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}};
32316 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}};
32317 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}};
32318 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}};
32319 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}};
32320 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}};
32321 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}};
32322 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}};
32323 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}};
32324 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}};
32325 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}};
32326 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}};
32327 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}};
32328 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}};
32329 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}};
32330 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}};
32331 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}};
32332 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}};
32333 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}};
32334 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}};
32335 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}};
32336 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}};
32337 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}};
32338 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}};
32339 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}};
32340 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}};
32341 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}};
32342 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}};
32343 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}};
32344 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}};
32345 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}};
32346 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}};
32347 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}};
32348 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}};
32349 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}};
32350 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}};
32351 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}};
32352 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}};
32353 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}};
32354 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}};
32355 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}};
32356 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}};
32357 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}};
32358 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}};
32359 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}};
32360 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}};
32361 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}};
32362 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}};
32363 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}};
32364 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}};
32365 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}};
32366 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}};
32367 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}};
32368 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}};
32369 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}};
32370 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}};
32371 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}};
32372 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}};
32373 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}};
32374 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}};
32375 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}};
32376 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}};
32377 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}};
32378 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}};
32379 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}};
32380 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}};
32381 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}};
32382 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}};
32383 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}};
32384 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}};
32385 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}};
32386 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}};
32387 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}};
32388 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}};
32389 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}};
32390 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}};
32391 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}};
32392 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}};
32393 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}};
32394 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}};
32395 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}};
32396 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}};
32397 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}};
32398 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}};
32399 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}};
32400
32401 static swig_type_info *swig_types_initial[] = {
32402 _swigt__p_wxLogChain,
32403 _swigt__p_wxMutexGuiLocker,
32404 _swigt__p_wxMetafile,
32405 _swigt__p_wxFileHistory,
32406 _swigt__p_wxLog,
32407 _swigt__p_wxMenu,
32408 _swigt__p_wxEvent,
32409 _swigt__p_wxDateTime__TimeZone,
32410 _swigt__p_wxConfigBase,
32411 _swigt__p_wxDisplay,
32412 _swigt__p_wxFileType,
32413 _swigt__p_wxLogGui,
32414 _swigt__p_wxFont,
32415 _swigt__p_wxDataFormat,
32416 _swigt__p_wxTimerEvent,
32417 _swigt__p_wxCaret,
32418 _swigt__ptrdiff_t,
32419 _swigt__std__ptrdiff_t,
32420 _swigt__p_int,
32421 _swigt__p_wxSize,
32422 _swigt__p_wxClipboard,
32423 _swigt__p_wxStopWatch,
32424 _swigt__p_wxClipboardLocker,
32425 _swigt__p_wxIcon,
32426 _swigt__p_wxLogStderr,
32427 _swigt__p_wxLogTextCtrl,
32428 _swigt__p_wxTextCtrl,
32429 _swigt__p_wxBusyCursor,
32430 _swigt__p_wxBitmapDataObject,
32431 _swigt__p_wxTextDataObject,
32432 _swigt__p_wxDataObject,
32433 _swigt__p_wxPyTextDataObject,
32434 _swigt__p_wxPyBitmapDataObject,
32435 _swigt__p_wxFileDataObject,
32436 _swigt__p_wxCustomDataObject,
32437 _swigt__p_wxURLDataObject,
32438 _swigt__p_wxMetafileDataObject,
32439 _swigt__p_wxSound,
32440 _swigt__p_wxTimerRunner,
32441 _swigt__p_wxLogWindow,
32442 _swigt__p_wxTimeSpan,
32443 _swigt__p_wxArrayString,
32444 _swigt__p_wxWindowDisabler,
32445 _swigt__p_form_ops_t,
32446 _swigt__p_wxToolTip,
32447 _swigt__p_wxDataObjectComposite,
32448 _swigt__p_wxFileConfig,
32449 _swigt__p_wxSystemSettings,
32450 _swigt__p_wxVideoMode,
32451 _swigt__p_wxDataObjectSimple,
32452 _swigt__p_wxPyDataObjectSimple,
32453 _swigt__p_wxDuplexMode,
32454 _swigt__p_wxEvtHandler,
32455 _swigt__p_wxRect,
32456 _swigt__p_char,
32457 _swigt__p_wxSingleInstanceChecker,
32458 _swigt__p_wxStandardPaths,
32459 _swigt__p_wxFileTypeInfo,
32460 _swigt__p_wxFrame,
32461 _swigt__p_wxTimer,
32462 _swigt__p_wxPaperSize,
32463 _swigt__p_wxMimeTypesManager,
32464 _swigt__p_wxPyArtProvider,
32465 _swigt__p_wxPyTipProvider,
32466 _swigt__p_wxTipProvider,
32467 _swigt__p_wxJoystick,
32468 _swigt__p_wxSystemOptions,
32469 _swigt__p_wxPoint,
32470 _swigt__p_wxJoystickEvent,
32471 _swigt__p_wxCursor,
32472 _swigt__p_wxObject,
32473 _swigt__p_wxOutputStream,
32474 _swigt__p_wxDateTime,
32475 _swigt__p_wxPyDropSource,
32476 _swigt__p_unsigned_long,
32477 _swigt__p_wxKillError,
32478 _swigt__p_wxWindow,
32479 _swigt__p_wxString,
32480 _swigt__p_wxPyProcess,
32481 _swigt__p_wxBitmap,
32482 _swigt__p_wxConfig,
32483 _swigt__unsigned_int,
32484 _swigt__p_unsigned_int,
32485 _swigt__p_unsigned_char,
32486 _swigt__p_wxChar,
32487 _swigt__p_wxBusyInfo,
32488 _swigt__p_wxPyDropTarget,
32489 _swigt__p_wxPyTextDropTarget,
32490 _swigt__p_wxPyFileDropTarget,
32491 _swigt__p_wxProcessEvent,
32492 _swigt__p_wxPyLog,
32493 _swigt__p_wxLogNull,
32494 _swigt__p_wxColour,
32495 _swigt__p_wxPyTimer,
32496 _swigt__p_wxConfigPathChanger,
32497 _swigt__p_wxDateSpan,
32498 0
32499 };
32500
32501
32502 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32503
32504 static swig_const_info swig_const_table[] = {
32505 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32506 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32507 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32508 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32509 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32510 {0, 0, 0, 0.0, 0, 0}};
32511
32512 #ifdef __cplusplus
32513 }
32514 #endif
32515
32516
32517 #ifdef __cplusplus
32518 extern "C" {
32519 #endif
32520
32521 /* Python-specific SWIG API */
32522 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32523 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32524 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32525
32526 /* -----------------------------------------------------------------------------
32527 * global variable support code.
32528 * ----------------------------------------------------------------------------- */
32529
32530 typedef struct swig_globalvar {
32531 char *name; /* Name of global variable */
32532 PyObject *(*get_attr)(); /* Return the current value */
32533 int (*set_attr)(PyObject *); /* Set the value */
32534 struct swig_globalvar *next;
32535 } swig_globalvar;
32536
32537 typedef struct swig_varlinkobject {
32538 PyObject_HEAD
32539 swig_globalvar *vars;
32540 } swig_varlinkobject;
32541
32542 static PyObject *
32543 swig_varlink_repr(swig_varlinkobject *v) {
32544 v = v;
32545 return PyString_FromString("<Swig global variables>");
32546 }
32547
32548 static int
32549 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32550 swig_globalvar *var;
32551 flags = flags;
32552 fprintf(fp,"Swig global variables { ");
32553 for (var = v->vars; var; var=var->next) {
32554 fprintf(fp,"%s", var->name);
32555 if (var->next) fprintf(fp,", ");
32556 }
32557 fprintf(fp," }\n");
32558 return 0;
32559 }
32560
32561 static PyObject *
32562 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32563 swig_globalvar *var = v->vars;
32564 while (var) {
32565 if (strcmp(var->name,n) == 0) {
32566 return (*var->get_attr)();
32567 }
32568 var = var->next;
32569 }
32570 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32571 return NULL;
32572 }
32573
32574 static int
32575 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32576 swig_globalvar *var = v->vars;
32577 while (var) {
32578 if (strcmp(var->name,n) == 0) {
32579 return (*var->set_attr)(p);
32580 }
32581 var = var->next;
32582 }
32583 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32584 return 1;
32585 }
32586
32587 static PyTypeObject varlinktype = {
32588 PyObject_HEAD_INIT(0)
32589 0, /* Number of items in variable part (ob_size) */
32590 (char *)"swigvarlink", /* Type name (tp_name) */
32591 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32592 0, /* Itemsize (tp_itemsize) */
32593 0, /* Deallocator (tp_dealloc) */
32594 (printfunc) swig_varlink_print, /* Print (tp_print) */
32595 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32596 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32597 0, /* tp_compare */
32598 (reprfunc) swig_varlink_repr, /* tp_repr */
32599 0, /* tp_as_number */
32600 0, /* tp_as_sequence */
32601 0, /* tp_as_mapping */
32602 0, /* tp_hash */
32603 0, /* tp_call */
32604 0, /* tp_str */
32605 0, /* tp_getattro */
32606 0, /* tp_setattro */
32607 0, /* tp_as_buffer */
32608 0, /* tp_flags */
32609 0, /* tp_doc */
32610 #if PY_VERSION_HEX >= 0x02000000
32611 0, /* tp_traverse */
32612 0, /* tp_clear */
32613 #endif
32614 #if PY_VERSION_HEX >= 0x02010000
32615 0, /* tp_richcompare */
32616 0, /* tp_weaklistoffset */
32617 #endif
32618 #if PY_VERSION_HEX >= 0x02020000
32619 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32620 #endif
32621 #if PY_VERSION_HEX >= 0x02030000
32622 0, /* tp_del */
32623 #endif
32624 #ifdef COUNT_ALLOCS
32625 0,0,0,0 /* tp_alloc -> tp_next */
32626 #endif
32627 };
32628
32629 /* Create a variable linking object for use later */
32630 static PyObject *
32631 SWIG_Python_newvarlink(void) {
32632 swig_varlinkobject *result = 0;
32633 result = PyMem_NEW(swig_varlinkobject,1);
32634 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32635 result->ob_type = &varlinktype;
32636 result->vars = 0;
32637 result->ob_refcnt = 0;
32638 Py_XINCREF((PyObject *) result);
32639 return ((PyObject*) result);
32640 }
32641
32642 static void
32643 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32644 swig_varlinkobject *v;
32645 swig_globalvar *gv;
32646 v= (swig_varlinkobject *) p;
32647 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32648 gv->name = (char *) malloc(strlen(name)+1);
32649 strcpy(gv->name,name);
32650 gv->get_attr = get_attr;
32651 gv->set_attr = set_attr;
32652 gv->next = v->vars;
32653 v->vars = gv;
32654 }
32655
32656 /* -----------------------------------------------------------------------------
32657 * constants/methods manipulation
32658 * ----------------------------------------------------------------------------- */
32659
32660 /* Install Constants */
32661 static void
32662 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32663 PyObject *obj = 0;
32664 size_t i;
32665 for (i = 0; constants[i].type; i++) {
32666 switch(constants[i].type) {
32667 case SWIG_PY_INT:
32668 obj = PyInt_FromLong(constants[i].lvalue);
32669 break;
32670 case SWIG_PY_FLOAT:
32671 obj = PyFloat_FromDouble(constants[i].dvalue);
32672 break;
32673 case SWIG_PY_STRING:
32674 if (constants[i].pvalue) {
32675 obj = PyString_FromString((char *) constants[i].pvalue);
32676 } else {
32677 Py_INCREF(Py_None);
32678 obj = Py_None;
32679 }
32680 break;
32681 case SWIG_PY_POINTER:
32682 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32683 break;
32684 case SWIG_PY_BINARY:
32685 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32686 break;
32687 default:
32688 obj = 0;
32689 break;
32690 }
32691 if (obj) {
32692 PyDict_SetItemString(d,constants[i].name,obj);
32693 Py_DECREF(obj);
32694 }
32695 }
32696 }
32697
32698 /* -----------------------------------------------------------------------------*/
32699 /* Fix SwigMethods to carry the callback ptrs when needed */
32700 /* -----------------------------------------------------------------------------*/
32701
32702 static void
32703 SWIG_Python_FixMethods(PyMethodDef *methods,
32704 swig_const_info *const_table,
32705 swig_type_info **types,
32706 swig_type_info **types_initial) {
32707 size_t i;
32708 for (i = 0; methods[i].ml_name; ++i) {
32709 char *c = methods[i].ml_doc;
32710 if (c && (c = strstr(c, "swig_ptr: "))) {
32711 int j;
32712 swig_const_info *ci = 0;
32713 char *name = c + 10;
32714 for (j = 0; const_table[j].type; j++) {
32715 if (strncmp(const_table[j].name, name,
32716 strlen(const_table[j].name)) == 0) {
32717 ci = &(const_table[j]);
32718 break;
32719 }
32720 }
32721 if (ci) {
32722 size_t shift = (ci->ptype) - types;
32723 swig_type_info *ty = types_initial[shift];
32724 size_t ldoc = (c - methods[i].ml_doc);
32725 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32726 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32727 char *buff = ndoc;
32728 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32729 strncpy(buff, methods[i].ml_doc, ldoc);
32730 buff += ldoc;
32731 strncpy(buff, "swig_ptr: ", 10);
32732 buff += 10;
32733 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32734 methods[i].ml_doc = ndoc;
32735 }
32736 }
32737 }
32738 }
32739
32740 /* -----------------------------------------------------------------------------*
32741 * Initialize type list
32742 * -----------------------------------------------------------------------------*/
32743
32744 #if PY_MAJOR_VERSION < 2
32745 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32746 is copied out of Python/modsupport.c in python version 2.3.4 */
32747 static int
32748 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32749 {
32750 PyObject *dict;
32751 if (!PyModule_Check(m)) {
32752 PyErr_SetString(PyExc_TypeError,
32753 "PyModule_AddObject() needs module as first arg");
32754 return -1;
32755 }
32756 if (!o) {
32757 PyErr_SetString(PyExc_TypeError,
32758 "PyModule_AddObject() needs non-NULL value");
32759 return -1;
32760 }
32761
32762 dict = PyModule_GetDict(m);
32763 if (dict == NULL) {
32764 /* Internal error -- modules must have a dict! */
32765 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32766 PyModule_GetName(m));
32767 return -1;
32768 }
32769 if (PyDict_SetItemString(dict, name, o))
32770 return -1;
32771 Py_DECREF(o);
32772 return 0;
32773 }
32774 #endif
32775
32776 static swig_type_info **
32777 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32778 static PyMethodDef swig_empty_runtime_method_table[] = {
32779 {
32780 NULL, NULL, 0, NULL
32781 }
32782 };/* Sentinel */
32783
32784 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32785 swig_empty_runtime_method_table);
32786 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32787 if (pointer && module) {
32788 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32789 }
32790 return type_list_handle;
32791 }
32792
32793 static swig_type_info **
32794 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32795 swig_type_info **type_pointer;
32796
32797 /* first check if module already created */
32798 type_pointer = SWIG_Python_GetTypeListHandle();
32799 if (type_pointer) {
32800 return type_pointer;
32801 } else {
32802 /* create a new module and variable */
32803 return SWIG_Python_SetTypeListHandle(type_list_handle);
32804 }
32805 }
32806
32807 #ifdef __cplusplus
32808 }
32809 #endif
32810
32811 /* -----------------------------------------------------------------------------*
32812 * Partial Init method
32813 * -----------------------------------------------------------------------------*/
32814
32815 #ifdef SWIG_LINK_RUNTIME
32816 #ifdef __cplusplus
32817 extern "C"
32818 #endif
32819 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32820 #endif
32821
32822 #ifdef __cplusplus
32823 extern "C"
32824 #endif
32825 SWIGEXPORT(void) SWIG_init(void) {
32826 static PyObject *SWIG_globals = 0;
32827 static int typeinit = 0;
32828 PyObject *m, *d;
32829 int i;
32830 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32831
32832 /* Fix SwigMethods to carry the callback ptrs when needed */
32833 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32834
32835 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32836 d = PyModule_GetDict(m);
32837
32838 if (!typeinit) {
32839 #ifdef SWIG_LINK_RUNTIME
32840 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32841 #else
32842 # ifndef SWIG_STATIC_RUNTIME
32843 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32844 # endif
32845 #endif
32846 for (i = 0; swig_types_initial[i]; i++) {
32847 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32848 }
32849 typeinit = 1;
32850 }
32851 SWIG_InstallConstants(d,swig_const_table);
32852
32853 {
32854 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32855 }
32856 {
32857 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32858 }
32859 {
32860 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32861 }
32862 {
32863 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32864 }
32865 {
32866 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32867 }
32868 {
32869 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32870 }
32871 {
32872 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32873 }
32874 {
32875 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
32876 }
32877 {
32878 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
32879 }
32880 {
32881 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
32882 }
32883 {
32884 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
32885 }
32886 {
32887 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
32888 }
32889 {
32890 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
32891 }
32892 {
32893 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
32894 }
32895 {
32896 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
32897 }
32898 {
32899 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
32900 }
32901 {
32902 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
32903 }
32904 {
32905 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
32906 }
32907 {
32908 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
32909 }
32910 {
32911 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
32912 }
32913 {
32914 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
32915 }
32916 {
32917 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
32918 }
32919 {
32920 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
32921 }
32922 {
32923 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
32924 }
32925 {
32926 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
32927 }
32928 {
32929 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
32930 }
32931 {
32932 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
32933 }
32934 {
32935 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
32936 }
32937 {
32938 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
32939 }
32940 {
32941 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
32942 }
32943 {
32944 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
32945 }
32946 {
32947 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
32948 }
32949 {
32950 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
32951 }
32952 {
32953 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
32954 }
32955 {
32956 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
32957 }
32958 {
32959 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
32960 }
32961 {
32962 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
32963 }
32964 {
32965 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
32966 }
32967 {
32968 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
32969 }
32970 {
32971 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
32972 }
32973 {
32974 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
32975 }
32976 {
32977 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
32978 }
32979 {
32980 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
32981 }
32982 {
32983 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
32984 }
32985 {
32986 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
32987 }
32988 {
32989 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
32990 }
32991 {
32992 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
32993 }
32994 {
32995 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
32996 }
32997 {
32998 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
32999 }
33000 {
33001 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33002 }
33003 {
33004 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33005 }
33006 {
33007 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33008 }
33009 {
33010 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33011 }
33012 {
33013 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33014 }
33015 {
33016 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33017 }
33018 {
33019 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33020 }
33021 {
33022 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33023 }
33024 {
33025 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33026 }
33027 {
33028 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33029 }
33030 {
33031 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33032 }
33033 {
33034 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33035 }
33036 {
33037 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33038 }
33039 {
33040 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33041 }
33042 {
33043 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33044 }
33045 {
33046 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33047 }
33048 {
33049 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33050 }
33051 {
33052 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33053 }
33054 {
33055 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33056 }
33057 {
33058 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33059 }
33060 {
33061 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33062 }
33063 {
33064 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33065 }
33066 {
33067 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33068 }
33069 {
33070 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33071 }
33072 {
33073 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33074 }
33075 {
33076 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33077 }
33078 {
33079 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33080 }
33081 {
33082 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33083 }
33084 {
33085 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33086 }
33087 {
33088 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33089 }
33090 {
33091 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33092 }
33093 {
33094 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33095 }
33096 {
33097 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33098 }
33099 {
33100 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33101 }
33102 {
33103 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33104 }
33105 {
33106 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33107 }
33108 {
33109 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33110 }
33111 {
33112 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33113 }
33114 {
33115 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33116 }
33117 {
33118 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33119 }
33120 {
33121 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33122 }
33123 {
33124 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33125 }
33126 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33127 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33128 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33129 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33130 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33131 {
33132 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33133 }
33134 {
33135 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33136 }
33137 {
33138 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33139 }
33140 {
33141 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33142 }
33143 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33144
33145 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33146
33147 {
33148 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33149 }
33150 {
33151 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33152 }
33153 {
33154 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33155 }
33156 {
33157 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33158 }
33159 {
33160 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33161 }
33162 {
33163 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33164 }
33165 {
33166 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33167 }
33168 {
33169 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33170 }
33171 {
33172 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33173 }
33174 {
33175 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33176 }
33177 {
33178 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33179 }
33180 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33181 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33182 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33183 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33184 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33185 {
33186 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33187 }
33188 {
33189 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33190 }
33191 {
33192 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33193 }
33194 {
33195 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33196 }
33197 {
33198 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33199 }
33200 {
33201 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33202 }
33203 {
33204 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33205 }
33206 {
33207 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33208 }
33209 {
33210 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33256 }
33257 {
33258 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33259 }
33260 {
33261 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33262 }
33263 {
33264 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33265 }
33266 {
33267 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33268 }
33269 {
33270 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33277 }
33278 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33279 {
33280 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33281 }
33282 {
33283 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33284 }
33285 {
33286 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33287 }
33288 {
33289 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33290 }
33291 {
33292 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33293 }
33294
33295 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33296
33297 {
33298 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33299 }
33300 {
33301 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33302 }
33303 {
33304 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33305 }
33306 {
33307 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33308 }
33309 {
33310 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33311 }
33312 {
33313 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33314 }
33315 {
33316 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33317 }
33318 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33319 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33320 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33321 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33322 {
33323 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33324 }
33325 {
33326 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33327 }
33328 {
33329 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33330 }
33331 {
33332 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33333 }
33334 {
33335 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33336 }
33337 {
33338 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33339 }
33340 {
33341 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33342 }
33343 {
33344 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33345 }
33346 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33347 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33348 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33349 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33350 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33351 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33352 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33353 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33354 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33355 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33356 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33357 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33358 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33359 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33360 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33361 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33362 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33363 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33364 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33365 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33366 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33367 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33368 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33369 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33370 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33371 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33372 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33373 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33374 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33375 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33376 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33377 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33378 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33379 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33380 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33381 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33382 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33383 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33384 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33385 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33386 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33387 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33388 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33389 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33390 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33391
33392 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33393
33394 {
33395 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33396 }
33397 {
33398 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33399 }
33400 {
33401 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33402 }
33403 {
33404 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33417 }
33418 {
33419 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33420 }
33421 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33422 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33423 {
33424 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
33887 }
33888 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
33889 {
33890 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
33948 }
33949 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
33950 {
33951 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
33985 }
33986
33987 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
33988 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
33989 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
33990 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
33991
33992 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
33993 }
33994
wxWidgets (Impactor)