]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Little tweaks to match CVS changes
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxDC 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_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxFileConfig 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 long wxGetFreeMemory()
1661 { wxPyRaiseNotImplemented(); return 0; }
1662
1663
1664 SWIGINTERN int
1665 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1666 {
1667 long v = 0;
1668 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1669 SWIG_type_error("unsigned number", obj);
1670 }
1671 else if (val)
1672 *val = (unsigned long)v;
1673 return 1;
1674 }
1675
1676
1677 SWIGINTERNSHORT unsigned long
1678 SWIG_As_unsigned_SS_long(PyObject* obj)
1679 {
1680 unsigned long v;
1681 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1682 /*
1683 this is needed to make valgrind/purify happier.
1684 */
1685 memset((void*)&v, 0, sizeof(unsigned long));
1686 }
1687 return v;
1688 }
1689
1690
1691 SWIGINTERNSHORT int
1692 SWIG_Check_unsigned_SS_long(PyObject* obj)
1693 {
1694 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1695 }
1696
1697
1698 SWIGINTERNSHORT PyObject*
1699 SWIG_From_unsigned_SS_long(unsigned long value)
1700 {
1701 return (value > LONG_MAX) ?
1702 PyLong_FromUnsignedLong(value)
1703 : PyInt_FromLong((long)(value));
1704 }
1705
1706
1707 void wxWakeUpMainThread() {}
1708
1709
1710 bool wxThread_IsMain() {
1711 #ifdef WXP_WITH_THREAD
1712 return wxThread::IsMain();
1713 #else
1714 return true;
1715 #endif
1716 }
1717
1718 static void wxCaret_Destroy(wxCaret *self){
1719 delete self;
1720 }
1721
1722 #include <wx/snglinst.h>
1723
1724
1725 #ifdef __WXMSW__
1726 #include <wx/msw/private.h>
1727 #include <wx/dynload.h>
1728 #endif
1729
1730
1731
1732 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1733 #if 0
1734 , int method
1735 #endif
1736 )
1737 {
1738 #ifdef __WXMSW__
1739 #if 0
1740 switch (method)
1741 {
1742 case 1:
1743 // This one only partially works. Appears to be an undocumented
1744 // "standard" convention that not all widgets adhear to. For
1745 // example, for some widgets backgrounds or non-client areas may
1746 // not be painted.
1747 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1748 break;
1749
1750 case 2:
1751 #endif
1752 // This one works much better, nearly all widgets and their
1753 // children are captured correctly[**]. Prior to the big
1754 // background erase changes that Vadim did in 2004-2005 this
1755 // method failed badly on XP with Themes activated, most native
1756 // widgets draw only partially, if at all. Without themes it
1757 // worked just like on Win2k. After those changes this method
1758 // works very well.
1759 //
1760 // ** For example the radio buttons in a wxRadioBox are not its
1761 // children by default, but you can capture it via the panel
1762 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1763 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1764 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1765 PRF_ERASEBKGND | PRF_OWNED );
1766 return true;
1767 #if 0
1768 break;
1769
1770 case 3:
1771 // This one is only defined in the latest SDK and is only
1772 // available on XP. MSDN says it is similar to sending WM_PRINT
1773 // so I expect that it will work similar to the above. Since it
1774 // is avaialble only on XP, it can't be compiled like this and
1775 // will have to be loaded dynamically.
1776 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1777
1778 // fall through
1779
1780 case 4:
1781 // Use PrintWindow if available, or fallback to WM_PRINT
1782 // otherwise. Unfortunately using PrintWindow is even worse than
1783 // WM_PRINT. For most native widgets nothing is drawn to the dc
1784 // at all, with or without Themes.
1785 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1786 static bool s_triedToLoad = false;
1787 static PrintWindow_t pfnPrintWindow = NULL;
1788 if ( !s_triedToLoad )
1789 {
1790
1791 s_triedToLoad = true;
1792 wxDynamicLibrary dllUser32(_T("user32.dll"));
1793 if ( dllUser32.IsLoaded() )
1794 {
1795 wxLogNull nolog; // Don't report errors here
1796 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1797 }
1798 }
1799 if (pfnPrintWindow)
1800 {
1801 //printf("Using PrintWindow\n");
1802 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1803 }
1804 else
1805 {
1806 //printf("Using WM_PRINT\n");
1807 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1808 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1809 PRF_ERASEBKGND | PRF_OWNED );
1810 }
1811 }
1812 #endif // 0
1813 #else
1814 return false;
1815 #endif // __WXMSW__
1816 }
1817
1818
1819
1820 #include <wx/tipdlg.h>
1821
1822
1823 class wxPyTipProvider : public wxTipProvider {
1824 public:
1825 wxPyTipProvider(size_t currentTip)
1826 : wxTipProvider(currentTip) {}
1827
1828 DEC_PYCALLBACK_STRING__pure(GetTip);
1829 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1830 PYPRIVATE;
1831 };
1832
1833 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1834 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1835
1836
1837 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1838
1839 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1840
1841 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1842 : wxTimer(owner, id)
1843 {
1844 if (owner == NULL) SetOwner(this);
1845 }
1846
1847
1848 void wxPyTimer::Notify() {
1849 bool found;
1850 bool blocked = wxPyBeginBlockThreads();
1851 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1852 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1853 wxPyEndBlockThreads(blocked);
1854 if (! found)
1855 wxTimer::Notify();
1856 }
1857 void wxPyTimer::base_Notify() {
1858 wxTimer::Notify();
1859 }
1860
1861
1862
1863 SWIGINTERN PyObject *
1864 SWIG_FromCharPtr(const char* cptr)
1865 {
1866 if (cptr) {
1867 size_t size = strlen(cptr);
1868 if (size > INT_MAX) {
1869 return SWIG_NewPointerObj((char*)(cptr),
1870 SWIG_TypeQuery("char *"), 0);
1871 } else {
1872 if (size != 0) {
1873 return PyString_FromStringAndSize(cptr, size);
1874 } else {
1875 return PyString_FromString(cptr);
1876 }
1877 }
1878 }
1879 Py_INCREF(Py_None);
1880 return Py_None;
1881 }
1882
1883
1884 SWIGINTERNSHORT int
1885 SWIG_CheckUnsignedLongInRange(unsigned long value,
1886 unsigned long max_value,
1887 const char *errmsg)
1888 {
1889 if (value > max_value) {
1890 if (errmsg) {
1891 PyErr_Format(PyExc_OverflowError,
1892 "value %lu is greater than '%s' minimum %lu",
1893 value, errmsg, max_value);
1894 }
1895 return 0;
1896 }
1897 return 1;
1898 }
1899
1900
1901 #if UINT_MAX != ULONG_MAX
1902 SWIGINTERN int
1903 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1904 {
1905 const char* errmsg = val ? "unsigned int" : (char*)0;
1906 unsigned long v;
1907 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1908 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1909 if (val) *val = (unsigned int)(v);
1910 return 1;
1911 }
1912 } else {
1913 PyErr_Clear();
1914 }
1915 if (val) {
1916 SWIG_type_error(errmsg, obj);
1917 }
1918 return 0;
1919 }
1920 #else
1921 SWIGINTERNSHORT unsigned int
1922 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1923 {
1924 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1925 }
1926 #endif
1927
1928
1929 SWIGINTERNSHORT unsigned int
1930 SWIG_As_unsigned_SS_int(PyObject* obj)
1931 {
1932 unsigned int v;
1933 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1934 /*
1935 this is needed to make valgrind/purify happier.
1936 */
1937 memset((void*)&v, 0, sizeof(unsigned int));
1938 }
1939 return v;
1940 }
1941
1942
1943 SWIGINTERNSHORT int
1944 SWIG_Check_unsigned_SS_int(PyObject* obj)
1945 {
1946 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1947 }
1948
1949 static wxString Log_TimeStamp(){
1950 wxString msg;
1951 wxLog::TimeStamp(&msg);
1952 return msg;
1953 }
1954 static void wxLog_Destroy(wxLog *self){ delete self; }
1955 // Make somce wrappers that double any % signs so they are 'escaped'
1956 void wxPyLogFatalError(const wxString& msg)
1957 {
1958 wxString m(msg);
1959 m.Replace(wxT("%"), wxT("%%"));
1960 wxLogFatalError(m);
1961 }
1962
1963 void wxPyLogError(const wxString& msg)
1964 {
1965 wxString m(msg);
1966 m.Replace(wxT("%"), wxT("%%"));
1967 wxLogError(m);
1968 }
1969
1970 void wxPyLogWarning(const wxString& msg)
1971 {
1972 wxString m(msg);
1973 m.Replace(wxT("%"), wxT("%%"));
1974 wxLogWarning(m);
1975 }
1976
1977 void wxPyLogMessage(const wxString& msg)
1978 {
1979 wxString m(msg);
1980 m.Replace(wxT("%"), wxT("%%"));
1981 wxLogMessage(m);
1982 }
1983
1984 void wxPyLogInfo(const wxString& msg)
1985 {
1986 wxString m(msg);
1987 m.Replace(wxT("%"), wxT("%%"));
1988 wxLogInfo(m);
1989 }
1990
1991 void wxPyLogDebug(const wxString& msg)
1992 {
1993 wxString m(msg);
1994 m.Replace(wxT("%"), wxT("%%"));
1995 wxLogDebug(m);
1996 }
1997
1998 void wxPyLogVerbose(const wxString& msg)
1999 {
2000 wxString m(msg);
2001 m.Replace(wxT("%"), wxT("%%"));
2002 wxLogVerbose(m);
2003 }
2004
2005 void wxPyLogStatus(const wxString& msg)
2006 {
2007 wxString m(msg);
2008 m.Replace(wxT("%"), wxT("%%"));
2009 wxLogStatus(m);
2010 }
2011
2012 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2013 {
2014 wxString m(msg);
2015 m.Replace(wxT("%"), wxT("%%"));
2016 wxLogStatus(pFrame, m);
2017 }
2018
2019 void wxPyLogSysError(const wxString& msg)
2020 {
2021 wxString m(msg);
2022 m.Replace(wxT("%"), wxT("%%"));
2023 wxLogSysError(m);
2024 }
2025
2026 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2027 {
2028 wxString m(msg);
2029 m.Replace(wxT("%"), wxT("%%"));
2030 wxLogGeneric(level, m);
2031 }
2032
2033 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2034 {
2035 wxString m(msg);
2036 m.Replace(wxT("%"), wxT("%%"));
2037 wxLogTrace(mask, m);
2038 }
2039
2040 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2041 {
2042 wxString m(msg);
2043 m.Replace(wxT("%"), wxT("%%"));
2044 wxLogTrace(mask, m);
2045 }
2046
2047
2048
2049 // A wxLog class that can be derived from in wxPython
2050 class wxPyLog : public wxLog {
2051 public:
2052 wxPyLog() : wxLog() {}
2053
2054 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2055 bool found;
2056 bool blocked = wxPyBeginBlockThreads();
2057 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2058 PyObject* s = wx2PyString(szString);
2059 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2060 Py_DECREF(s);
2061 }
2062 wxPyEndBlockThreads(blocked);
2063 if (! found)
2064 wxLog::DoLog(level, szString, t);
2065 }
2066
2067 virtual void DoLogString(const wxChar *szString, time_t t) {
2068 bool found;
2069 bool blocked = wxPyBeginBlockThreads();
2070 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2071 PyObject* s = wx2PyString(szString);
2072 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2073 Py_DECREF(s);
2074 }
2075 wxPyEndBlockThreads(blocked);
2076 if (! found)
2077 wxLog::DoLogString(szString, t);
2078 }
2079
2080 PYPRIVATE;
2081 };
2082
2083
2084
2085
2086 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2087
2088
2089 #include <wx/joystick.h>
2090
2091
2092 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2093 // A C++ stub class for wxJoystick for platforms that don't have it.
2094 class wxJoystick : public wxObject {
2095 public:
2096 wxJoystick(int joystick = wxJOYSTICK1) {
2097 bool blocked = wxPyBeginBlockThreads();
2098 PyErr_SetString(PyExc_NotImplementedError,
2099 "wxJoystick is not available on this platform.");
2100 wxPyEndBlockThreads(blocked);
2101 }
2102 wxPoint GetPosition() { return wxPoint(-1,-1); }
2103 int GetZPosition() { return -1; }
2104 int GetButtonState() { return -1; }
2105 int GetPOVPosition() { return -1; }
2106 int GetPOVCTSPosition() { return -1; }
2107 int GetRudderPosition() { return -1; }
2108 int GetUPosition() { return -1; }
2109 int GetVPosition() { return -1; }
2110 int GetMovementThreshold() { return -1; }
2111 void SetMovementThreshold(int threshold) {}
2112
2113 bool IsOk(void) { return false; }
2114 int GetNumberJoysticks() { return -1; }
2115 int GetManufacturerId() { return -1; }
2116 int GetProductId() { return -1; }
2117 wxString GetProductName() { return wxEmptyString; }
2118 int GetXMin() { return -1; }
2119 int GetYMin() { return -1; }
2120 int GetZMin() { return -1; }
2121 int GetXMax() { return -1; }
2122 int GetYMax() { return -1; }
2123 int GetZMax() { return -1; }
2124 int GetNumberButtons() { return -1; }
2125 int GetNumberAxes() { return -1; }
2126 int GetMaxButtons() { return -1; }
2127 int GetMaxAxes() { return -1; }
2128 int GetPollingMin() { return -1; }
2129 int GetPollingMax() { return -1; }
2130 int GetRudderMin() { return -1; }
2131 int GetRudderMax() { return -1; }
2132 int GetUMin() { return -1; }
2133 int GetUMax() { return -1; }
2134 int GetVMin() { return -1; }
2135 int GetVMax() { return -1; }
2136
2137 bool HasRudder() { return false; }
2138 bool HasZ() { return false; }
2139 bool HasU() { return false; }
2140 bool HasV() { return false; }
2141 bool HasPOV() { return false; }
2142 bool HasPOV4Dir() { return false; }
2143 bool HasPOVCTS() { return false; }
2144
2145 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2146 bool ReleaseCapture() { return false; }
2147 };
2148 #endif
2149
2150
2151 #include <wx/sound.h>
2152
2153
2154 #if !wxUSE_SOUND
2155 // A C++ stub class for wxWave for platforms that don't have it.
2156 class wxSound : public wxObject
2157 {
2158 public:
2159 wxSound() {
2160 bool blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(const wxString&/*, bool*/) {
2166 bool blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171 wxSound(int, const wxByte*) {
2172 bool blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177
2178 ~wxSound() {};
2179
2180 bool Create(const wxString&/*, bool*/) { return false; }
2181 bool Create(int, const wxByte*) { return false; };
2182 bool IsOk() { return false; };
2183 bool Play(unsigned) const { return false; }
2184 static bool Play(const wxString&, unsigned) { return false; }
2185 static void Stop() {}
2186 };
2187
2188 #endif
2189
2190 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2191 if (fileName.Length() == 0)
2192 return new wxSound;
2193 else
2194 return new wxSound(fileName);
2195 }
2196 static wxSound *new_wxSound(PyObject *data){
2197 unsigned char* buffer; int size;
2198 wxSound *sound = NULL;
2199
2200 bool blocked = wxPyBeginBlockThreads();
2201 if (!PyArg_Parse(data, "t#", &buffer, &size))
2202 goto done;
2203 sound = new wxSound(size, buffer);
2204 done:
2205 wxPyEndBlockThreads(blocked);
2206 return sound;
2207 }
2208 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2209 #ifndef __WXMAC__
2210 unsigned char* buffer;
2211 int size;
2212 bool rv = false;
2213
2214 bool blocked = wxPyBeginBlockThreads();
2215 if (!PyArg_Parse(data, "t#", &buffer, &size))
2216 goto done;
2217 rv = self->Create(size, buffer);
2218 done:
2219 wxPyEndBlockThreads(blocked);
2220 return rv;
2221 #else
2222 bool blocked = wxPyBeginBlockThreads();
2223 PyErr_SetString(PyExc_NotImplementedError,
2224 "Create from data is not available on this platform.");
2225 wxPyEndBlockThreads(blocked);
2226 return false;
2227 #endif
2228 }
2229
2230 #include <wx/mimetype.h>
2231
2232 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2233 wxString str;
2234 if (self->GetMimeType(&str))
2235 return wx2PyString(str);
2236 else
2237 RETURN_NONE();
2238 }
2239 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2240 wxArrayString arr;
2241 if (self->GetMimeTypes(arr))
2242 return wxArrayString2PyList_helper(arr);
2243 else
2244 RETURN_NONE();
2245 }
2246 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2247 wxArrayString arr;
2248 if (self->GetExtensions(arr))
2249 return wxArrayString2PyList_helper(arr);
2250 else
2251 RETURN_NONE();
2252 }
2253 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2254 wxIconLocation loc;
2255 if (self->GetIcon(&loc))
2256 return new wxIcon(loc);
2257 else
2258 return NULL;
2259 }
2260 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2261 wxIconLocation loc;
2262 if (self->GetIcon(&loc)) {
2263 wxString iconFile = loc.GetFileName();
2264 int iconIndex = -1;
2265
2266
2267
2268 // Make a tuple and put the values in it
2269 bool blocked = wxPyBeginBlockThreads();
2270 PyObject* tuple = PyTuple_New(3);
2271 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2272 wxT("wxIcon"), true));
2273 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2274 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2275 wxPyEndBlockThreads(blocked);
2276 return tuple;
2277 }
2278 else
2279 RETURN_NONE();
2280 }
2281 static PyObject *wxFileType_GetDescription(wxFileType *self){
2282 wxString str;
2283 if (self->GetDescription(&str))
2284 return wx2PyString(str);
2285 else
2286 RETURN_NONE();
2287 }
2288 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2289 wxString str;
2290 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2291 return wx2PyString(str);
2292 else
2293 RETURN_NONE();
2294 }
2295 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2296 wxString str;
2297 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2298 return wx2PyString(str);
2299 else
2300 RETURN_NONE();
2301 }
2302 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2303 wxArrayString verbs;
2304 wxArrayString commands;
2305 if (self->GetAllCommands(&verbs, &commands,
2306 wxFileType::MessageParameters(filename, mimetype))) {
2307 bool blocked = wxPyBeginBlockThreads();
2308 PyObject* tuple = PyTuple_New(2);
2309 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2310 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2311 wxPyEndBlockThreads(blocked);
2312 return tuple;
2313 }
2314 else
2315 RETURN_NONE();
2316 }
2317 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2318 return wxFileType::ExpandCommand(command,
2319 wxFileType::MessageParameters(filename, mimetype));
2320 }
2321 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2322 wxArrayString arr;
2323 self->EnumAllFileTypes(arr);
2324 return wxArrayString2PyList_helper(arr);
2325 }
2326
2327 #include <wx/artprov.h>
2328
2329 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2330 static const wxString wxPyART_MENU(wxART_MENU);
2331 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2332 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2333 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2334 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2335 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2336 static const wxString wxPyART_OTHER(wxART_OTHER);
2337 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2338 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2339 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2340 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2341 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2342 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2343 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2344 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2345 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2346 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2347 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2348 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2349 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2350 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2351 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2352 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2353 static const wxString wxPyART_PRINT(wxART_PRINT);
2354 static const wxString wxPyART_HELP(wxART_HELP);
2355 static const wxString wxPyART_TIP(wxART_TIP);
2356 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2357 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2358 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2359 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2360 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2361 static const wxString wxPyART_CDROM(wxART_CDROM);
2362 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2363 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2364 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2365 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2366 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2367 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2368 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2369 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2370 static const wxString wxPyART_ERROR(wxART_ERROR);
2371 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2372 static const wxString wxPyART_WARNING(wxART_WARNING);
2373 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2374 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2375 static const wxString wxPyART_COPY(wxART_COPY);
2376 static const wxString wxPyART_CUT(wxART_CUT);
2377 static const wxString wxPyART_PASTE(wxART_PASTE);
2378 static const wxString wxPyART_DELETE(wxART_DELETE);
2379 static const wxString wxPyART_UNDO(wxART_UNDO);
2380 static const wxString wxPyART_REDO(wxART_REDO);
2381 static const wxString wxPyART_QUIT(wxART_QUIT);
2382 static const wxString wxPyART_FIND(wxART_FIND);
2383 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2384 // Python aware wxArtProvider
2385 class wxPyArtProvider : public wxArtProvider {
2386 public:
2387
2388 virtual wxBitmap CreateBitmap(const wxArtID& id,
2389 const wxArtClient& client,
2390 const wxSize& size) {
2391 wxBitmap rval = wxNullBitmap;
2392 bool blocked = wxPyBeginBlockThreads();
2393 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2394 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2395 PyObject* ro;
2396 wxBitmap* ptr;
2397 PyObject* s1, *s2;
2398 s1 = wx2PyString(id);
2399 s2 = wx2PyString(client);
2400 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2401 Py_DECREF(so);
2402 Py_DECREF(s1);
2403 Py_DECREF(s2);
2404 if (ro) {
2405 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2406 rval = *ptr;
2407 Py_DECREF(ro);
2408 }
2409 }
2410 wxPyEndBlockThreads(blocked);
2411 return rval;
2412 }
2413
2414 PYPRIVATE;
2415 };
2416
2417 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2418
2419
2420
2421 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2422 PyObject* ret = PyTuple_New(3);
2423 if (ret) {
2424 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2425 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2426 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2427 }
2428 return ret;
2429 }
2430
2431 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2432 bool cont;
2433 long index = 0;
2434 wxString value;
2435
2436 cont = self->GetFirstGroup(value, index);
2437 return __EnumerationHelper(cont, value, index);
2438 }
2439 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2440 bool cont;
2441 wxString value;
2442
2443 cont = self->GetNextGroup(value, index);
2444 return __EnumerationHelper(cont, value, index);
2445 }
2446 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2447 bool cont;
2448 long index = 0;
2449 wxString value;
2450
2451 cont = self->GetFirstEntry(value, index);
2452 return __EnumerationHelper(cont, value, index);
2453 }
2454 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2455 bool cont;
2456 wxString value;
2457
2458 cont = self->GetNextEntry(value, index);
2459 return __EnumerationHelper(cont, value, index);
2460 }
2461 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2462 long rv;
2463 self->Read(key, &rv, defaultVal);
2464 return rv;
2465 }
2466
2467 SWIGINTERN int
2468 SWIG_AsVal_double(PyObject *obj, double* val)
2469 {
2470 if (PyNumber_Check(obj)) {
2471 if (val) *val = PyFloat_AsDouble(obj);
2472 return 1;
2473 }
2474 else {
2475 SWIG_type_error("number", obj);
2476 }
2477 return 0;
2478 }
2479
2480
2481 SWIGINTERNSHORT double
2482 SWIG_As_double(PyObject* obj)
2483 {
2484 double v;
2485 if (!SWIG_AsVal_double(obj, &v)) {
2486 /*
2487 this is needed to make valgrind/purify happier.
2488 */
2489 memset((void*)&v, 0, sizeof(double));
2490 }
2491 return v;
2492 }
2493
2494
2495 SWIGINTERNSHORT int
2496 SWIG_Check_double(PyObject* obj)
2497 {
2498 return SWIG_AsVal_double(obj, (double*)0);
2499 }
2500
2501 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2502 double rv;
2503 self->Read(key, &rv, defaultVal);
2504 return rv;
2505 }
2506
2507 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2508 #define SWIG_From_double PyFloat_FromDouble
2509 /*@@*/
2510
2511 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2512 bool rv;
2513 self->Read(key, &rv, defaultVal);
2514 return rv;
2515 }
2516
2517 #include <wx/datetime.h>
2518
2519 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2520 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2521
2522 #define LOCAL_TZ wxDateTime::Local
2523
2524 static PyObject *DateTime_GetAmPmStrings(){
2525 wxString am;
2526 wxString pm;
2527 wxDateTime::GetAmPmStrings(&am, &pm);
2528 bool blocked = wxPyBeginBlockThreads();
2529 PyObject* tup = PyTuple_New(2);
2530 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2531 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2532 wxPyEndBlockThreads(blocked);
2533 return tup;
2534 }
2535
2536 #if UINT_MAX < LONG_MAX
2537 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2538 #define SWIG_From_unsigned_SS_int SWIG_From_long
2539 /*@@*/
2540 #else
2541 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2542 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2543 /*@@*/
2544 #endif
2545
2546 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2547 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2548 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2549 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2550 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2551 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2552 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2553 return (*self < *other);
2554 }
2555 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2556 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2557 return (*self <= *other);
2558 }
2559 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2560 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2561 return (*self > *other);
2562 }
2563 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2564 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2565 return (*self >= *other);
2566 }
2567 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2568 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2569 return (*self == *other);
2570 }
2571 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2572 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2573 return (*self != *other);
2574 }
2575 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2576 const wxChar* rv;
2577 const wxChar* _date = date;
2578 rv = self->ParseRfc822Date(_date);
2579 if (rv == NULL) return -1;
2580 return rv - _date;
2581 }
2582 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2583 const wxChar* rv;
2584 const wxChar* _date = date;
2585 rv = self->ParseFormat(_date, format, dateDef);
2586 if (rv == NULL) return -1;
2587 return rv - _date;
2588 }
2589 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2590 const wxChar* rv;
2591 const wxChar* _datetime = datetime;
2592 rv = self->ParseDateTime(_datetime);
2593 if (rv == NULL) return -1;
2594 return rv - _datetime;
2595 }
2596 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2597 const wxChar* rv;
2598 const wxChar* _date = date;
2599 rv = self->ParseDate(_date);
2600 if (rv == NULL) return -1;
2601 return rv - _date;
2602 }
2603 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2604 const wxChar* rv;
2605 const wxChar* _time = time;
2606 rv = self->ParseTime(_time);
2607 if (rv == NULL) return -1;
2608 return rv - _time;
2609 }
2610 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2611 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2612 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2613 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2614 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2615 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2616 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2617 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2618 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2620 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2621 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2622 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2623 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2624 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2625 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2626
2627 #include <wx/dataobj.h>
2628
2629 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2630 size_t count = self->GetFormatCount(dir);
2631 wxDataFormat* formats = new wxDataFormat[count];
2632 self->GetAllFormats(formats, dir);
2633
2634 bool blocked = wxPyBeginBlockThreads();
2635 PyObject* list = PyList_New(count);
2636 for (size_t i=0; i<count; i++) {
2637 wxDataFormat* format = new wxDataFormat(formats[i]);
2638 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2639 PyList_Append(list, obj);
2640 Py_DECREF(obj);
2641 }
2642 wxPyEndBlockThreads(blocked);
2643 delete [] formats;
2644 return list;
2645 }
2646 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2647 PyObject* rval = NULL;
2648 size_t size = self->GetDataSize(format);
2649 bool blocked = wxPyBeginBlockThreads();
2650 if (size) {
2651 char* buf = new char[size];
2652 if (self->GetDataHere(format, buf))
2653 rval = PyString_FromStringAndSize(buf, size);
2654 delete [] buf;
2655 }
2656 if (! rval) {
2657 rval = Py_None;
2658 Py_INCREF(rval);
2659 }
2660 wxPyEndBlockThreads(blocked);
2661 return rval;
2662 }
2663 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2664 bool rval;
2665 bool blocked = wxPyBeginBlockThreads();
2666 if (PyString_Check(data)) {
2667 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2668 }
2669 else {
2670 // raise a TypeError if not a string
2671 PyErr_SetString(PyExc_TypeError, "String expected.");
2672 rval = false;
2673 }
2674 wxPyEndBlockThreads(blocked);
2675 return rval;
2676 }
2677 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2678 PyObject* rval = NULL;
2679 size_t size = self->GetDataSize();
2680 bool blocked = wxPyBeginBlockThreads();
2681 if (size) {
2682 char* buf = new char[size];
2683 if (self->GetDataHere(buf))
2684 rval = PyString_FromStringAndSize(buf, size);
2685 delete [] buf;
2686 }
2687 if (! rval) {
2688 rval = Py_None;
2689 Py_INCREF(rval);
2690 }
2691 wxPyEndBlockThreads(blocked);
2692 return rval;
2693 }
2694 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2695 bool rval;
2696 bool blocked = wxPyBeginBlockThreads();
2697 if (PyString_Check(data)) {
2698 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2699 }
2700 else {
2701 // raise a TypeError if not a string
2702 PyErr_SetString(PyExc_TypeError, "String expected.");
2703 rval = false;
2704 }
2705 wxPyEndBlockThreads(blocked);
2706 return rval;
2707 }
2708 // Create a new class for wxPython to use
2709 class wxPyDataObjectSimple : public wxDataObjectSimple {
2710 public:
2711 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2712 : wxDataObjectSimple(format) {}
2713
2714 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2715 bool GetDataHere(void *buf) const;
2716 bool SetData(size_t len, const void *buf) const;
2717 PYPRIVATE;
2718 };
2719
2720 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2721
2722 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2723 // We need to get the data for this object and write it to buf. I think
2724 // the best way to do this for wxPython is to have the Python method
2725 // return either a string or None and then act appropriately with the
2726 // C++ version.
2727
2728 bool rval = false;
2729 bool blocked = wxPyBeginBlockThreads();
2730 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2731 PyObject* ro;
2732 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2733 if (ro) {
2734 rval = (ro != Py_None && PyString_Check(ro));
2735 if (rval)
2736 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2737 Py_DECREF(ro);
2738 }
2739 }
2740 wxPyEndBlockThreads(blocked);
2741 return rval;
2742 }
2743
2744 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2745 // For this one we simply need to make a string from buf and len
2746 // and send it to the Python method.
2747 bool rval = false;
2748 bool blocked = wxPyBeginBlockThreads();
2749 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2750 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2751 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2752 Py_DECREF(data);
2753 }
2754 wxPyEndBlockThreads(blocked);
2755 return rval;
2756 }
2757
2758 // Create a new class for wxPython to use
2759 class wxPyTextDataObject : public wxTextDataObject {
2760 public:
2761 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2762 : wxTextDataObject(text) {}
2763
2764 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2765 DEC_PYCALLBACK_STRING__const(GetText);
2766 DEC_PYCALLBACK__STRING(SetText);
2767 PYPRIVATE;
2768 };
2769
2770 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2771 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2772 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2773
2774
2775 // Create a new class for wxPython to use
2776 class wxPyBitmapDataObject : public wxBitmapDataObject {
2777 public:
2778 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2779 : wxBitmapDataObject(bitmap) {}
2780
2781 wxBitmap GetBitmap() const;
2782 void SetBitmap(const wxBitmap& bitmap);
2783 PYPRIVATE;
2784 };
2785
2786 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2787 wxBitmap* rval = &wxNullBitmap;
2788 bool blocked = wxPyBeginBlockThreads();
2789 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2790 PyObject* ro;
2791 wxBitmap* ptr;
2792 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2793 if (ro) {
2794 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2795 rval = ptr;
2796 Py_DECREF(ro);
2797 }
2798 }
2799 wxPyEndBlockThreads(blocked);
2800 return *rval;
2801 }
2802
2803 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2804 bool blocked = wxPyBeginBlockThreads();
2805 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2806 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2807 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2808 Py_DECREF(bo);
2809 }
2810 wxPyEndBlockThreads(blocked);
2811 }
2812
2813 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2814 return new wxCustomDataObject(wxDataFormat(formatName));
2815 }
2816 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2817 bool rval;
2818 bool blocked = wxPyBeginBlockThreads();
2819 if (PyString_Check(data)) {
2820 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2821 }
2822 else {
2823 // raise a TypeError if not a string
2824 PyErr_SetString(PyExc_TypeError, "String expected.");
2825 rval = false;
2826 }
2827 wxPyEndBlockThreads(blocked);
2828 return rval;
2829 }
2830 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2831 PyObject* obj;
2832 bool blocked = wxPyBeginBlockThreads();
2833 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2834 wxPyEndBlockThreads(blocked);
2835 return obj;
2836 }
2837
2838 class wxMetafileDataObject : public wxDataObjectSimple
2839 {
2840 public:
2841 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2842 };
2843
2844
2845 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2846
2847
2848 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2849 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2850 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2851 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2852 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2853
2854
2855 class wxPyTextDropTarget : public wxTextDropTarget {
2856 public:
2857 wxPyTextDropTarget() {}
2858
2859 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2860
2861 DEC_PYCALLBACK__(OnLeave);
2862 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2863 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2864 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2865 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2866
2867 PYPRIVATE;
2868 };
2869
2870 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2871 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2872 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2873 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2874 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2875 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2876
2877
2878
2879 class wxPyFileDropTarget : public wxFileDropTarget {
2880 public:
2881 wxPyFileDropTarget() {}
2882
2883 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2884
2885 DEC_PYCALLBACK__(OnLeave);
2886 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2887 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2888 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2889 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2890
2891 PYPRIVATE;
2892 };
2893
2894 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2895 const wxArrayString& filenames) {
2896 bool rval = false;
2897 bool blocked = wxPyBeginBlockThreads();
2898 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2899 PyObject* list = wxArrayString2PyList_helper(filenames);
2900 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2901 Py_DECREF(list);
2902 }
2903 wxPyEndBlockThreads(blocked);
2904 return rval;
2905 }
2906
2907
2908
2909 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2910 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2911 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2912 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2913 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2914
2915
2916
2917
2918 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2919
2920 #include <wx/display.h>
2921
2922 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2923 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2924
2925 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2926 #if !wxUSE_DISPLAY
2927 #include <wx/dynarray.h>
2928 #include <wx/vidmode.h>
2929
2930 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2931 #include "wx/arrimpl.cpp"
2932 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2933 const wxVideoMode wxDefaultVideoMode;
2934
2935 class wxDisplay
2936 {
2937 public:
2938 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2939 ~wxDisplay() {}
2940
2941 static size_t GetCount()
2942 { wxPyRaiseNotImplemented(); return 0; }
2943
2944 static int GetFromPoint(const wxPoint& pt)
2945 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2946 static int GetFromWindow(wxWindow *window)
2947 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2948
2949 virtual bool IsOk() const { return false; }
2950 virtual wxRect GetGeometry() const { wxRect r; return r; }
2951 virtual wxString GetName() const { return wxEmptyString; }
2952 bool IsPrimary() const { return false; }
2953
2954 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2955 { wxArrayVideoModes a; return a; }
2956
2957 virtual wxVideoMode GetCurrentMode() const
2958 { return wxDefaultVideoMode; }
2959
2960 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2961 { return false; }
2962
2963 void ResetMode() {}
2964 };
2965 #endif
2966
2967 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2968 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2969 PyObject* pyList = NULL;
2970 wxArrayVideoModes arr = self->GetModes(mode);
2971 bool blocked = wxPyBeginBlockThreads();
2972 pyList = PyList_New(0);
2973 for (int i=0; i < arr.GetCount(); i++) {
2974 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2975 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2976 PyList_Append(pyList, pyObj);
2977 Py_DECREF(pyObj);
2978 }
2979 wxPyEndBlockThreads(blocked);
2980 return pyList;
2981 }
2982
2983 #include <wx/stdpaths.h>
2984
2985 static wxStandardPaths *StandardPaths_Get(){
2986 return (wxStandardPaths*) &wxStandardPaths::Get();
2987 }
2988 #ifdef __cplusplus
2989 extern "C" {
2990 #endif
2991 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2992 PyObject *resultobj;
2993 wxSystemColour arg1 ;
2994 wxColour result;
2995 PyObject * obj0 = 0 ;
2996 char *kwnames[] = {
2997 (char *) "index", NULL
2998 };
2999
3000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3001 {
3002 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3003 if (SWIG_arg_fail(1)) SWIG_fail;
3004 }
3005 {
3006 if (!wxPyCheckForApp()) SWIG_fail;
3007 PyThreadState* __tstate = wxPyBeginAllowThreads();
3008 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3009
3010 wxPyEndAllowThreads(__tstate);
3011 if (PyErr_Occurred()) SWIG_fail;
3012 }
3013 {
3014 wxColour * resultptr;
3015 resultptr = new wxColour((wxColour &)(result));
3016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3017 }
3018 return resultobj;
3019 fail:
3020 return NULL;
3021 }
3022
3023
3024 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3025 PyObject *resultobj;
3026 wxSystemFont arg1 ;
3027 wxFont result;
3028 PyObject * obj0 = 0 ;
3029 char *kwnames[] = {
3030 (char *) "index", NULL
3031 };
3032
3033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3034 {
3035 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3036 if (SWIG_arg_fail(1)) SWIG_fail;
3037 }
3038 {
3039 if (!wxPyCheckForApp()) SWIG_fail;
3040 PyThreadState* __tstate = wxPyBeginAllowThreads();
3041 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3042
3043 wxPyEndAllowThreads(__tstate);
3044 if (PyErr_Occurred()) SWIG_fail;
3045 }
3046 {
3047 wxFont * resultptr;
3048 resultptr = new wxFont((wxFont &)(result));
3049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3050 }
3051 return resultobj;
3052 fail:
3053 return NULL;
3054 }
3055
3056
3057 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3058 PyObject *resultobj;
3059 wxSystemMetric arg1 ;
3060 int result;
3061 PyObject * obj0 = 0 ;
3062 char *kwnames[] = {
3063 (char *) "index", NULL
3064 };
3065
3066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3067 {
3068 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3069 if (SWIG_arg_fail(1)) SWIG_fail;
3070 }
3071 {
3072 if (!wxPyCheckForApp()) SWIG_fail;
3073 PyThreadState* __tstate = wxPyBeginAllowThreads();
3074 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3075
3076 wxPyEndAllowThreads(__tstate);
3077 if (PyErr_Occurred()) SWIG_fail;
3078 }
3079 {
3080 resultobj = SWIG_From_int((int)(result));
3081 }
3082 return resultobj;
3083 fail:
3084 return NULL;
3085 }
3086
3087
3088 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3089 PyObject *resultobj;
3090 wxSystemFeature arg1 ;
3091 bool result;
3092 PyObject * obj0 = 0 ;
3093 char *kwnames[] = {
3094 (char *) "index", NULL
3095 };
3096
3097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3098 {
3099 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3100 if (SWIG_arg_fail(1)) SWIG_fail;
3101 }
3102 {
3103 if (!wxPyCheckForApp()) SWIG_fail;
3104 PyThreadState* __tstate = wxPyBeginAllowThreads();
3105 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3106
3107 wxPyEndAllowThreads(__tstate);
3108 if (PyErr_Occurred()) SWIG_fail;
3109 }
3110 {
3111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3112 }
3113 return resultobj;
3114 fail:
3115 return NULL;
3116 }
3117
3118
3119 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3120 PyObject *resultobj;
3121 wxSystemScreenType result;
3122 char *kwnames[] = {
3123 NULL
3124 };
3125
3126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3127 {
3128 if (!wxPyCheckForApp()) SWIG_fail;
3129 PyThreadState* __tstate = wxPyBeginAllowThreads();
3130 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3131
3132 wxPyEndAllowThreads(__tstate);
3133 if (PyErr_Occurred()) SWIG_fail;
3134 }
3135 resultobj = SWIG_From_int((result));
3136 return resultobj;
3137 fail:
3138 return NULL;
3139 }
3140
3141
3142 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3143 PyObject *resultobj;
3144 wxSystemScreenType arg1 ;
3145 PyObject * obj0 = 0 ;
3146 char *kwnames[] = {
3147 (char *) "screen", NULL
3148 };
3149
3150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3151 {
3152 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3153 if (SWIG_arg_fail(1)) SWIG_fail;
3154 }
3155 {
3156 if (!wxPyCheckForApp()) SWIG_fail;
3157 PyThreadState* __tstate = wxPyBeginAllowThreads();
3158 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3159
3160 wxPyEndAllowThreads(__tstate);
3161 if (PyErr_Occurred()) SWIG_fail;
3162 }
3163 Py_INCREF(Py_None); resultobj = Py_None;
3164 return resultobj;
3165 fail:
3166 return NULL;
3167 }
3168
3169
3170 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3171 PyObject *obj;
3172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3173 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3174 Py_INCREF(obj);
3175 return Py_BuildValue((char *)"");
3176 }
3177 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3178 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3179 return 1;
3180 }
3181
3182
3183 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3184 PyObject *pyobj;
3185
3186 {
3187 #if wxUSE_UNICODE
3188 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3189 #else
3190 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3191 #endif
3192 }
3193 return pyobj;
3194 }
3195
3196
3197 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3198 PyObject *resultobj;
3199 wxSystemOptions *result;
3200 char *kwnames[] = {
3201 NULL
3202 };
3203
3204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3205 {
3206 PyThreadState* __tstate = wxPyBeginAllowThreads();
3207 result = (wxSystemOptions *)new wxSystemOptions();
3208
3209 wxPyEndAllowThreads(__tstate);
3210 if (PyErr_Occurred()) SWIG_fail;
3211 }
3212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3213 return resultobj;
3214 fail:
3215 return NULL;
3216 }
3217
3218
3219 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3220 PyObject *resultobj;
3221 wxString *arg1 = 0 ;
3222 wxString *arg2 = 0 ;
3223 bool temp1 = false ;
3224 bool temp2 = false ;
3225 PyObject * obj0 = 0 ;
3226 PyObject * obj1 = 0 ;
3227 char *kwnames[] = {
3228 (char *) "name",(char *) "value", NULL
3229 };
3230
3231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3232 {
3233 arg1 = wxString_in_helper(obj0);
3234 if (arg1 == NULL) SWIG_fail;
3235 temp1 = true;
3236 }
3237 {
3238 arg2 = wxString_in_helper(obj1);
3239 if (arg2 == NULL) SWIG_fail;
3240 temp2 = true;
3241 }
3242 {
3243 PyThreadState* __tstate = wxPyBeginAllowThreads();
3244 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3245
3246 wxPyEndAllowThreads(__tstate);
3247 if (PyErr_Occurred()) SWIG_fail;
3248 }
3249 Py_INCREF(Py_None); resultobj = Py_None;
3250 {
3251 if (temp1)
3252 delete arg1;
3253 }
3254 {
3255 if (temp2)
3256 delete arg2;
3257 }
3258 return resultobj;
3259 fail:
3260 {
3261 if (temp1)
3262 delete arg1;
3263 }
3264 {
3265 if (temp2)
3266 delete arg2;
3267 }
3268 return NULL;
3269 }
3270
3271
3272 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3273 PyObject *resultobj;
3274 wxString *arg1 = 0 ;
3275 int arg2 ;
3276 bool temp1 = false ;
3277 PyObject * obj0 = 0 ;
3278 PyObject * obj1 = 0 ;
3279 char *kwnames[] = {
3280 (char *) "name",(char *) "value", NULL
3281 };
3282
3283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3284 {
3285 arg1 = wxString_in_helper(obj0);
3286 if (arg1 == NULL) SWIG_fail;
3287 temp1 = true;
3288 }
3289 {
3290 arg2 = (int)(SWIG_As_int(obj1));
3291 if (SWIG_arg_fail(2)) SWIG_fail;
3292 }
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 Py_INCREF(Py_None); resultobj = Py_None;
3301 {
3302 if (temp1)
3303 delete arg1;
3304 }
3305 return resultobj;
3306 fail:
3307 {
3308 if (temp1)
3309 delete arg1;
3310 }
3311 return NULL;
3312 }
3313
3314
3315 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3316 PyObject *resultobj;
3317 wxString *arg1 = 0 ;
3318 wxString result;
3319 bool temp1 = false ;
3320 PyObject * obj0 = 0 ;
3321 char *kwnames[] = {
3322 (char *) "name", NULL
3323 };
3324
3325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3326 {
3327 arg1 = wxString_in_helper(obj0);
3328 if (arg1 == NULL) SWIG_fail;
3329 temp1 = true;
3330 }
3331 {
3332 PyThreadState* __tstate = wxPyBeginAllowThreads();
3333 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3334
3335 wxPyEndAllowThreads(__tstate);
3336 if (PyErr_Occurred()) SWIG_fail;
3337 }
3338 {
3339 #if wxUSE_UNICODE
3340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3341 #else
3342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3343 #endif
3344 }
3345 {
3346 if (temp1)
3347 delete arg1;
3348 }
3349 return resultobj;
3350 fail:
3351 {
3352 if (temp1)
3353 delete arg1;
3354 }
3355 return NULL;
3356 }
3357
3358
3359 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3360 PyObject *resultobj;
3361 wxString *arg1 = 0 ;
3362 int result;
3363 bool temp1 = false ;
3364 PyObject * obj0 = 0 ;
3365 char *kwnames[] = {
3366 (char *) "name", NULL
3367 };
3368
3369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3370 {
3371 arg1 = wxString_in_helper(obj0);
3372 if (arg1 == NULL) SWIG_fail;
3373 temp1 = true;
3374 }
3375 {
3376 PyThreadState* __tstate = wxPyBeginAllowThreads();
3377 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3378
3379 wxPyEndAllowThreads(__tstate);
3380 if (PyErr_Occurred()) SWIG_fail;
3381 }
3382 {
3383 resultobj = SWIG_From_int((int)(result));
3384 }
3385 {
3386 if (temp1)
3387 delete arg1;
3388 }
3389 return resultobj;
3390 fail:
3391 {
3392 if (temp1)
3393 delete arg1;
3394 }
3395 return NULL;
3396 }
3397
3398
3399 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj;
3401 wxString *arg1 = 0 ;
3402 bool result;
3403 bool temp1 = false ;
3404 PyObject * obj0 = 0 ;
3405 char *kwnames[] = {
3406 (char *) "name", NULL
3407 };
3408
3409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3410 {
3411 arg1 = wxString_in_helper(obj0);
3412 if (arg1 == NULL) SWIG_fail;
3413 temp1 = true;
3414 }
3415 {
3416 PyThreadState* __tstate = wxPyBeginAllowThreads();
3417 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3418
3419 wxPyEndAllowThreads(__tstate);
3420 if (PyErr_Occurred()) SWIG_fail;
3421 }
3422 {
3423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3424 }
3425 {
3426 if (temp1)
3427 delete arg1;
3428 }
3429 return resultobj;
3430 fail:
3431 {
3432 if (temp1)
3433 delete arg1;
3434 }
3435 return NULL;
3436 }
3437
3438
3439 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3440 PyObject *obj;
3441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3442 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3443 Py_INCREF(obj);
3444 return Py_BuildValue((char *)"");
3445 }
3446 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3447 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3448 return 1;
3449 }
3450
3451
3452 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3453 PyObject *pyobj;
3454
3455 {
3456 #if wxUSE_UNICODE
3457 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3458 #else
3459 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3460 #endif
3461 }
3462 return pyobj;
3463 }
3464
3465
3466 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3467 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3468 return 1;
3469 }
3470
3471
3472 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3473 PyObject *pyobj;
3474
3475 {
3476 #if wxUSE_UNICODE
3477 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3478 #else
3479 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3480 #endif
3481 }
3482 return pyobj;
3483 }
3484
3485
3486 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3487 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3488 return 1;
3489 }
3490
3491
3492 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3493 PyObject *pyobj;
3494
3495 {
3496 #if wxUSE_UNICODE
3497 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3498 #else
3499 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3500 #endif
3501 }
3502 return pyobj;
3503 }
3504
3505
3506 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3507 PyObject *resultobj;
3508 long result;
3509 char *kwnames[] = {
3510 NULL
3511 };
3512
3513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3514 {
3515 PyThreadState* __tstate = wxPyBeginAllowThreads();
3516 result = (long)wxNewId();
3517
3518 wxPyEndAllowThreads(__tstate);
3519 if (PyErr_Occurred()) SWIG_fail;
3520 }
3521 {
3522 resultobj = SWIG_From_long((long)(result));
3523 }
3524 return resultobj;
3525 fail:
3526 return NULL;
3527 }
3528
3529
3530 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3531 PyObject *resultobj;
3532 long arg1 ;
3533 PyObject * obj0 = 0 ;
3534 char *kwnames[] = {
3535 (char *) "id", NULL
3536 };
3537
3538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3539 {
3540 arg1 = (long)(SWIG_As_long(obj0));
3541 if (SWIG_arg_fail(1)) SWIG_fail;
3542 }
3543 {
3544 PyThreadState* __tstate = wxPyBeginAllowThreads();
3545 wxRegisterId(arg1);
3546
3547 wxPyEndAllowThreads(__tstate);
3548 if (PyErr_Occurred()) SWIG_fail;
3549 }
3550 Py_INCREF(Py_None); resultobj = Py_None;
3551 return resultobj;
3552 fail:
3553 return NULL;
3554 }
3555
3556
3557 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 long result;
3560 char *kwnames[] = {
3561 NULL
3562 };
3563
3564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3565 {
3566 PyThreadState* __tstate = wxPyBeginAllowThreads();
3567 result = (long)wxGetCurrentId();
3568
3569 wxPyEndAllowThreads(__tstate);
3570 if (PyErr_Occurred()) SWIG_fail;
3571 }
3572 {
3573 resultobj = SWIG_From_long((long)(result));
3574 }
3575 return resultobj;
3576 fail:
3577 return NULL;
3578 }
3579
3580
3581 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3582 PyObject *resultobj;
3583 int arg1 ;
3584 bool result;
3585 PyObject * obj0 = 0 ;
3586 char *kwnames[] = {
3587 (char *) "id", NULL
3588 };
3589
3590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3591 {
3592 arg1 = (int)(SWIG_As_int(obj0));
3593 if (SWIG_arg_fail(1)) SWIG_fail;
3594 }
3595 {
3596 PyThreadState* __tstate = wxPyBeginAllowThreads();
3597 result = (bool)wxIsStockID(arg1);
3598
3599 wxPyEndAllowThreads(__tstate);
3600 if (PyErr_Occurred()) SWIG_fail;
3601 }
3602 {
3603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3604 }
3605 return resultobj;
3606 fail:
3607 return NULL;
3608 }
3609
3610
3611 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3612 PyObject *resultobj;
3613 int arg1 ;
3614 wxString *arg2 = 0 ;
3615 bool result;
3616 bool temp2 = false ;
3617 PyObject * obj0 = 0 ;
3618 PyObject * obj1 = 0 ;
3619 char *kwnames[] = {
3620 (char *) "id",(char *) "label", NULL
3621 };
3622
3623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3624 {
3625 arg1 = (int)(SWIG_As_int(obj0));
3626 if (SWIG_arg_fail(1)) SWIG_fail;
3627 }
3628 {
3629 arg2 = wxString_in_helper(obj1);
3630 if (arg2 == NULL) SWIG_fail;
3631 temp2 = true;
3632 }
3633 {
3634 PyThreadState* __tstate = wxPyBeginAllowThreads();
3635 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3636
3637 wxPyEndAllowThreads(__tstate);
3638 if (PyErr_Occurred()) SWIG_fail;
3639 }
3640 {
3641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3642 }
3643 {
3644 if (temp2)
3645 delete arg2;
3646 }
3647 return resultobj;
3648 fail:
3649 {
3650 if (temp2)
3651 delete arg2;
3652 }
3653 return NULL;
3654 }
3655
3656
3657 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3658 PyObject *resultobj;
3659 int arg1 ;
3660 bool arg2 = (bool) true ;
3661 wxString arg3 = (wxString) wxPyEmptyString ;
3662 wxString result;
3663 PyObject * obj0 = 0 ;
3664 PyObject * obj1 = 0 ;
3665 PyObject * obj2 = 0 ;
3666 char *kwnames[] = {
3667 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3668 };
3669
3670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3671 {
3672 arg1 = (int)(SWIG_As_int(obj0));
3673 if (SWIG_arg_fail(1)) SWIG_fail;
3674 }
3675 if (obj1) {
3676 {
3677 arg2 = (bool)(SWIG_As_bool(obj1));
3678 if (SWIG_arg_fail(2)) SWIG_fail;
3679 }
3680 }
3681 if (obj2) {
3682 {
3683 wxString* sptr = wxString_in_helper(obj2);
3684 if (sptr == NULL) SWIG_fail;
3685 arg3 = *sptr;
3686 delete sptr;
3687 }
3688 }
3689 {
3690 PyThreadState* __tstate = wxPyBeginAllowThreads();
3691 result = wxGetStockLabel(arg1,arg2,arg3);
3692
3693 wxPyEndAllowThreads(__tstate);
3694 if (PyErr_Occurred()) SWIG_fail;
3695 }
3696 {
3697 #if wxUSE_UNICODE
3698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3699 #else
3700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3701 #endif
3702 }
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 char *kwnames[] = {
3712 NULL
3713 };
3714
3715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3716 {
3717 if (!wxPyCheckForApp()) SWIG_fail;
3718 PyThreadState* __tstate = wxPyBeginAllowThreads();
3719 wxBell();
3720
3721 wxPyEndAllowThreads(__tstate);
3722 if (PyErr_Occurred()) SWIG_fail;
3723 }
3724 Py_INCREF(Py_None); resultobj = Py_None;
3725 return resultobj;
3726 fail:
3727 return NULL;
3728 }
3729
3730
3731 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3732 PyObject *resultobj;
3733 char *kwnames[] = {
3734 NULL
3735 };
3736
3737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3738 {
3739 if (!wxPyCheckForApp()) SWIG_fail;
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 wxEndBusyCursor();
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 Py_INCREF(Py_None); resultobj = Py_None;
3747 return resultobj;
3748 fail:
3749 return NULL;
3750 }
3751
3752
3753 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3754 PyObject *resultobj;
3755 bool arg1 = (bool) true ;
3756 long result;
3757 PyObject * obj0 = 0 ;
3758 char *kwnames[] = {
3759 (char *) "resetTimer", NULL
3760 };
3761
3762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3763 if (obj0) {
3764 {
3765 arg1 = (bool)(SWIG_As_bool(obj0));
3766 if (SWIG_arg_fail(1)) SWIG_fail;
3767 }
3768 }
3769 {
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 result = (long)wxGetElapsedTime(arg1);
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 {
3777 resultobj = SWIG_From_long((long)(result));
3778 }
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj;
3787 int *arg1 = (int *) 0 ;
3788 int *arg2 = (int *) 0 ;
3789 int temp1 ;
3790 int res1 = 0 ;
3791 int temp2 ;
3792 int res2 = 0 ;
3793 char *kwnames[] = {
3794 NULL
3795 };
3796
3797 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3798 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3800 {
3801 if (!wxPyCheckForApp()) SWIG_fail;
3802 PyThreadState* __tstate = wxPyBeginAllowThreads();
3803 wxGetMousePosition(arg1,arg2);
3804
3805 wxPyEndAllowThreads(__tstate);
3806 if (PyErr_Occurred()) SWIG_fail;
3807 }
3808 Py_INCREF(Py_None); resultobj = Py_None;
3809 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3810 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3811 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3812 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3813 return resultobj;
3814 fail:
3815 return NULL;
3816 }
3817
3818
3819 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3820 PyObject *resultobj;
3821 bool result;
3822 char *kwnames[] = {
3823 NULL
3824 };
3825
3826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 result = (bool)wxIsBusy();
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 {
3835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3836 }
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 wxString result;
3846 char *kwnames[] = {
3847 NULL
3848 };
3849
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3851 {
3852 PyThreadState* __tstate = wxPyBeginAllowThreads();
3853 result = wxNow();
3854
3855 wxPyEndAllowThreads(__tstate);
3856 if (PyErr_Occurred()) SWIG_fail;
3857 }
3858 {
3859 #if wxUSE_UNICODE
3860 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3861 #else
3862 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3863 #endif
3864 }
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxString const &arg1_defvalue = wxPyEmptyString ;
3874 wxString *arg1 = (wxString *) &arg1_defvalue ;
3875 bool result;
3876 bool temp1 = false ;
3877 PyObject * obj0 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "command", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3883 if (obj0) {
3884 {
3885 arg1 = wxString_in_helper(obj0);
3886 if (arg1 == NULL) SWIG_fail;
3887 temp1 = true;
3888 }
3889 }
3890 {
3891 PyThreadState* __tstate = wxPyBeginAllowThreads();
3892 result = (bool)wxShell((wxString const &)*arg1);
3893
3894 wxPyEndAllowThreads(__tstate);
3895 if (PyErr_Occurred()) SWIG_fail;
3896 }
3897 {
3898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3899 }
3900 {
3901 if (temp1)
3902 delete arg1;
3903 }
3904 return resultobj;
3905 fail:
3906 {
3907 if (temp1)
3908 delete arg1;
3909 }
3910 return NULL;
3911 }
3912
3913
3914 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3915 PyObject *resultobj;
3916 char *kwnames[] = {
3917 NULL
3918 };
3919
3920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3921 {
3922 PyThreadState* __tstate = wxPyBeginAllowThreads();
3923 wxStartTimer();
3924
3925 wxPyEndAllowThreads(__tstate);
3926 if (PyErr_Occurred()) SWIG_fail;
3927 }
3928 Py_INCREF(Py_None); resultobj = Py_None;
3929 return resultobj;
3930 fail:
3931 return NULL;
3932 }
3933
3934
3935 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj;
3937 int *arg1 = (int *) 0 ;
3938 int *arg2 = (int *) 0 ;
3939 int result;
3940 int temp1 ;
3941 int res1 = 0 ;
3942 int temp2 ;
3943 int res2 = 0 ;
3944 char *kwnames[] = {
3945 NULL
3946 };
3947
3948 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3949 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3951 {
3952 PyThreadState* __tstate = wxPyBeginAllowThreads();
3953 result = (int)wxGetOsVersion(arg1,arg2);
3954
3955 wxPyEndAllowThreads(__tstate);
3956 if (PyErr_Occurred()) SWIG_fail;
3957 }
3958 {
3959 resultobj = SWIG_From_int((int)(result));
3960 }
3961 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3962 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3963 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3964 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3965 return resultobj;
3966 fail:
3967 return NULL;
3968 }
3969
3970
3971 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3972 PyObject *resultobj;
3973 wxString result;
3974 char *kwnames[] = {
3975 NULL
3976 };
3977
3978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3979 {
3980 PyThreadState* __tstate = wxPyBeginAllowThreads();
3981 result = wxGetOsDescription();
3982
3983 wxPyEndAllowThreads(__tstate);
3984 if (PyErr_Occurred()) SWIG_fail;
3985 }
3986 {
3987 #if wxUSE_UNICODE
3988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3989 #else
3990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3991 #endif
3992 }
3993 return resultobj;
3994 fail:
3995 return NULL;
3996 }
3997
3998
3999 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4000 PyObject *resultobj;
4001 long result;
4002 char *kwnames[] = {
4003 NULL
4004 };
4005
4006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4007 {
4008 PyThreadState* __tstate = wxPyBeginAllowThreads();
4009 result = (long)wxGetFreeMemory();
4010
4011 wxPyEndAllowThreads(__tstate);
4012 if (PyErr_Occurred()) SWIG_fail;
4013 }
4014 {
4015 resultobj = SWIG_From_long((long)(result));
4016 }
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
4023 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4024 PyObject *resultobj;
4025 wxShutdownFlags arg1 ;
4026 bool result;
4027 PyObject * obj0 = 0 ;
4028 char *kwnames[] = {
4029 (char *) "wFlags", NULL
4030 };
4031
4032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4033 {
4034 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4035 if (SWIG_arg_fail(1)) SWIG_fail;
4036 }
4037 {
4038 if (!wxPyCheckForApp()) SWIG_fail;
4039 PyThreadState* __tstate = wxPyBeginAllowThreads();
4040 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4041
4042 wxPyEndAllowThreads(__tstate);
4043 if (PyErr_Occurred()) SWIG_fail;
4044 }
4045 {
4046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4047 }
4048 return resultobj;
4049 fail:
4050 return NULL;
4051 }
4052
4053
4054 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4055 PyObject *resultobj;
4056 int arg1 ;
4057 PyObject * obj0 = 0 ;
4058 char *kwnames[] = {
4059 (char *) "secs", NULL
4060 };
4061
4062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4063 {
4064 arg1 = (int)(SWIG_As_int(obj0));
4065 if (SWIG_arg_fail(1)) SWIG_fail;
4066 }
4067 {
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 wxSleep(arg1);
4070
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 Py_INCREF(Py_None); resultobj = Py_None;
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj;
4083 unsigned long arg1 ;
4084 PyObject * obj0 = 0 ;
4085 char *kwnames[] = {
4086 (char *) "milliseconds", NULL
4087 };
4088
4089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4090 {
4091 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4092 if (SWIG_arg_fail(1)) SWIG_fail;
4093 }
4094 {
4095 PyThreadState* __tstate = wxPyBeginAllowThreads();
4096 wxMilliSleep(arg1);
4097
4098 wxPyEndAllowThreads(__tstate);
4099 if (PyErr_Occurred()) SWIG_fail;
4100 }
4101 Py_INCREF(Py_None); resultobj = Py_None;
4102 return resultobj;
4103 fail:
4104 return NULL;
4105 }
4106
4107
4108 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj;
4110 unsigned long arg1 ;
4111 PyObject * obj0 = 0 ;
4112 char *kwnames[] = {
4113 (char *) "microseconds", NULL
4114 };
4115
4116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4117 {
4118 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4119 if (SWIG_arg_fail(1)) SWIG_fail;
4120 }
4121 {
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 wxMicroSleep(arg1);
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 Py_INCREF(Py_None); resultobj = Py_None;
4129 return resultobj;
4130 fail:
4131 return NULL;
4132 }
4133
4134
4135 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4136 PyObject *resultobj;
4137 bool arg1 ;
4138 PyObject * obj0 = 0 ;
4139 char *kwnames[] = {
4140 (char *) "enable", NULL
4141 };
4142
4143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4144 {
4145 arg1 = (bool)(SWIG_As_bool(obj0));
4146 if (SWIG_arg_fail(1)) SWIG_fail;
4147 }
4148 {
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 wxEnableTopLevelWindows(arg1);
4151
4152 wxPyEndAllowThreads(__tstate);
4153 if (PyErr_Occurred()) SWIG_fail;
4154 }
4155 Py_INCREF(Py_None); resultobj = Py_None;
4156 return resultobj;
4157 fail:
4158 return NULL;
4159 }
4160
4161
4162 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4163 PyObject *resultobj;
4164 wxString *arg1 = 0 ;
4165 wxString result;
4166 bool temp1 = false ;
4167 PyObject * obj0 = 0 ;
4168 char *kwnames[] = {
4169 (char *) "in", NULL
4170 };
4171
4172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4173 {
4174 arg1 = wxString_in_helper(obj0);
4175 if (arg1 == NULL) SWIG_fail;
4176 temp1 = true;
4177 }
4178 {
4179 PyThreadState* __tstate = wxPyBeginAllowThreads();
4180 result = wxStripMenuCodes((wxString const &)*arg1);
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 {
4193 if (temp1)
4194 delete arg1;
4195 }
4196 return resultobj;
4197 fail:
4198 {
4199 if (temp1)
4200 delete arg1;
4201 }
4202 return NULL;
4203 }
4204
4205
4206 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4207 PyObject *resultobj;
4208 wxString result;
4209 char *kwnames[] = {
4210 NULL
4211 };
4212
4213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4214 {
4215 PyThreadState* __tstate = wxPyBeginAllowThreads();
4216 result = wxGetEmailAddress();
4217
4218 wxPyEndAllowThreads(__tstate);
4219 if (PyErr_Occurred()) SWIG_fail;
4220 }
4221 {
4222 #if wxUSE_UNICODE
4223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4224 #else
4225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4226 #endif
4227 }
4228 return resultobj;
4229 fail:
4230 return NULL;
4231 }
4232
4233
4234 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4235 PyObject *resultobj;
4236 wxString result;
4237 char *kwnames[] = {
4238 NULL
4239 };
4240
4241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4242 {
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = wxGetHostName();
4245
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 {
4250 #if wxUSE_UNICODE
4251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4252 #else
4253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4254 #endif
4255 }
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj;
4264 wxString result;
4265 char *kwnames[] = {
4266 NULL
4267 };
4268
4269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4270 {
4271 PyThreadState* __tstate = wxPyBeginAllowThreads();
4272 result = wxGetFullHostName();
4273
4274 wxPyEndAllowThreads(__tstate);
4275 if (PyErr_Occurred()) SWIG_fail;
4276 }
4277 {
4278 #if wxUSE_UNICODE
4279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4280 #else
4281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4282 #endif
4283 }
4284 return resultobj;
4285 fail:
4286 return NULL;
4287 }
4288
4289
4290 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4291 PyObject *resultobj;
4292 wxString result;
4293 char *kwnames[] = {
4294 NULL
4295 };
4296
4297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4298 {
4299 PyThreadState* __tstate = wxPyBeginAllowThreads();
4300 result = wxGetUserId();
4301
4302 wxPyEndAllowThreads(__tstate);
4303 if (PyErr_Occurred()) SWIG_fail;
4304 }
4305 {
4306 #if wxUSE_UNICODE
4307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4308 #else
4309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4310 #endif
4311 }
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj;
4320 wxString result;
4321 char *kwnames[] = {
4322 NULL
4323 };
4324
4325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4326 {
4327 PyThreadState* __tstate = wxPyBeginAllowThreads();
4328 result = wxGetUserName();
4329
4330 wxPyEndAllowThreads(__tstate);
4331 if (PyErr_Occurred()) SWIG_fail;
4332 }
4333 {
4334 #if wxUSE_UNICODE
4335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4336 #else
4337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4338 #endif
4339 }
4340 return resultobj;
4341 fail:
4342 return NULL;
4343 }
4344
4345
4346 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4347 PyObject *resultobj;
4348 wxString result;
4349 char *kwnames[] = {
4350 NULL
4351 };
4352
4353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4354 {
4355 PyThreadState* __tstate = wxPyBeginAllowThreads();
4356 result = wxGetHomeDir();
4357
4358 wxPyEndAllowThreads(__tstate);
4359 if (PyErr_Occurred()) SWIG_fail;
4360 }
4361 {
4362 #if wxUSE_UNICODE
4363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4364 #else
4365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4366 #endif
4367 }
4368 return resultobj;
4369 fail:
4370 return NULL;
4371 }
4372
4373
4374 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4375 PyObject *resultobj;
4376 wxString const &arg1_defvalue = wxPyEmptyString ;
4377 wxString *arg1 = (wxString *) &arg1_defvalue ;
4378 wxString result;
4379 bool temp1 = false ;
4380 PyObject * obj0 = 0 ;
4381 char *kwnames[] = {
4382 (char *) "user", NULL
4383 };
4384
4385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4386 if (obj0) {
4387 {
4388 arg1 = wxString_in_helper(obj0);
4389 if (arg1 == NULL) SWIG_fail;
4390 temp1 = true;
4391 }
4392 }
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 result = wxGetUserHome((wxString const &)*arg1);
4396
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 {
4401 #if wxUSE_UNICODE
4402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4403 #else
4404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4405 #endif
4406 }
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 return resultobj;
4412 fail:
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return NULL;
4418 }
4419
4420
4421 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj;
4423 unsigned long result;
4424 char *kwnames[] = {
4425 NULL
4426 };
4427
4428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = (unsigned long)wxGetProcessId();
4432
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 {
4437 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4438 }
4439 return resultobj;
4440 fail:
4441 return NULL;
4442 }
4443
4444
4445 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4446 PyObject *resultobj;
4447 char *kwnames[] = {
4448 NULL
4449 };
4450
4451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4452 {
4453 PyThreadState* __tstate = wxPyBeginAllowThreads();
4454 wxTrap();
4455
4456 wxPyEndAllowThreads(__tstate);
4457 if (PyErr_Occurred()) SWIG_fail;
4458 }
4459 Py_INCREF(Py_None); resultobj = Py_None;
4460 return resultobj;
4461 fail:
4462 return NULL;
4463 }
4464
4465
4466 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4467 PyObject *resultobj;
4468 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4469 wxString *arg1 = (wxString *) &arg1_defvalue ;
4470 wxString const &arg2_defvalue = wxPyEmptyString ;
4471 wxString *arg2 = (wxString *) &arg2_defvalue ;
4472 wxString const &arg3_defvalue = wxPyEmptyString ;
4473 wxString *arg3 = (wxString *) &arg3_defvalue ;
4474 wxString const &arg4_defvalue = wxPyEmptyString ;
4475 wxString *arg4 = (wxString *) &arg4_defvalue ;
4476 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4477 wxString *arg5 = (wxString *) &arg5_defvalue ;
4478 int arg6 = (int) 0 ;
4479 wxWindow *arg7 = (wxWindow *) NULL ;
4480 int arg8 = (int) -1 ;
4481 int arg9 = (int) -1 ;
4482 wxString result;
4483 bool temp1 = false ;
4484 bool temp2 = false ;
4485 bool temp3 = false ;
4486 bool temp4 = false ;
4487 bool temp5 = false ;
4488 PyObject * obj0 = 0 ;
4489 PyObject * obj1 = 0 ;
4490 PyObject * obj2 = 0 ;
4491 PyObject * obj3 = 0 ;
4492 PyObject * obj4 = 0 ;
4493 PyObject * obj5 = 0 ;
4494 PyObject * obj6 = 0 ;
4495 PyObject * obj7 = 0 ;
4496 PyObject * obj8 = 0 ;
4497 char *kwnames[] = {
4498 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4502 if (obj0) {
4503 {
4504 arg1 = wxString_in_helper(obj0);
4505 if (arg1 == NULL) SWIG_fail;
4506 temp1 = true;
4507 }
4508 }
4509 if (obj1) {
4510 {
4511 arg2 = wxString_in_helper(obj1);
4512 if (arg2 == NULL) SWIG_fail;
4513 temp2 = true;
4514 }
4515 }
4516 if (obj2) {
4517 {
4518 arg3 = wxString_in_helper(obj2);
4519 if (arg3 == NULL) SWIG_fail;
4520 temp3 = true;
4521 }
4522 }
4523 if (obj3) {
4524 {
4525 arg4 = wxString_in_helper(obj3);
4526 if (arg4 == NULL) SWIG_fail;
4527 temp4 = true;
4528 }
4529 }
4530 if (obj4) {
4531 {
4532 arg5 = wxString_in_helper(obj4);
4533 if (arg5 == NULL) SWIG_fail;
4534 temp5 = true;
4535 }
4536 }
4537 if (obj5) {
4538 {
4539 arg6 = (int)(SWIG_As_int(obj5));
4540 if (SWIG_arg_fail(6)) SWIG_fail;
4541 }
4542 }
4543 if (obj6) {
4544 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4545 if (SWIG_arg_fail(7)) SWIG_fail;
4546 }
4547 if (obj7) {
4548 {
4549 arg8 = (int)(SWIG_As_int(obj7));
4550 if (SWIG_arg_fail(8)) SWIG_fail;
4551 }
4552 }
4553 if (obj8) {
4554 {
4555 arg9 = (int)(SWIG_As_int(obj8));
4556 if (SWIG_arg_fail(9)) SWIG_fail;
4557 }
4558 }
4559 {
4560 if (!wxPyCheckForApp()) SWIG_fail;
4561 PyThreadState* __tstate = wxPyBeginAllowThreads();
4562 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4563
4564 wxPyEndAllowThreads(__tstate);
4565 if (PyErr_Occurred()) SWIG_fail;
4566 }
4567 {
4568 #if wxUSE_UNICODE
4569 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4570 #else
4571 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4572 #endif
4573 }
4574 {
4575 if (temp1)
4576 delete arg1;
4577 }
4578 {
4579 if (temp2)
4580 delete arg2;
4581 }
4582 {
4583 if (temp3)
4584 delete arg3;
4585 }
4586 {
4587 if (temp4)
4588 delete arg4;
4589 }
4590 {
4591 if (temp5)
4592 delete arg5;
4593 }
4594 return resultobj;
4595 fail:
4596 {
4597 if (temp1)
4598 delete arg1;
4599 }
4600 {
4601 if (temp2)
4602 delete arg2;
4603 }
4604 {
4605 if (temp3)
4606 delete arg3;
4607 }
4608 {
4609 if (temp4)
4610 delete arg4;
4611 }
4612 {
4613 if (temp5)
4614 delete arg5;
4615 }
4616 return NULL;
4617 }
4618
4619
4620 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4621 PyObject *resultobj;
4622 wxString *arg1 = 0 ;
4623 wxString *arg2 = 0 ;
4624 wxString const &arg3_defvalue = wxPyEmptyString ;
4625 wxString *arg3 = (wxString *) &arg3_defvalue ;
4626 wxWindow *arg4 = (wxWindow *) NULL ;
4627 wxString result;
4628 bool temp1 = false ;
4629 bool temp2 = false ;
4630 bool temp3 = false ;
4631 PyObject * obj0 = 0 ;
4632 PyObject * obj1 = 0 ;
4633 PyObject * obj2 = 0 ;
4634 PyObject * obj3 = 0 ;
4635 char *kwnames[] = {
4636 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4637 };
4638
4639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4640 {
4641 arg1 = wxString_in_helper(obj0);
4642 if (arg1 == NULL) SWIG_fail;
4643 temp1 = true;
4644 }
4645 {
4646 arg2 = wxString_in_helper(obj1);
4647 if (arg2 == NULL) SWIG_fail;
4648 temp2 = true;
4649 }
4650 if (obj2) {
4651 {
4652 arg3 = wxString_in_helper(obj2);
4653 if (arg3 == NULL) SWIG_fail;
4654 temp3 = true;
4655 }
4656 }
4657 if (obj3) {
4658 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4659 if (SWIG_arg_fail(4)) SWIG_fail;
4660 }
4661 {
4662 if (!wxPyCheckForApp()) SWIG_fail;
4663 PyThreadState* __tstate = wxPyBeginAllowThreads();
4664 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4665
4666 wxPyEndAllowThreads(__tstate);
4667 if (PyErr_Occurred()) SWIG_fail;
4668 }
4669 {
4670 #if wxUSE_UNICODE
4671 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4672 #else
4673 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4674 #endif
4675 }
4676 {
4677 if (temp1)
4678 delete arg1;
4679 }
4680 {
4681 if (temp2)
4682 delete arg2;
4683 }
4684 {
4685 if (temp3)
4686 delete arg3;
4687 }
4688 return resultobj;
4689 fail:
4690 {
4691 if (temp1)
4692 delete arg1;
4693 }
4694 {
4695 if (temp2)
4696 delete arg2;
4697 }
4698 {
4699 if (temp3)
4700 delete arg3;
4701 }
4702 return NULL;
4703 }
4704
4705
4706 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4707 PyObject *resultobj;
4708 wxString *arg1 = 0 ;
4709 wxString *arg2 = 0 ;
4710 wxString const &arg3_defvalue = wxPyEmptyString ;
4711 wxString *arg3 = (wxString *) &arg3_defvalue ;
4712 wxWindow *arg4 = (wxWindow *) NULL ;
4713 wxString result;
4714 bool temp1 = false ;
4715 bool temp2 = false ;
4716 bool temp3 = false ;
4717 PyObject * obj0 = 0 ;
4718 PyObject * obj1 = 0 ;
4719 PyObject * obj2 = 0 ;
4720 PyObject * obj3 = 0 ;
4721 char *kwnames[] = {
4722 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4723 };
4724
4725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4726 {
4727 arg1 = wxString_in_helper(obj0);
4728 if (arg1 == NULL) SWIG_fail;
4729 temp1 = true;
4730 }
4731 {
4732 arg2 = wxString_in_helper(obj1);
4733 if (arg2 == NULL) SWIG_fail;
4734 temp2 = true;
4735 }
4736 if (obj2) {
4737 {
4738 arg3 = wxString_in_helper(obj2);
4739 if (arg3 == NULL) SWIG_fail;
4740 temp3 = true;
4741 }
4742 }
4743 if (obj3) {
4744 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4745 if (SWIG_arg_fail(4)) SWIG_fail;
4746 }
4747 {
4748 if (!wxPyCheckForApp()) SWIG_fail;
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4751
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 {
4756 #if wxUSE_UNICODE
4757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4758 #else
4759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4760 #endif
4761 }
4762 {
4763 if (temp1)
4764 delete arg1;
4765 }
4766 {
4767 if (temp2)
4768 delete arg2;
4769 }
4770 {
4771 if (temp3)
4772 delete arg3;
4773 }
4774 return resultobj;
4775 fail:
4776 {
4777 if (temp1)
4778 delete arg1;
4779 }
4780 {
4781 if (temp2)
4782 delete arg2;
4783 }
4784 {
4785 if (temp3)
4786 delete arg3;
4787 }
4788 return NULL;
4789 }
4790
4791
4792 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj;
4794 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4795 wxString *arg1 = (wxString *) &arg1_defvalue ;
4796 wxString const &arg2_defvalue = wxPyEmptyString ;
4797 wxString *arg2 = (wxString *) &arg2_defvalue ;
4798 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4799 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4800 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4801 wxWindow *arg5 = (wxWindow *) NULL ;
4802 wxString result;
4803 bool temp1 = false ;
4804 bool temp2 = false ;
4805 wxPoint temp4 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 PyObject * obj2 = 0 ;
4809 PyObject * obj3 = 0 ;
4810 PyObject * obj4 = 0 ;
4811 char *kwnames[] = {
4812 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4813 };
4814
4815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4816 if (obj0) {
4817 {
4818 arg1 = wxString_in_helper(obj0);
4819 if (arg1 == NULL) SWIG_fail;
4820 temp1 = true;
4821 }
4822 }
4823 if (obj1) {
4824 {
4825 arg2 = wxString_in_helper(obj1);
4826 if (arg2 == NULL) SWIG_fail;
4827 temp2 = true;
4828 }
4829 }
4830 if (obj2) {
4831 {
4832 arg3 = (long)(SWIG_As_long(obj2));
4833 if (SWIG_arg_fail(3)) SWIG_fail;
4834 }
4835 }
4836 if (obj3) {
4837 {
4838 arg4 = &temp4;
4839 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4840 }
4841 }
4842 if (obj4) {
4843 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4844 if (SWIG_arg_fail(5)) SWIG_fail;
4845 }
4846 {
4847 if (!wxPyCheckForApp()) SWIG_fail;
4848 PyThreadState* __tstate = wxPyBeginAllowThreads();
4849 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4850
4851 wxPyEndAllowThreads(__tstate);
4852 if (PyErr_Occurred()) SWIG_fail;
4853 }
4854 {
4855 #if wxUSE_UNICODE
4856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4857 #else
4858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4859 #endif
4860 }
4861 {
4862 if (temp1)
4863 delete arg1;
4864 }
4865 {
4866 if (temp2)
4867 delete arg2;
4868 }
4869 return resultobj;
4870 fail:
4871 {
4872 if (temp1)
4873 delete arg1;
4874 }
4875 {
4876 if (temp2)
4877 delete arg2;
4878 }
4879 return NULL;
4880 }
4881
4882
4883 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj;
4885 wxString *arg1 = 0 ;
4886 wxString const &arg2_defvalue = wxPyEmptyString ;
4887 wxString *arg2 = (wxString *) &arg2_defvalue ;
4888 wxString const &arg3_defvalue = wxPyEmptyString ;
4889 wxString *arg3 = (wxString *) &arg3_defvalue ;
4890 wxWindow *arg4 = (wxWindow *) NULL ;
4891 int arg5 = (int) -1 ;
4892 int arg6 = (int) -1 ;
4893 bool arg7 = (bool) true ;
4894 wxString result;
4895 bool temp1 = false ;
4896 bool temp2 = false ;
4897 bool temp3 = false ;
4898 PyObject * obj0 = 0 ;
4899 PyObject * obj1 = 0 ;
4900 PyObject * obj2 = 0 ;
4901 PyObject * obj3 = 0 ;
4902 PyObject * obj4 = 0 ;
4903 PyObject * obj5 = 0 ;
4904 PyObject * obj6 = 0 ;
4905 char *kwnames[] = {
4906 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4907 };
4908
4909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4910 {
4911 arg1 = wxString_in_helper(obj0);
4912 if (arg1 == NULL) SWIG_fail;
4913 temp1 = true;
4914 }
4915 if (obj1) {
4916 {
4917 arg2 = wxString_in_helper(obj1);
4918 if (arg2 == NULL) SWIG_fail;
4919 temp2 = true;
4920 }
4921 }
4922 if (obj2) {
4923 {
4924 arg3 = wxString_in_helper(obj2);
4925 if (arg3 == NULL) SWIG_fail;
4926 temp3 = true;
4927 }
4928 }
4929 if (obj3) {
4930 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4931 if (SWIG_arg_fail(4)) SWIG_fail;
4932 }
4933 if (obj4) {
4934 {
4935 arg5 = (int)(SWIG_As_int(obj4));
4936 if (SWIG_arg_fail(5)) SWIG_fail;
4937 }
4938 }
4939 if (obj5) {
4940 {
4941 arg6 = (int)(SWIG_As_int(obj5));
4942 if (SWIG_arg_fail(6)) SWIG_fail;
4943 }
4944 }
4945 if (obj6) {
4946 {
4947 arg7 = (bool)(SWIG_As_bool(obj6));
4948 if (SWIG_arg_fail(7)) SWIG_fail;
4949 }
4950 }
4951 {
4952 if (!wxPyCheckForApp()) SWIG_fail;
4953 PyThreadState* __tstate = wxPyBeginAllowThreads();
4954 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4955
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 {
4960 #if wxUSE_UNICODE
4961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4962 #else
4963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4964 #endif
4965 }
4966 {
4967 if (temp1)
4968 delete arg1;
4969 }
4970 {
4971 if (temp2)
4972 delete arg2;
4973 }
4974 {
4975 if (temp3)
4976 delete arg3;
4977 }
4978 return resultobj;
4979 fail:
4980 {
4981 if (temp1)
4982 delete arg1;
4983 }
4984 {
4985 if (temp2)
4986 delete arg2;
4987 }
4988 {
4989 if (temp3)
4990 delete arg3;
4991 }
4992 return NULL;
4993 }
4994
4995
4996 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4997 PyObject *resultobj;
4998 wxString *arg1 = 0 ;
4999 wxString const &arg2_defvalue = wxPyEmptyString ;
5000 wxString *arg2 = (wxString *) &arg2_defvalue ;
5001 wxString const &arg3_defvalue = wxPyEmptyString ;
5002 wxString *arg3 = (wxString *) &arg3_defvalue ;
5003 wxWindow *arg4 = (wxWindow *) NULL ;
5004 wxString result;
5005 bool temp1 = false ;
5006 bool temp2 = false ;
5007 bool temp3 = false ;
5008 PyObject * obj0 = 0 ;
5009 PyObject * obj1 = 0 ;
5010 PyObject * obj2 = 0 ;
5011 PyObject * obj3 = 0 ;
5012 char *kwnames[] = {
5013 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5014 };
5015
5016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5017 {
5018 arg1 = wxString_in_helper(obj0);
5019 if (arg1 == NULL) SWIG_fail;
5020 temp1 = true;
5021 }
5022 if (obj1) {
5023 {
5024 arg2 = wxString_in_helper(obj1);
5025 if (arg2 == NULL) SWIG_fail;
5026 temp2 = true;
5027 }
5028 }
5029 if (obj2) {
5030 {
5031 arg3 = wxString_in_helper(obj2);
5032 if (arg3 == NULL) SWIG_fail;
5033 temp3 = true;
5034 }
5035 }
5036 if (obj3) {
5037 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5038 if (SWIG_arg_fail(4)) SWIG_fail;
5039 }
5040 {
5041 if (!wxPyCheckForApp()) SWIG_fail;
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5044
5045 wxPyEndAllowThreads(__tstate);
5046 if (PyErr_Occurred()) SWIG_fail;
5047 }
5048 {
5049 #if wxUSE_UNICODE
5050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5051 #else
5052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5053 #endif
5054 }
5055 {
5056 if (temp1)
5057 delete arg1;
5058 }
5059 {
5060 if (temp2)
5061 delete arg2;
5062 }
5063 {
5064 if (temp3)
5065 delete arg3;
5066 }
5067 return resultobj;
5068 fail:
5069 {
5070 if (temp1)
5071 delete arg1;
5072 }
5073 {
5074 if (temp2)
5075 delete arg2;
5076 }
5077 {
5078 if (temp3)
5079 delete arg3;
5080 }
5081 return NULL;
5082 }
5083
5084
5085 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5086 PyObject *resultobj;
5087 wxString *arg1 = 0 ;
5088 wxString *arg2 = 0 ;
5089 int arg3 ;
5090 wxString *arg4 = (wxString *) 0 ;
5091 wxWindow *arg5 = (wxWindow *) NULL ;
5092 int arg6 = (int) -1 ;
5093 int arg7 = (int) -1 ;
5094 bool arg8 = (bool) true ;
5095 int arg9 = (int) 150 ;
5096 int arg10 = (int) 200 ;
5097 wxString result;
5098 bool temp1 = false ;
5099 bool temp2 = false ;
5100 PyObject * obj0 = 0 ;
5101 PyObject * obj1 = 0 ;
5102 PyObject * obj2 = 0 ;
5103 PyObject * obj3 = 0 ;
5104 PyObject * obj4 = 0 ;
5105 PyObject * obj5 = 0 ;
5106 PyObject * obj6 = 0 ;
5107 PyObject * obj7 = 0 ;
5108 PyObject * obj8 = 0 ;
5109 char *kwnames[] = {
5110 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5111 };
5112
5113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5114 {
5115 arg1 = wxString_in_helper(obj0);
5116 if (arg1 == NULL) SWIG_fail;
5117 temp1 = true;
5118 }
5119 {
5120 arg2 = wxString_in_helper(obj1);
5121 if (arg2 == NULL) SWIG_fail;
5122 temp2 = true;
5123 }
5124 {
5125 arg3 = PyList_Size(obj2);
5126 arg4 = wxString_LIST_helper(obj2);
5127 if (arg4 == NULL) SWIG_fail;
5128 }
5129 if (obj3) {
5130 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5131 if (SWIG_arg_fail(5)) SWIG_fail;
5132 }
5133 if (obj4) {
5134 {
5135 arg6 = (int)(SWIG_As_int(obj4));
5136 if (SWIG_arg_fail(6)) SWIG_fail;
5137 }
5138 }
5139 if (obj5) {
5140 {
5141 arg7 = (int)(SWIG_As_int(obj5));
5142 if (SWIG_arg_fail(7)) SWIG_fail;
5143 }
5144 }
5145 if (obj6) {
5146 {
5147 arg8 = (bool)(SWIG_As_bool(obj6));
5148 if (SWIG_arg_fail(8)) SWIG_fail;
5149 }
5150 }
5151 if (obj7) {
5152 {
5153 arg9 = (int)(SWIG_As_int(obj7));
5154 if (SWIG_arg_fail(9)) SWIG_fail;
5155 }
5156 }
5157 if (obj8) {
5158 {
5159 arg10 = (int)(SWIG_As_int(obj8));
5160 if (SWIG_arg_fail(10)) SWIG_fail;
5161 }
5162 }
5163 {
5164 if (!wxPyCheckForApp()) SWIG_fail;
5165 PyThreadState* __tstate = wxPyBeginAllowThreads();
5166 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5167
5168 wxPyEndAllowThreads(__tstate);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 {
5172 #if wxUSE_UNICODE
5173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5174 #else
5175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5176 #endif
5177 }
5178 {
5179 if (temp1)
5180 delete arg1;
5181 }
5182 {
5183 if (temp2)
5184 delete arg2;
5185 }
5186 {
5187 if (arg4) delete [] arg4;
5188 }
5189 return resultobj;
5190 fail:
5191 {
5192 if (temp1)
5193 delete arg1;
5194 }
5195 {
5196 if (temp2)
5197 delete arg2;
5198 }
5199 {
5200 if (arg4) delete [] arg4;
5201 }
5202 return NULL;
5203 }
5204
5205
5206 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj;
5208 wxString *arg1 = 0 ;
5209 wxString *arg2 = 0 ;
5210 int arg3 ;
5211 wxString *arg4 = (wxString *) 0 ;
5212 wxWindow *arg5 = (wxWindow *) NULL ;
5213 int arg6 = (int) -1 ;
5214 int arg7 = (int) -1 ;
5215 bool arg8 = (bool) true ;
5216 int arg9 = (int) 150 ;
5217 int arg10 = (int) 200 ;
5218 int result;
5219 bool temp1 = false ;
5220 bool temp2 = false ;
5221 PyObject * obj0 = 0 ;
5222 PyObject * obj1 = 0 ;
5223 PyObject * obj2 = 0 ;
5224 PyObject * obj3 = 0 ;
5225 PyObject * obj4 = 0 ;
5226 PyObject * obj5 = 0 ;
5227 PyObject * obj6 = 0 ;
5228 PyObject * obj7 = 0 ;
5229 PyObject * obj8 = 0 ;
5230 char *kwnames[] = {
5231 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5232 };
5233
5234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5235 {
5236 arg1 = wxString_in_helper(obj0);
5237 if (arg1 == NULL) SWIG_fail;
5238 temp1 = true;
5239 }
5240 {
5241 arg2 = wxString_in_helper(obj1);
5242 if (arg2 == NULL) SWIG_fail;
5243 temp2 = true;
5244 }
5245 {
5246 arg3 = PyList_Size(obj2);
5247 arg4 = wxString_LIST_helper(obj2);
5248 if (arg4 == NULL) SWIG_fail;
5249 }
5250 if (obj3) {
5251 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5252 if (SWIG_arg_fail(5)) SWIG_fail;
5253 }
5254 if (obj4) {
5255 {
5256 arg6 = (int)(SWIG_As_int(obj4));
5257 if (SWIG_arg_fail(6)) SWIG_fail;
5258 }
5259 }
5260 if (obj5) {
5261 {
5262 arg7 = (int)(SWIG_As_int(obj5));
5263 if (SWIG_arg_fail(7)) SWIG_fail;
5264 }
5265 }
5266 if (obj6) {
5267 {
5268 arg8 = (bool)(SWIG_As_bool(obj6));
5269 if (SWIG_arg_fail(8)) SWIG_fail;
5270 }
5271 }
5272 if (obj7) {
5273 {
5274 arg9 = (int)(SWIG_As_int(obj7));
5275 if (SWIG_arg_fail(9)) SWIG_fail;
5276 }
5277 }
5278 if (obj8) {
5279 {
5280 arg10 = (int)(SWIG_As_int(obj8));
5281 if (SWIG_arg_fail(10)) SWIG_fail;
5282 }
5283 }
5284 {
5285 if (!wxPyCheckForApp()) SWIG_fail;
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5288
5289 wxPyEndAllowThreads(__tstate);
5290 if (PyErr_Occurred()) SWIG_fail;
5291 }
5292 {
5293 resultobj = SWIG_From_int((int)(result));
5294 }
5295 {
5296 if (temp1)
5297 delete arg1;
5298 }
5299 {
5300 if (temp2)
5301 delete arg2;
5302 }
5303 {
5304 if (arg4) delete [] arg4;
5305 }
5306 return resultobj;
5307 fail:
5308 {
5309 if (temp1)
5310 delete arg1;
5311 }
5312 {
5313 if (temp2)
5314 delete arg2;
5315 }
5316 {
5317 if (arg4) delete [] arg4;
5318 }
5319 return NULL;
5320 }
5321
5322
5323 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5324 PyObject *resultobj;
5325 wxString *arg1 = 0 ;
5326 wxString const &arg2_defvalue = wxPyEmptyString ;
5327 wxString *arg2 = (wxString *) &arg2_defvalue ;
5328 int arg3 = (int) wxOK|wxCENTRE ;
5329 wxWindow *arg4 = (wxWindow *) NULL ;
5330 int arg5 = (int) -1 ;
5331 int arg6 = (int) -1 ;
5332 int result;
5333 bool temp1 = false ;
5334 bool temp2 = false ;
5335 PyObject * obj0 = 0 ;
5336 PyObject * obj1 = 0 ;
5337 PyObject * obj2 = 0 ;
5338 PyObject * obj3 = 0 ;
5339 PyObject * obj4 = 0 ;
5340 PyObject * obj5 = 0 ;
5341 char *kwnames[] = {
5342 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5343 };
5344
5345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5346 {
5347 arg1 = wxString_in_helper(obj0);
5348 if (arg1 == NULL) SWIG_fail;
5349 temp1 = true;
5350 }
5351 if (obj1) {
5352 {
5353 arg2 = wxString_in_helper(obj1);
5354 if (arg2 == NULL) SWIG_fail;
5355 temp2 = true;
5356 }
5357 }
5358 if (obj2) {
5359 {
5360 arg3 = (int)(SWIG_As_int(obj2));
5361 if (SWIG_arg_fail(3)) SWIG_fail;
5362 }
5363 }
5364 if (obj3) {
5365 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5366 if (SWIG_arg_fail(4)) SWIG_fail;
5367 }
5368 if (obj4) {
5369 {
5370 arg5 = (int)(SWIG_As_int(obj4));
5371 if (SWIG_arg_fail(5)) SWIG_fail;
5372 }
5373 }
5374 if (obj5) {
5375 {
5376 arg6 = (int)(SWIG_As_int(obj5));
5377 if (SWIG_arg_fail(6)) SWIG_fail;
5378 }
5379 }
5380 {
5381 if (!wxPyCheckForApp()) SWIG_fail;
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5384
5385 wxPyEndAllowThreads(__tstate);
5386 if (PyErr_Occurred()) SWIG_fail;
5387 }
5388 {
5389 resultobj = SWIG_From_int((int)(result));
5390 }
5391 {
5392 if (temp1)
5393 delete arg1;
5394 }
5395 {
5396 if (temp2)
5397 delete arg2;
5398 }
5399 return resultobj;
5400 fail:
5401 {
5402 if (temp1)
5403 delete arg1;
5404 }
5405 {
5406 if (temp2)
5407 delete arg2;
5408 }
5409 return NULL;
5410 }
5411
5412
5413 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5414 PyObject *resultobj;
5415 wxString *arg1 = 0 ;
5416 wxString *arg2 = 0 ;
5417 wxString *arg3 = 0 ;
5418 long arg4 ;
5419 long arg5 = (long) 0 ;
5420 long arg6 = (long) 100 ;
5421 wxWindow *arg7 = (wxWindow *) NULL ;
5422 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5423 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5424 long result;
5425 bool temp1 = false ;
5426 bool temp2 = false ;
5427 bool temp3 = false ;
5428 wxPoint temp8 ;
5429 PyObject * obj0 = 0 ;
5430 PyObject * obj1 = 0 ;
5431 PyObject * obj2 = 0 ;
5432 PyObject * obj3 = 0 ;
5433 PyObject * obj4 = 0 ;
5434 PyObject * obj5 = 0 ;
5435 PyObject * obj6 = 0 ;
5436 PyObject * obj7 = 0 ;
5437 char *kwnames[] = {
5438 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5439 };
5440
5441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5442 {
5443 arg1 = wxString_in_helper(obj0);
5444 if (arg1 == NULL) SWIG_fail;
5445 temp1 = true;
5446 }
5447 {
5448 arg2 = wxString_in_helper(obj1);
5449 if (arg2 == NULL) SWIG_fail;
5450 temp2 = true;
5451 }
5452 {
5453 arg3 = wxString_in_helper(obj2);
5454 if (arg3 == NULL) SWIG_fail;
5455 temp3 = true;
5456 }
5457 {
5458 arg4 = (long)(SWIG_As_long(obj3));
5459 if (SWIG_arg_fail(4)) SWIG_fail;
5460 }
5461 if (obj4) {
5462 {
5463 arg5 = (long)(SWIG_As_long(obj4));
5464 if (SWIG_arg_fail(5)) SWIG_fail;
5465 }
5466 }
5467 if (obj5) {
5468 {
5469 arg6 = (long)(SWIG_As_long(obj5));
5470 if (SWIG_arg_fail(6)) SWIG_fail;
5471 }
5472 }
5473 if (obj6) {
5474 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5475 if (SWIG_arg_fail(7)) SWIG_fail;
5476 }
5477 if (obj7) {
5478 {
5479 arg8 = &temp8;
5480 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5481 }
5482 }
5483 {
5484 if (!wxPyCheckForApp()) SWIG_fail;
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5487
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 resultobj = SWIG_From_long((long)(result));
5493 }
5494 {
5495 if (temp1)
5496 delete arg1;
5497 }
5498 {
5499 if (temp2)
5500 delete arg2;
5501 }
5502 {
5503 if (temp3)
5504 delete arg3;
5505 }
5506 return resultobj;
5507 fail:
5508 {
5509 if (temp1)
5510 delete arg1;
5511 }
5512 {
5513 if (temp2)
5514 delete arg2;
5515 }
5516 {
5517 if (temp3)
5518 delete arg3;
5519 }
5520 return NULL;
5521 }
5522
5523
5524 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj;
5526 bool result;
5527 char *kwnames[] = {
5528 NULL
5529 };
5530
5531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5532 {
5533 if (!wxPyCheckForApp()) SWIG_fail;
5534 PyThreadState* __tstate = wxPyBeginAllowThreads();
5535 result = (bool)wxColourDisplay();
5536
5537 wxPyEndAllowThreads(__tstate);
5538 if (PyErr_Occurred()) SWIG_fail;
5539 }
5540 {
5541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5542 }
5543 return resultobj;
5544 fail:
5545 return NULL;
5546 }
5547
5548
5549 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5550 PyObject *resultobj;
5551 int result;
5552 char *kwnames[] = {
5553 NULL
5554 };
5555
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5557 {
5558 if (!wxPyCheckForApp()) SWIG_fail;
5559 PyThreadState* __tstate = wxPyBeginAllowThreads();
5560 result = (int)wxDisplayDepth();
5561
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 {
5566 resultobj = SWIG_From_int((int)(result));
5567 }
5568 return resultobj;
5569 fail:
5570 return NULL;
5571 }
5572
5573
5574 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5575 PyObject *resultobj;
5576 int result;
5577 char *kwnames[] = {
5578 NULL
5579 };
5580
5581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5582 {
5583 if (!wxPyCheckForApp()) SWIG_fail;
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 result = (int)wxGetDisplayDepth();
5586
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 {
5591 resultobj = SWIG_From_int((int)(result));
5592 }
5593 return resultobj;
5594 fail:
5595 return NULL;
5596 }
5597
5598
5599 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5600 PyObject *resultobj;
5601 int *arg1 = (int *) 0 ;
5602 int *arg2 = (int *) 0 ;
5603 int temp1 ;
5604 int res1 = 0 ;
5605 int temp2 ;
5606 int res2 = 0 ;
5607 char *kwnames[] = {
5608 NULL
5609 };
5610
5611 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5612 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5614 {
5615 if (!wxPyCheckForApp()) SWIG_fail;
5616 PyThreadState* __tstate = wxPyBeginAllowThreads();
5617 wxDisplaySize(arg1,arg2);
5618
5619 wxPyEndAllowThreads(__tstate);
5620 if (PyErr_Occurred()) SWIG_fail;
5621 }
5622 Py_INCREF(Py_None); resultobj = Py_None;
5623 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5624 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5625 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5626 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5634 PyObject *resultobj;
5635 wxSize result;
5636 char *kwnames[] = {
5637 NULL
5638 };
5639
5640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5641 {
5642 if (!wxPyCheckForApp()) SWIG_fail;
5643 PyThreadState* __tstate = wxPyBeginAllowThreads();
5644 result = wxGetDisplaySize();
5645
5646 wxPyEndAllowThreads(__tstate);
5647 if (PyErr_Occurred()) SWIG_fail;
5648 }
5649 {
5650 wxSize * resultptr;
5651 resultptr = new wxSize((wxSize &)(result));
5652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5653 }
5654 return resultobj;
5655 fail:
5656 return NULL;
5657 }
5658
5659
5660 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5661 PyObject *resultobj;
5662 int *arg1 = (int *) 0 ;
5663 int *arg2 = (int *) 0 ;
5664 int temp1 ;
5665 int res1 = 0 ;
5666 int temp2 ;
5667 int res2 = 0 ;
5668 char *kwnames[] = {
5669 NULL
5670 };
5671
5672 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5673 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5675 {
5676 if (!wxPyCheckForApp()) SWIG_fail;
5677 PyThreadState* __tstate = wxPyBeginAllowThreads();
5678 wxDisplaySizeMM(arg1,arg2);
5679
5680 wxPyEndAllowThreads(__tstate);
5681 if (PyErr_Occurred()) SWIG_fail;
5682 }
5683 Py_INCREF(Py_None); resultobj = Py_None;
5684 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5685 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5686 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5687 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj;
5696 wxSize result;
5697 char *kwnames[] = {
5698 NULL
5699 };
5700
5701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5702 {
5703 if (!wxPyCheckForApp()) SWIG_fail;
5704 PyThreadState* __tstate = wxPyBeginAllowThreads();
5705 result = wxGetDisplaySizeMM();
5706
5707 wxPyEndAllowThreads(__tstate);
5708 if (PyErr_Occurred()) SWIG_fail;
5709 }
5710 {
5711 wxSize * resultptr;
5712 resultptr = new wxSize((wxSize &)(result));
5713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5714 }
5715 return resultobj;
5716 fail:
5717 return NULL;
5718 }
5719
5720
5721 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5722 PyObject *resultobj;
5723 int *arg1 = (int *) 0 ;
5724 int *arg2 = (int *) 0 ;
5725 int *arg3 = (int *) 0 ;
5726 int *arg4 = (int *) 0 ;
5727 int temp1 ;
5728 int res1 = 0 ;
5729 int temp2 ;
5730 int res2 = 0 ;
5731 int temp3 ;
5732 int res3 = 0 ;
5733 int temp4 ;
5734 int res4 = 0 ;
5735 char *kwnames[] = {
5736 NULL
5737 };
5738
5739 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5740 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5741 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5742 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5744 {
5745 if (!wxPyCheckForApp()) SWIG_fail;
5746 PyThreadState* __tstate = wxPyBeginAllowThreads();
5747 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5748
5749 wxPyEndAllowThreads(__tstate);
5750 if (PyErr_Occurred()) SWIG_fail;
5751 }
5752 Py_INCREF(Py_None); resultobj = Py_None;
5753 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5754 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5755 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5756 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5757 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5758 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5759 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5760 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5761 return resultobj;
5762 fail:
5763 return NULL;
5764 }
5765
5766
5767 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5768 PyObject *resultobj;
5769 wxRect result;
5770 char *kwnames[] = {
5771 NULL
5772 };
5773
5774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5775 {
5776 if (!wxPyCheckForApp()) SWIG_fail;
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 result = wxGetClientDisplayRect();
5779
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 {
5784 wxRect * resultptr;
5785 resultptr = new wxRect((wxRect &)(result));
5786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5787 }
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj;
5796 wxCursor *arg1 = 0 ;
5797 PyObject * obj0 = 0 ;
5798 char *kwnames[] = {
5799 (char *) "cursor", NULL
5800 };
5801
5802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5803 {
5804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5805 if (SWIG_arg_fail(1)) SWIG_fail;
5806 if (arg1 == NULL) {
5807 SWIG_null_ref("wxCursor");
5808 }
5809 if (SWIG_arg_fail(1)) SWIG_fail;
5810 }
5811 {
5812 if (!wxPyCheckForApp()) SWIG_fail;
5813 PyThreadState* __tstate = wxPyBeginAllowThreads();
5814 wxSetCursor(*arg1);
5815
5816 wxPyEndAllowThreads(__tstate);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 Py_INCREF(Py_None); resultobj = Py_None;
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj;
5828 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5829 PyObject * obj0 = 0 ;
5830 char *kwnames[] = {
5831 (char *) "cursor", NULL
5832 };
5833
5834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5835 if (obj0) {
5836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5837 if (SWIG_arg_fail(1)) SWIG_fail;
5838 }
5839 {
5840 if (!wxPyCheckForApp()) SWIG_fail;
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 wxBeginBusyCursor(arg1);
5843
5844 wxPyEndAllowThreads(__tstate);
5845 if (PyErr_Occurred()) SWIG_fail;
5846 }
5847 Py_INCREF(Py_None); resultobj = Py_None;
5848 return resultobj;
5849 fail:
5850 return NULL;
5851 }
5852
5853
5854 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj;
5856 wxWindow *result;
5857 char *kwnames[] = {
5858 NULL
5859 };
5860
5861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5862 {
5863 if (!wxPyCheckForApp()) SWIG_fail;
5864 PyThreadState* __tstate = wxPyBeginAllowThreads();
5865 result = (wxWindow *)wxGetActiveWindow();
5866
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 {
5871 resultobj = wxPyMake_wxObject(result, 0);
5872 }
5873 return resultobj;
5874 fail:
5875 return NULL;
5876 }
5877
5878
5879 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5880 PyObject *resultobj;
5881 wxPoint *arg1 = 0 ;
5882 wxWindow *result;
5883 wxPoint temp1 ;
5884 PyObject * obj0 = 0 ;
5885 char *kwnames[] = {
5886 (char *) "pt", NULL
5887 };
5888
5889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5890 {
5891 arg1 = &temp1;
5892 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5893 }
5894 {
5895 if (!wxPyCheckForApp()) SWIG_fail;
5896 PyThreadState* __tstate = wxPyBeginAllowThreads();
5897 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5898
5899 wxPyEndAllowThreads(__tstate);
5900 if (PyErr_Occurred()) SWIG_fail;
5901 }
5902 {
5903 resultobj = wxPyMake_wxObject(result, 0);
5904 }
5905 return resultobj;
5906 fail:
5907 return NULL;
5908 }
5909
5910
5911 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5912 PyObject *resultobj;
5913 wxPoint *arg1 = 0 ;
5914 wxWindow *result;
5915 wxPoint temp1 ;
5916 PyObject * obj0 = 0 ;
5917 char *kwnames[] = {
5918 (char *) "pt", NULL
5919 };
5920
5921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5922 {
5923 arg1 = &temp1;
5924 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5925 }
5926 {
5927 if (!wxPyCheckForApp()) SWIG_fail;
5928 PyThreadState* __tstate = wxPyBeginAllowThreads();
5929 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5930
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 {
5935 resultobj = wxPyMake_wxObject(result, 0);
5936 }
5937 return resultobj;
5938 fail:
5939 return NULL;
5940 }
5941
5942
5943 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5944 PyObject *resultobj;
5945 wxWindow *arg1 = (wxWindow *) 0 ;
5946 wxWindow *result;
5947 PyObject * obj0 = 0 ;
5948 char *kwnames[] = {
5949 (char *) "win", NULL
5950 };
5951
5952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5954 if (SWIG_arg_fail(1)) SWIG_fail;
5955 {
5956 if (!wxPyCheckForApp()) SWIG_fail;
5957 PyThreadState* __tstate = wxPyBeginAllowThreads();
5958 result = (wxWindow *)wxGetTopLevelParent(arg1);
5959
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 {
5964 resultobj = wxPyMake_wxObject(result, 0);
5965 }
5966 return resultobj;
5967 fail:
5968 return NULL;
5969 }
5970
5971
5972 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5973 PyObject *resultobj;
5974 wxKeyCode arg1 ;
5975 bool result;
5976 PyObject * obj0 = 0 ;
5977 char *kwnames[] = {
5978 (char *) "key", NULL
5979 };
5980
5981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5982 {
5983 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5984 if (SWIG_arg_fail(1)) SWIG_fail;
5985 }
5986 {
5987 if (!wxPyCheckForApp()) SWIG_fail;
5988 PyThreadState* __tstate = wxPyBeginAllowThreads();
5989 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5990
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 {
5995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5996 }
5997 return resultobj;
5998 fail:
5999 return NULL;
6000 }
6001
6002
6003 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6004 PyObject *resultobj;
6005 char *kwnames[] = {
6006 NULL
6007 };
6008
6009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6010 {
6011 if (!wxPyCheckForApp()) SWIG_fail;
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 wxWakeUpMainThread();
6014
6015 wxPyEndAllowThreads(__tstate);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 Py_INCREF(Py_None); resultobj = Py_None;
6019 return resultobj;
6020 fail:
6021 return NULL;
6022 }
6023
6024
6025 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6026 PyObject *resultobj;
6027 char *kwnames[] = {
6028 NULL
6029 };
6030
6031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6032 {
6033 if (!wxPyCheckForApp()) SWIG_fail;
6034 PyThreadState* __tstate = wxPyBeginAllowThreads();
6035 wxMutexGuiEnter();
6036
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 Py_INCREF(Py_None); resultobj = Py_None;
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6048 PyObject *resultobj;
6049 char *kwnames[] = {
6050 NULL
6051 };
6052
6053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6054 {
6055 if (!wxPyCheckForApp()) SWIG_fail;
6056 PyThreadState* __tstate = wxPyBeginAllowThreads();
6057 wxMutexGuiLeave();
6058
6059 wxPyEndAllowThreads(__tstate);
6060 if (PyErr_Occurred()) SWIG_fail;
6061 }
6062 Py_INCREF(Py_None); resultobj = Py_None;
6063 return resultobj;
6064 fail:
6065 return NULL;
6066 }
6067
6068
6069 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6070 PyObject *resultobj;
6071 wxMutexGuiLocker *result;
6072 char *kwnames[] = {
6073 NULL
6074 };
6075
6076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6077 {
6078 if (!wxPyCheckForApp()) SWIG_fail;
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6086 return resultobj;
6087 fail:
6088 return NULL;
6089 }
6090
6091
6092 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj;
6094 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6095 PyObject * obj0 = 0 ;
6096 char *kwnames[] = {
6097 (char *) "self", NULL
6098 };
6099
6100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6102 if (SWIG_arg_fail(1)) SWIG_fail;
6103 {
6104 PyThreadState* __tstate = wxPyBeginAllowThreads();
6105 delete arg1;
6106
6107 wxPyEndAllowThreads(__tstate);
6108 if (PyErr_Occurred()) SWIG_fail;
6109 }
6110 Py_INCREF(Py_None); resultobj = Py_None;
6111 return resultobj;
6112 fail:
6113 return NULL;
6114 }
6115
6116
6117 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6118 PyObject *obj;
6119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6120 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6121 Py_INCREF(obj);
6122 return Py_BuildValue((char *)"");
6123 }
6124 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6125 PyObject *resultobj;
6126 bool result;
6127 char *kwnames[] = {
6128 NULL
6129 };
6130
6131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6132 {
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 result = (bool)wxThread_IsMain();
6135
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 {
6140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6141 }
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj;
6150 wxString *arg1 = 0 ;
6151 wxToolTip *result;
6152 bool temp1 = false ;
6153 PyObject * obj0 = 0 ;
6154 char *kwnames[] = {
6155 (char *) "tip", NULL
6156 };
6157
6158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6159 {
6160 arg1 = wxString_in_helper(obj0);
6161 if (arg1 == NULL) SWIG_fail;
6162 temp1 = true;
6163 }
6164 {
6165 if (!wxPyCheckForApp()) SWIG_fail;
6166 PyThreadState* __tstate = wxPyBeginAllowThreads();
6167 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6168
6169 wxPyEndAllowThreads(__tstate);
6170 if (PyErr_Occurred()) SWIG_fail;
6171 }
6172 {
6173 resultobj = wxPyMake_wxObject(result, 1);
6174 }
6175 {
6176 if (temp1)
6177 delete arg1;
6178 }
6179 return resultobj;
6180 fail:
6181 {
6182 if (temp1)
6183 delete arg1;
6184 }
6185 return NULL;
6186 }
6187
6188
6189 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6190 PyObject *resultobj;
6191 wxToolTip *arg1 = (wxToolTip *) 0 ;
6192 wxString *arg2 = 0 ;
6193 bool temp2 = false ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char *kwnames[] = {
6197 (char *) "self",(char *) "tip", NULL
6198 };
6199
6200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6202 if (SWIG_arg_fail(1)) SWIG_fail;
6203 {
6204 arg2 = wxString_in_helper(obj1);
6205 if (arg2 == NULL) SWIG_fail;
6206 temp2 = true;
6207 }
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 (arg1)->SetTip((wxString const &)*arg2);
6211
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 Py_INCREF(Py_None); resultobj = Py_None;
6216 {
6217 if (temp2)
6218 delete arg2;
6219 }
6220 return resultobj;
6221 fail:
6222 {
6223 if (temp2)
6224 delete arg2;
6225 }
6226 return NULL;
6227 }
6228
6229
6230 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 wxToolTip *arg1 = (wxToolTip *) 0 ;
6233 wxString result;
6234 PyObject * obj0 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 {
6243 PyThreadState* __tstate = wxPyBeginAllowThreads();
6244 result = (arg1)->GetTip();
6245
6246 wxPyEndAllowThreads(__tstate);
6247 if (PyErr_Occurred()) SWIG_fail;
6248 }
6249 {
6250 #if wxUSE_UNICODE
6251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6252 #else
6253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6254 #endif
6255 }
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6263 PyObject *resultobj;
6264 wxToolTip *arg1 = (wxToolTip *) 0 ;
6265 wxWindow *result;
6266 PyObject * obj0 = 0 ;
6267 char *kwnames[] = {
6268 (char *) "self", NULL
6269 };
6270
6271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6273 if (SWIG_arg_fail(1)) SWIG_fail;
6274 {
6275 PyThreadState* __tstate = wxPyBeginAllowThreads();
6276 result = (wxWindow *)(arg1)->GetWindow();
6277
6278 wxPyEndAllowThreads(__tstate);
6279 if (PyErr_Occurred()) SWIG_fail;
6280 }
6281 {
6282 resultobj = wxPyMake_wxObject(result, 0);
6283 }
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj;
6292 bool arg1 ;
6293 PyObject * obj0 = 0 ;
6294 char *kwnames[] = {
6295 (char *) "flag", NULL
6296 };
6297
6298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6299 {
6300 arg1 = (bool)(SWIG_As_bool(obj0));
6301 if (SWIG_arg_fail(1)) SWIG_fail;
6302 }
6303 {
6304 PyThreadState* __tstate = wxPyBeginAllowThreads();
6305 wxToolTip::Enable(arg1);
6306
6307 wxPyEndAllowThreads(__tstate);
6308 if (PyErr_Occurred()) SWIG_fail;
6309 }
6310 Py_INCREF(Py_None); resultobj = Py_None;
6311 return resultobj;
6312 fail:
6313 return NULL;
6314 }
6315
6316
6317 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6318 PyObject *resultobj;
6319 long arg1 ;
6320 PyObject * obj0 = 0 ;
6321 char *kwnames[] = {
6322 (char *) "milliseconds", NULL
6323 };
6324
6325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6326 {
6327 arg1 = (long)(SWIG_As_long(obj0));
6328 if (SWIG_arg_fail(1)) SWIG_fail;
6329 }
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 wxToolTip::SetDelay(arg1);
6333
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 Py_INCREF(Py_None); resultobj = Py_None;
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6345 PyObject *obj;
6346 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6347 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6348 Py_INCREF(obj);
6349 return Py_BuildValue((char *)"");
6350 }
6351 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj;
6353 wxWindow *arg1 = (wxWindow *) 0 ;
6354 wxSize *arg2 = 0 ;
6355 wxCaret *result;
6356 wxSize temp2 ;
6357 PyObject * obj0 = 0 ;
6358 PyObject * obj1 = 0 ;
6359 char *kwnames[] = {
6360 (char *) "window",(char *) "size", NULL
6361 };
6362
6363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6365 if (SWIG_arg_fail(1)) SWIG_fail;
6366 {
6367 arg2 = &temp2;
6368 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6369 }
6370 {
6371 if (!wxPyCheckForApp()) SWIG_fail;
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6374
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6379 return resultobj;
6380 fail:
6381 return NULL;
6382 }
6383
6384
6385 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6386 PyObject *resultobj;
6387 wxCaret *arg1 = (wxCaret *) 0 ;
6388 PyObject * obj0 = 0 ;
6389 char *kwnames[] = {
6390 (char *) "self", NULL
6391 };
6392
6393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6395 if (SWIG_arg_fail(1)) SWIG_fail;
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 wxCaret_Destroy(arg1);
6399
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 Py_INCREF(Py_None); resultobj = Py_None;
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6411 PyObject *resultobj;
6412 wxCaret *arg1 = (wxCaret *) 0 ;
6413 bool result;
6414 PyObject * obj0 = 0 ;
6415 char *kwnames[] = {
6416 (char *) "self", NULL
6417 };
6418
6419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6421 if (SWIG_arg_fail(1)) SWIG_fail;
6422 {
6423 PyThreadState* __tstate = wxPyBeginAllowThreads();
6424 result = (bool)(arg1)->IsOk();
6425
6426 wxPyEndAllowThreads(__tstate);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 {
6430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6431 }
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj;
6440 wxCaret *arg1 = (wxCaret *) 0 ;
6441 bool result;
6442 PyObject * obj0 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "self", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 result = (bool)(arg1)->IsVisible();
6453
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 {
6458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6459 }
6460 return resultobj;
6461 fail:
6462 return NULL;
6463 }
6464
6465
6466 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj;
6468 wxCaret *arg1 = (wxCaret *) 0 ;
6469 wxPoint result;
6470 PyObject * obj0 = 0 ;
6471 char *kwnames[] = {
6472 (char *) "self", NULL
6473 };
6474
6475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6477 if (SWIG_arg_fail(1)) SWIG_fail;
6478 {
6479 PyThreadState* __tstate = wxPyBeginAllowThreads();
6480 result = (arg1)->GetPosition();
6481
6482 wxPyEndAllowThreads(__tstate);
6483 if (PyErr_Occurred()) SWIG_fail;
6484 }
6485 {
6486 wxPoint * resultptr;
6487 resultptr = new wxPoint((wxPoint &)(result));
6488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6489 }
6490 return resultobj;
6491 fail:
6492 return NULL;
6493 }
6494
6495
6496 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6497 PyObject *resultobj;
6498 wxCaret *arg1 = (wxCaret *) 0 ;
6499 int *arg2 = (int *) 0 ;
6500 int *arg3 = (int *) 0 ;
6501 int temp2 ;
6502 int res2 = 0 ;
6503 int temp3 ;
6504 int res3 = 0 ;
6505 PyObject * obj0 = 0 ;
6506 char *kwnames[] = {
6507 (char *) "self", NULL
6508 };
6509
6510 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6511 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6514 if (SWIG_arg_fail(1)) SWIG_fail;
6515 {
6516 PyThreadState* __tstate = wxPyBeginAllowThreads();
6517 (arg1)->GetPosition(arg2,arg3);
6518
6519 wxPyEndAllowThreads(__tstate);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 Py_INCREF(Py_None); resultobj = Py_None;
6523 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6524 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6525 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6526 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj;
6535 wxCaret *arg1 = (wxCaret *) 0 ;
6536 wxSize result;
6537 PyObject * obj0 = 0 ;
6538 char *kwnames[] = {
6539 (char *) "self", NULL
6540 };
6541
6542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6544 if (SWIG_arg_fail(1)) SWIG_fail;
6545 {
6546 PyThreadState* __tstate = wxPyBeginAllowThreads();
6547 result = (arg1)->GetSize();
6548
6549 wxPyEndAllowThreads(__tstate);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 {
6553 wxSize * resultptr;
6554 resultptr = new wxSize((wxSize &)(result));
6555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6556 }
6557 return resultobj;
6558 fail:
6559 return NULL;
6560 }
6561
6562
6563 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6564 PyObject *resultobj;
6565 wxCaret *arg1 = (wxCaret *) 0 ;
6566 int *arg2 = (int *) 0 ;
6567 int *arg3 = (int *) 0 ;
6568 int temp2 ;
6569 int res2 = 0 ;
6570 int temp3 ;
6571 int res3 = 0 ;
6572 PyObject * obj0 = 0 ;
6573 char *kwnames[] = {
6574 (char *) "self", NULL
6575 };
6576
6577 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6578 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6581 if (SWIG_arg_fail(1)) SWIG_fail;
6582 {
6583 PyThreadState* __tstate = wxPyBeginAllowThreads();
6584 (arg1)->GetSize(arg2,arg3);
6585
6586 wxPyEndAllowThreads(__tstate);
6587 if (PyErr_Occurred()) SWIG_fail;
6588 }
6589 Py_INCREF(Py_None); resultobj = Py_None;
6590 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6591 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6592 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6593 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj;
6602 wxCaret *arg1 = (wxCaret *) 0 ;
6603 wxWindow *result;
6604 PyObject * obj0 = 0 ;
6605 char *kwnames[] = {
6606 (char *) "self", NULL
6607 };
6608
6609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6611 if (SWIG_arg_fail(1)) SWIG_fail;
6612 {
6613 PyThreadState* __tstate = wxPyBeginAllowThreads();
6614 result = (wxWindow *)(arg1)->GetWindow();
6615
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 {
6620 resultobj = wxPyMake_wxObject(result, 0);
6621 }
6622 return resultobj;
6623 fail:
6624 return NULL;
6625 }
6626
6627
6628 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6629 PyObject *resultobj;
6630 wxCaret *arg1 = (wxCaret *) 0 ;
6631 int arg2 ;
6632 int arg3 ;
6633 PyObject * obj0 = 0 ;
6634 PyObject * obj1 = 0 ;
6635 PyObject * obj2 = 0 ;
6636 char *kwnames[] = {
6637 (char *) "self",(char *) "x",(char *) "y", NULL
6638 };
6639
6640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6642 if (SWIG_arg_fail(1)) SWIG_fail;
6643 {
6644 arg2 = (int)(SWIG_As_int(obj1));
6645 if (SWIG_arg_fail(2)) SWIG_fail;
6646 }
6647 {
6648 arg3 = (int)(SWIG_As_int(obj2));
6649 if (SWIG_arg_fail(3)) SWIG_fail;
6650 }
6651 {
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 (arg1)->Move(arg2,arg3);
6654
6655 wxPyEndAllowThreads(__tstate);
6656 if (PyErr_Occurred()) SWIG_fail;
6657 }
6658 Py_INCREF(Py_None); resultobj = Py_None;
6659 return resultobj;
6660 fail:
6661 return NULL;
6662 }
6663
6664
6665 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6666 PyObject *resultobj;
6667 wxCaret *arg1 = (wxCaret *) 0 ;
6668 wxPoint *arg2 = 0 ;
6669 wxPoint temp2 ;
6670 PyObject * obj0 = 0 ;
6671 PyObject * obj1 = 0 ;
6672 char *kwnames[] = {
6673 (char *) "self",(char *) "pt", NULL
6674 };
6675
6676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6678 if (SWIG_arg_fail(1)) SWIG_fail;
6679 {
6680 arg2 = &temp2;
6681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6682 }
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 (arg1)->Move((wxPoint const &)*arg2);
6686
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 Py_INCREF(Py_None); resultobj = Py_None;
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6698 PyObject *resultobj;
6699 wxCaret *arg1 = (wxCaret *) 0 ;
6700 int arg2 ;
6701 int arg3 ;
6702 PyObject * obj0 = 0 ;
6703 PyObject * obj1 = 0 ;
6704 PyObject * obj2 = 0 ;
6705 char *kwnames[] = {
6706 (char *) "self",(char *) "width",(char *) "height", NULL
6707 };
6708
6709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6711 if (SWIG_arg_fail(1)) SWIG_fail;
6712 {
6713 arg2 = (int)(SWIG_As_int(obj1));
6714 if (SWIG_arg_fail(2)) SWIG_fail;
6715 }
6716 {
6717 arg3 = (int)(SWIG_As_int(obj2));
6718 if (SWIG_arg_fail(3)) SWIG_fail;
6719 }
6720 {
6721 PyThreadState* __tstate = wxPyBeginAllowThreads();
6722 (arg1)->SetSize(arg2,arg3);
6723
6724 wxPyEndAllowThreads(__tstate);
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 Py_INCREF(Py_None); resultobj = Py_None;
6728 return resultobj;
6729 fail:
6730 return NULL;
6731 }
6732
6733
6734 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6735 PyObject *resultobj;
6736 wxCaret *arg1 = (wxCaret *) 0 ;
6737 wxSize *arg2 = 0 ;
6738 wxSize temp2 ;
6739 PyObject * obj0 = 0 ;
6740 PyObject * obj1 = 0 ;
6741 char *kwnames[] = {
6742 (char *) "self",(char *) "size", NULL
6743 };
6744
6745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6747 if (SWIG_arg_fail(1)) SWIG_fail;
6748 {
6749 arg2 = &temp2;
6750 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6751 }
6752 {
6753 PyThreadState* __tstate = wxPyBeginAllowThreads();
6754 (arg1)->SetSize((wxSize const &)*arg2);
6755
6756 wxPyEndAllowThreads(__tstate);
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 Py_INCREF(Py_None); resultobj = Py_None;
6760 return resultobj;
6761 fail:
6762 return NULL;
6763 }
6764
6765
6766 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6767 PyObject *resultobj;
6768 wxCaret *arg1 = (wxCaret *) 0 ;
6769 int arg2 = (int) true ;
6770 PyObject * obj0 = 0 ;
6771 PyObject * obj1 = 0 ;
6772 char *kwnames[] = {
6773 (char *) "self",(char *) "show", NULL
6774 };
6775
6776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6778 if (SWIG_arg_fail(1)) SWIG_fail;
6779 if (obj1) {
6780 {
6781 arg2 = (int)(SWIG_As_int(obj1));
6782 if (SWIG_arg_fail(2)) SWIG_fail;
6783 }
6784 }
6785 {
6786 PyThreadState* __tstate = wxPyBeginAllowThreads();
6787 (arg1)->Show(arg2);
6788
6789 wxPyEndAllowThreads(__tstate);
6790 if (PyErr_Occurred()) SWIG_fail;
6791 }
6792 Py_INCREF(Py_None); resultobj = Py_None;
6793 return resultobj;
6794 fail:
6795 return NULL;
6796 }
6797
6798
6799 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6800 PyObject *resultobj;
6801 wxCaret *arg1 = (wxCaret *) 0 ;
6802 PyObject * obj0 = 0 ;
6803 char *kwnames[] = {
6804 (char *) "self", NULL
6805 };
6806
6807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6809 if (SWIG_arg_fail(1)) SWIG_fail;
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 (arg1)->Hide();
6813
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 Py_INCREF(Py_None); resultobj = Py_None;
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6825 PyObject *resultobj;
6826 int result;
6827 char *kwnames[] = {
6828 NULL
6829 };
6830
6831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (int)wxCaret::GetBlinkTime();
6835
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 {
6840 resultobj = SWIG_From_int((int)(result));
6841 }
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6849 PyObject *resultobj;
6850 int arg1 ;
6851 PyObject * obj0 = 0 ;
6852 char *kwnames[] = {
6853 (char *) "milliseconds", NULL
6854 };
6855
6856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6857 {
6858 arg1 = (int)(SWIG_As_int(obj0));
6859 if (SWIG_arg_fail(1)) SWIG_fail;
6860 }
6861 {
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 wxCaret::SetBlinkTime(arg1);
6864
6865 wxPyEndAllowThreads(__tstate);
6866 if (PyErr_Occurred()) SWIG_fail;
6867 }
6868 Py_INCREF(Py_None); resultobj = Py_None;
6869 return resultobj;
6870 fail:
6871 return NULL;
6872 }
6873
6874
6875 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6876 PyObject *obj;
6877 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6878 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6879 Py_INCREF(obj);
6880 return Py_BuildValue((char *)"");
6881 }
6882 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6883 PyObject *resultobj;
6884 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6885 wxBusyCursor *result;
6886 PyObject * obj0 = 0 ;
6887 char *kwnames[] = {
6888 (char *) "cursor", NULL
6889 };
6890
6891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6892 if (obj0) {
6893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6894 if (SWIG_arg_fail(1)) SWIG_fail;
6895 }
6896 {
6897 if (!wxPyCheckForApp()) SWIG_fail;
6898 PyThreadState* __tstate = wxPyBeginAllowThreads();
6899 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6900
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6912 PyObject *resultobj;
6913 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6914 PyObject * obj0 = 0 ;
6915 char *kwnames[] = {
6916 (char *) "self", NULL
6917 };
6918
6919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6921 if (SWIG_arg_fail(1)) SWIG_fail;
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 delete arg1;
6925
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 Py_INCREF(Py_None); resultobj = Py_None;
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6937 PyObject *obj;
6938 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6939 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6940 Py_INCREF(obj);
6941 return Py_BuildValue((char *)"");
6942 }
6943 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj;
6945 wxWindow *arg1 = (wxWindow *) NULL ;
6946 wxWindowDisabler *result;
6947 PyObject * obj0 = 0 ;
6948 char *kwnames[] = {
6949 (char *) "winToSkip", NULL
6950 };
6951
6952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6953 if (obj0) {
6954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6955 if (SWIG_arg_fail(1)) SWIG_fail;
6956 }
6957 {
6958 if (!wxPyCheckForApp()) SWIG_fail;
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6961
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6966 return resultobj;
6967 fail:
6968 return NULL;
6969 }
6970
6971
6972 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6973 PyObject *resultobj;
6974 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6975 PyObject * obj0 = 0 ;
6976 char *kwnames[] = {
6977 (char *) "self", NULL
6978 };
6979
6980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6982 if (SWIG_arg_fail(1)) SWIG_fail;
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 delete arg1;
6986
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 Py_INCREF(Py_None); resultobj = Py_None;
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6998 PyObject *obj;
6999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7000 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7001 Py_INCREF(obj);
7002 return Py_BuildValue((char *)"");
7003 }
7004 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7005 PyObject *resultobj;
7006 wxString *arg1 = 0 ;
7007 wxBusyInfo *result;
7008 bool temp1 = false ;
7009 PyObject * obj0 = 0 ;
7010 char *kwnames[] = {
7011 (char *) "message", NULL
7012 };
7013
7014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7015 {
7016 arg1 = wxString_in_helper(obj0);
7017 if (arg1 == NULL) SWIG_fail;
7018 temp1 = true;
7019 }
7020 {
7021 if (!wxPyCheckForApp()) SWIG_fail;
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7024
7025 wxPyEndAllowThreads(__tstate);
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7029 {
7030 if (temp1)
7031 delete arg1;
7032 }
7033 return resultobj;
7034 fail:
7035 {
7036 if (temp1)
7037 delete arg1;
7038 }
7039 return NULL;
7040 }
7041
7042
7043 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7044 PyObject *resultobj;
7045 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7046 PyObject * obj0 = 0 ;
7047 char *kwnames[] = {
7048 (char *) "self", NULL
7049 };
7050
7051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7053 if (SWIG_arg_fail(1)) SWIG_fail;
7054 {
7055 PyThreadState* __tstate = wxPyBeginAllowThreads();
7056 delete arg1;
7057
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 Py_INCREF(Py_None); resultobj = Py_None;
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7069 PyObject *obj;
7070 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7071 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7072 Py_INCREF(obj);
7073 return Py_BuildValue((char *)"");
7074 }
7075 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7076 PyObject *resultobj;
7077 wxStopWatch *result;
7078 char *kwnames[] = {
7079 NULL
7080 };
7081
7082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7083 {
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 result = (wxStopWatch *)new wxStopWatch();
7086
7087 wxPyEndAllowThreads(__tstate);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7098 PyObject *resultobj;
7099 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7100 long arg2 = (long) 0 ;
7101 PyObject * obj0 = 0 ;
7102 PyObject * obj1 = 0 ;
7103 char *kwnames[] = {
7104 (char *) "self",(char *) "t0", NULL
7105 };
7106
7107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7109 if (SWIG_arg_fail(1)) SWIG_fail;
7110 if (obj1) {
7111 {
7112 arg2 = (long)(SWIG_As_long(obj1));
7113 if (SWIG_arg_fail(2)) SWIG_fail;
7114 }
7115 }
7116 {
7117 PyThreadState* __tstate = wxPyBeginAllowThreads();
7118 (arg1)->Start(arg2);
7119
7120 wxPyEndAllowThreads(__tstate);
7121 if (PyErr_Occurred()) SWIG_fail;
7122 }
7123 Py_INCREF(Py_None); resultobj = Py_None;
7124 return resultobj;
7125 fail:
7126 return NULL;
7127 }
7128
7129
7130 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7131 PyObject *resultobj;
7132 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7133 PyObject * obj0 = 0 ;
7134 char *kwnames[] = {
7135 (char *) "self", NULL
7136 };
7137
7138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7140 if (SWIG_arg_fail(1)) SWIG_fail;
7141 {
7142 PyThreadState* __tstate = wxPyBeginAllowThreads();
7143 (arg1)->Pause();
7144
7145 wxPyEndAllowThreads(__tstate);
7146 if (PyErr_Occurred()) SWIG_fail;
7147 }
7148 Py_INCREF(Py_None); resultobj = Py_None;
7149 return resultobj;
7150 fail:
7151 return NULL;
7152 }
7153
7154
7155 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7156 PyObject *resultobj;
7157 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7158 PyObject * obj0 = 0 ;
7159 char *kwnames[] = {
7160 (char *) "self", NULL
7161 };
7162
7163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7165 if (SWIG_arg_fail(1)) SWIG_fail;
7166 {
7167 PyThreadState* __tstate = wxPyBeginAllowThreads();
7168 (arg1)->Resume();
7169
7170 wxPyEndAllowThreads(__tstate);
7171 if (PyErr_Occurred()) SWIG_fail;
7172 }
7173 Py_INCREF(Py_None); resultobj = Py_None;
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj;
7182 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7183 long result;
7184 PyObject * obj0 = 0 ;
7185 char *kwnames[] = {
7186 (char *) "self", NULL
7187 };
7188
7189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7191 if (SWIG_arg_fail(1)) SWIG_fail;
7192 {
7193 PyThreadState* __tstate = wxPyBeginAllowThreads();
7194 result = (long)((wxStopWatch const *)arg1)->Time();
7195
7196 wxPyEndAllowThreads(__tstate);
7197 if (PyErr_Occurred()) SWIG_fail;
7198 }
7199 {
7200 resultobj = SWIG_From_long((long)(result));
7201 }
7202 return resultobj;
7203 fail:
7204 return NULL;
7205 }
7206
7207
7208 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7209 PyObject *obj;
7210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7211 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7212 Py_INCREF(obj);
7213 return Py_BuildValue((char *)"");
7214 }
7215 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7216 PyObject *resultobj;
7217 int arg1 = (int) 9 ;
7218 int arg2 = (int) wxID_FILE1 ;
7219 wxFileHistory *result;
7220 PyObject * obj0 = 0 ;
7221 PyObject * obj1 = 0 ;
7222 char *kwnames[] = {
7223 (char *) "maxFiles",(char *) "idBase", NULL
7224 };
7225
7226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7227 if (obj0) {
7228 {
7229 arg1 = (int)(SWIG_As_int(obj0));
7230 if (SWIG_arg_fail(1)) SWIG_fail;
7231 }
7232 }
7233 if (obj1) {
7234 {
7235 arg2 = (int)(SWIG_As_int(obj1));
7236 if (SWIG_arg_fail(2)) SWIG_fail;
7237 }
7238 }
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7242
7243 wxPyEndAllowThreads(__tstate);
7244 if (PyErr_Occurred()) SWIG_fail;
7245 }
7246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7247 return resultobj;
7248 fail:
7249 return NULL;
7250 }
7251
7252
7253 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7254 PyObject *resultobj;
7255 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7256 PyObject * obj0 = 0 ;
7257 char *kwnames[] = {
7258 (char *) "self", NULL
7259 };
7260
7261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7263 if (SWIG_arg_fail(1)) SWIG_fail;
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 delete arg1;
7267
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 Py_INCREF(Py_None); resultobj = Py_None;
7272 return resultobj;
7273 fail:
7274 return NULL;
7275 }
7276
7277
7278 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7279 PyObject *resultobj;
7280 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7281 wxString *arg2 = 0 ;
7282 bool temp2 = false ;
7283 PyObject * obj0 = 0 ;
7284 PyObject * obj1 = 0 ;
7285 char *kwnames[] = {
7286 (char *) "self",(char *) "file", NULL
7287 };
7288
7289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7291 if (SWIG_arg_fail(1)) SWIG_fail;
7292 {
7293 arg2 = wxString_in_helper(obj1);
7294 if (arg2 == NULL) SWIG_fail;
7295 temp2 = true;
7296 }
7297 {
7298 PyThreadState* __tstate = wxPyBeginAllowThreads();
7299 (arg1)->AddFileToHistory((wxString const &)*arg2);
7300
7301 wxPyEndAllowThreads(__tstate);
7302 if (PyErr_Occurred()) SWIG_fail;
7303 }
7304 Py_INCREF(Py_None); resultobj = Py_None;
7305 {
7306 if (temp2)
7307 delete arg2;
7308 }
7309 return resultobj;
7310 fail:
7311 {
7312 if (temp2)
7313 delete arg2;
7314 }
7315 return NULL;
7316 }
7317
7318
7319 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7320 PyObject *resultobj;
7321 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7322 int arg2 ;
7323 PyObject * obj0 = 0 ;
7324 PyObject * obj1 = 0 ;
7325 char *kwnames[] = {
7326 (char *) "self",(char *) "i", NULL
7327 };
7328
7329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7331 if (SWIG_arg_fail(1)) SWIG_fail;
7332 {
7333 arg2 = (int)(SWIG_As_int(obj1));
7334 if (SWIG_arg_fail(2)) SWIG_fail;
7335 }
7336 {
7337 PyThreadState* __tstate = wxPyBeginAllowThreads();
7338 (arg1)->RemoveFileFromHistory(arg2);
7339
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 Py_INCREF(Py_None); resultobj = Py_None;
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj;
7352 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7353 int result;
7354 PyObject * obj0 = 0 ;
7355 char *kwnames[] = {
7356 (char *) "self", NULL
7357 };
7358
7359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7361 if (SWIG_arg_fail(1)) SWIG_fail;
7362 {
7363 PyThreadState* __tstate = wxPyBeginAllowThreads();
7364 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7365
7366 wxPyEndAllowThreads(__tstate);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 {
7370 resultobj = SWIG_From_int((int)(result));
7371 }
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7379 PyObject *resultobj;
7380 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7381 wxMenu *arg2 = (wxMenu *) 0 ;
7382 PyObject * obj0 = 0 ;
7383 PyObject * obj1 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "self",(char *) "menu", NULL
7386 };
7387
7388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7390 if (SWIG_arg_fail(1)) SWIG_fail;
7391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7392 if (SWIG_arg_fail(2)) SWIG_fail;
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 (arg1)->UseMenu(arg2);
7396
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 Py_INCREF(Py_None); resultobj = Py_None;
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj;
7409 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7410 wxMenu *arg2 = (wxMenu *) 0 ;
7411 PyObject * obj0 = 0 ;
7412 PyObject * obj1 = 0 ;
7413 char *kwnames[] = {
7414 (char *) "self",(char *) "menu", NULL
7415 };
7416
7417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7419 if (SWIG_arg_fail(1)) SWIG_fail;
7420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7421 if (SWIG_arg_fail(2)) SWIG_fail;
7422 {
7423 PyThreadState* __tstate = wxPyBeginAllowThreads();
7424 (arg1)->RemoveMenu(arg2);
7425
7426 wxPyEndAllowThreads(__tstate);
7427 if (PyErr_Occurred()) SWIG_fail;
7428 }
7429 Py_INCREF(Py_None); resultobj = Py_None;
7430 return resultobj;
7431 fail:
7432 return NULL;
7433 }
7434
7435
7436 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7437 PyObject *resultobj;
7438 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7439 wxConfigBase *arg2 = 0 ;
7440 PyObject * obj0 = 0 ;
7441 PyObject * obj1 = 0 ;
7442 char *kwnames[] = {
7443 (char *) "self",(char *) "config", NULL
7444 };
7445
7446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7448 if (SWIG_arg_fail(1)) SWIG_fail;
7449 {
7450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7451 if (SWIG_arg_fail(2)) SWIG_fail;
7452 if (arg2 == NULL) {
7453 SWIG_null_ref("wxConfigBase");
7454 }
7455 if (SWIG_arg_fail(2)) SWIG_fail;
7456 }
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 (arg1)->Load(*arg2);
7460
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 Py_INCREF(Py_None); resultobj = Py_None;
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj;
7473 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7474 wxConfigBase *arg2 = 0 ;
7475 PyObject * obj0 = 0 ;
7476 PyObject * obj1 = 0 ;
7477 char *kwnames[] = {
7478 (char *) "self",(char *) "config", NULL
7479 };
7480
7481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7483 if (SWIG_arg_fail(1)) SWIG_fail;
7484 {
7485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7486 if (SWIG_arg_fail(2)) SWIG_fail;
7487 if (arg2 == NULL) {
7488 SWIG_null_ref("wxConfigBase");
7489 }
7490 if (SWIG_arg_fail(2)) SWIG_fail;
7491 }
7492 {
7493 PyThreadState* __tstate = wxPyBeginAllowThreads();
7494 (arg1)->Save(*arg2);
7495
7496 wxPyEndAllowThreads(__tstate);
7497 if (PyErr_Occurred()) SWIG_fail;
7498 }
7499 Py_INCREF(Py_None); resultobj = Py_None;
7500 return resultobj;
7501 fail:
7502 return NULL;
7503 }
7504
7505
7506 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7507 PyObject *resultobj;
7508 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7509 PyObject * obj0 = 0 ;
7510 char *kwnames[] = {
7511 (char *) "self", NULL
7512 };
7513
7514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7516 if (SWIG_arg_fail(1)) SWIG_fail;
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 (arg1)->AddFilesToMenu();
7520
7521 wxPyEndAllowThreads(__tstate);
7522 if (PyErr_Occurred()) SWIG_fail;
7523 }
7524 Py_INCREF(Py_None); resultobj = Py_None;
7525 return resultobj;
7526 fail:
7527 return NULL;
7528 }
7529
7530
7531 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7532 PyObject *resultobj;
7533 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7534 wxMenu *arg2 = (wxMenu *) 0 ;
7535 PyObject * obj0 = 0 ;
7536 PyObject * obj1 = 0 ;
7537 char *kwnames[] = {
7538 (char *) "self",(char *) "menu", NULL
7539 };
7540
7541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7543 if (SWIG_arg_fail(1)) SWIG_fail;
7544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7545 if (SWIG_arg_fail(2)) SWIG_fail;
7546 {
7547 PyThreadState* __tstate = wxPyBeginAllowThreads();
7548 (arg1)->AddFilesToMenu(arg2);
7549
7550 wxPyEndAllowThreads(__tstate);
7551 if (PyErr_Occurred()) SWIG_fail;
7552 }
7553 Py_INCREF(Py_None); resultobj = Py_None;
7554 return resultobj;
7555 fail:
7556 return NULL;
7557 }
7558
7559
7560 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7561 PyObject *resultobj;
7562 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7563 int arg2 ;
7564 wxString result;
7565 PyObject * obj0 = 0 ;
7566 PyObject * obj1 = 0 ;
7567 char *kwnames[] = {
7568 (char *) "self",(char *) "i", NULL
7569 };
7570
7571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7573 if (SWIG_arg_fail(1)) SWIG_fail;
7574 {
7575 arg2 = (int)(SWIG_As_int(obj1));
7576 if (SWIG_arg_fail(2)) SWIG_fail;
7577 }
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 {
7586 #if wxUSE_UNICODE
7587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7588 #else
7589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7590 #endif
7591 }
7592 return resultobj;
7593 fail:
7594 return NULL;
7595 }
7596
7597
7598 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7599 PyObject *resultobj;
7600 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7601 int result;
7602 PyObject * obj0 = 0 ;
7603 char *kwnames[] = {
7604 (char *) "self", NULL
7605 };
7606
7607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7609 if (SWIG_arg_fail(1)) SWIG_fail;
7610 {
7611 PyThreadState* __tstate = wxPyBeginAllowThreads();
7612 result = (int)((wxFileHistory const *)arg1)->GetCount();
7613
7614 wxPyEndAllowThreads(__tstate);
7615 if (PyErr_Occurred()) SWIG_fail;
7616 }
7617 {
7618 resultobj = SWIG_From_int((int)(result));
7619 }
7620 return resultobj;
7621 fail:
7622 return NULL;
7623 }
7624
7625
7626 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7627 PyObject *obj;
7628 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7629 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7630 Py_INCREF(obj);
7631 return Py_BuildValue((char *)"");
7632 }
7633 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7634 PyObject *resultobj;
7635 wxString *arg1 = 0 ;
7636 wxString const &arg2_defvalue = wxPyEmptyString ;
7637 wxString *arg2 = (wxString *) &arg2_defvalue ;
7638 wxSingleInstanceChecker *result;
7639 bool temp1 = false ;
7640 bool temp2 = false ;
7641 PyObject * obj0 = 0 ;
7642 PyObject * obj1 = 0 ;
7643 char *kwnames[] = {
7644 (char *) "name",(char *) "path", NULL
7645 };
7646
7647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7648 {
7649 arg1 = wxString_in_helper(obj0);
7650 if (arg1 == NULL) SWIG_fail;
7651 temp1 = true;
7652 }
7653 if (obj1) {
7654 {
7655 arg2 = wxString_in_helper(obj1);
7656 if (arg2 == NULL) SWIG_fail;
7657 temp2 = true;
7658 }
7659 }
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7668 {
7669 if (temp1)
7670 delete arg1;
7671 }
7672 {
7673 if (temp2)
7674 delete arg2;
7675 }
7676 return resultobj;
7677 fail:
7678 {
7679 if (temp1)
7680 delete arg1;
7681 }
7682 {
7683 if (temp2)
7684 delete arg2;
7685 }
7686 return NULL;
7687 }
7688
7689
7690 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj;
7692 wxSingleInstanceChecker *result;
7693 char *kwnames[] = {
7694 NULL
7695 };
7696
7697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7698 {
7699 PyThreadState* __tstate = wxPyBeginAllowThreads();
7700 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7701
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj;
7714 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7715 PyObject * obj0 = 0 ;
7716 char *kwnames[] = {
7717 (char *) "self", NULL
7718 };
7719
7720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7722 if (SWIG_arg_fail(1)) SWIG_fail;
7723 {
7724 PyThreadState* __tstate = wxPyBeginAllowThreads();
7725 delete arg1;
7726
7727 wxPyEndAllowThreads(__tstate);
7728 if (PyErr_Occurred()) SWIG_fail;
7729 }
7730 Py_INCREF(Py_None); resultobj = Py_None;
7731 return resultobj;
7732 fail:
7733 return NULL;
7734 }
7735
7736
7737 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7738 PyObject *resultobj;
7739 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7740 wxString *arg2 = 0 ;
7741 wxString const &arg3_defvalue = wxPyEmptyString ;
7742 wxString *arg3 = (wxString *) &arg3_defvalue ;
7743 bool result;
7744 bool temp2 = false ;
7745 bool temp3 = false ;
7746 PyObject * obj0 = 0 ;
7747 PyObject * obj1 = 0 ;
7748 PyObject * obj2 = 0 ;
7749 char *kwnames[] = {
7750 (char *) "self",(char *) "name",(char *) "path", NULL
7751 };
7752
7753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7755 if (SWIG_arg_fail(1)) SWIG_fail;
7756 {
7757 arg2 = wxString_in_helper(obj1);
7758 if (arg2 == NULL) SWIG_fail;
7759 temp2 = true;
7760 }
7761 if (obj2) {
7762 {
7763 arg3 = wxString_in_helper(obj2);
7764 if (arg3 == NULL) SWIG_fail;
7765 temp3 = true;
7766 }
7767 }
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7771
7772 wxPyEndAllowThreads(__tstate);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 {
7776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7777 }
7778 {
7779 if (temp2)
7780 delete arg2;
7781 }
7782 {
7783 if (temp3)
7784 delete arg3;
7785 }
7786 return resultobj;
7787 fail:
7788 {
7789 if (temp2)
7790 delete arg2;
7791 }
7792 {
7793 if (temp3)
7794 delete arg3;
7795 }
7796 return NULL;
7797 }
7798
7799
7800 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7801 PyObject *resultobj;
7802 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7803 bool result;
7804 PyObject * obj0 = 0 ;
7805 char *kwnames[] = {
7806 (char *) "self", NULL
7807 };
7808
7809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7811 if (SWIG_arg_fail(1)) SWIG_fail;
7812 {
7813 PyThreadState* __tstate = wxPyBeginAllowThreads();
7814 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7815
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 {
7820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7821 }
7822 return resultobj;
7823 fail:
7824 return NULL;
7825 }
7826
7827
7828 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7829 PyObject *obj;
7830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7831 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7832 Py_INCREF(obj);
7833 return Py_BuildValue((char *)"");
7834 }
7835 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj;
7837 wxWindow *arg1 = (wxWindow *) 0 ;
7838 wxDC *arg2 = 0 ;
7839 bool result;
7840 PyObject * obj0 = 0 ;
7841 PyObject * obj1 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "window",(char *) "dc", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7851 if (SWIG_arg_fail(2)) SWIG_fail;
7852 if (arg2 == NULL) {
7853 SWIG_null_ref("wxDC");
7854 }
7855 if (SWIG_arg_fail(2)) SWIG_fail;
7856 }
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 {
7865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7866 }
7867 return resultobj;
7868 fail:
7869 return NULL;
7870 }
7871
7872
7873 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7874 PyObject *resultobj;
7875 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7876 PyObject * obj0 = 0 ;
7877 char *kwnames[] = {
7878 (char *) "self", NULL
7879 };
7880
7881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7883 if (SWIG_arg_fail(1)) SWIG_fail;
7884 {
7885 PyThreadState* __tstate = wxPyBeginAllowThreads();
7886 delete arg1;
7887
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 Py_INCREF(Py_None); resultobj = Py_None;
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj;
7900 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7901 wxString result;
7902 PyObject * obj0 = 0 ;
7903 char *kwnames[] = {
7904 (char *) "self", NULL
7905 };
7906
7907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7909 if (SWIG_arg_fail(1)) SWIG_fail;
7910 {
7911 PyThreadState* __tstate = wxPyBeginAllowThreads();
7912 result = (arg1)->GetTip();
7913
7914 wxPyEndAllowThreads(__tstate);
7915 if (PyErr_Occurred()) SWIG_fail;
7916 }
7917 {
7918 #if wxUSE_UNICODE
7919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7920 #else
7921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7922 #endif
7923 }
7924 return resultobj;
7925 fail:
7926 return NULL;
7927 }
7928
7929
7930 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7931 PyObject *resultobj;
7932 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7933 size_t result;
7934 PyObject * obj0 = 0 ;
7935 char *kwnames[] = {
7936 (char *) "self", NULL
7937 };
7938
7939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7941 if (SWIG_arg_fail(1)) SWIG_fail;
7942 {
7943 PyThreadState* __tstate = wxPyBeginAllowThreads();
7944 result = (size_t)(arg1)->GetCurrentTip();
7945
7946 wxPyEndAllowThreads(__tstate);
7947 if (PyErr_Occurred()) SWIG_fail;
7948 }
7949 {
7950 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7951 }
7952 return resultobj;
7953 fail:
7954 return NULL;
7955 }
7956
7957
7958 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7959 PyObject *resultobj;
7960 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7961 wxString *arg2 = 0 ;
7962 wxString result;
7963 bool temp2 = false ;
7964 PyObject * obj0 = 0 ;
7965 PyObject * obj1 = 0 ;
7966 char *kwnames[] = {
7967 (char *) "self",(char *) "tip", NULL
7968 };
7969
7970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7972 if (SWIG_arg_fail(1)) SWIG_fail;
7973 {
7974 arg2 = wxString_in_helper(obj1);
7975 if (arg2 == NULL) SWIG_fail;
7976 temp2 = true;
7977 }
7978 {
7979 PyThreadState* __tstate = wxPyBeginAllowThreads();
7980 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7981
7982 wxPyEndAllowThreads(__tstate);
7983 if (PyErr_Occurred()) SWIG_fail;
7984 }
7985 {
7986 #if wxUSE_UNICODE
7987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7988 #else
7989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7990 #endif
7991 }
7992 {
7993 if (temp2)
7994 delete arg2;
7995 }
7996 return resultobj;
7997 fail:
7998 {
7999 if (temp2)
8000 delete arg2;
8001 }
8002 return NULL;
8003 }
8004
8005
8006 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8007 PyObject *obj;
8008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8009 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8010 Py_INCREF(obj);
8011 return Py_BuildValue((char *)"");
8012 }
8013 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8014 PyObject *resultobj;
8015 size_t arg1 ;
8016 wxPyTipProvider *result;
8017 PyObject * obj0 = 0 ;
8018 char *kwnames[] = {
8019 (char *) "currentTip", NULL
8020 };
8021
8022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8023 {
8024 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8025 if (SWIG_arg_fail(1)) SWIG_fail;
8026 }
8027 {
8028 PyThreadState* __tstate = wxPyBeginAllowThreads();
8029 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8030
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8035 return resultobj;
8036 fail:
8037 return NULL;
8038 }
8039
8040
8041 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8042 PyObject *resultobj;
8043 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8044 PyObject *arg2 = (PyObject *) 0 ;
8045 PyObject *arg3 = (PyObject *) 0 ;
8046 PyObject * obj0 = 0 ;
8047 PyObject * obj1 = 0 ;
8048 PyObject * obj2 = 0 ;
8049 char *kwnames[] = {
8050 (char *) "self",(char *) "self",(char *) "_class", NULL
8051 };
8052
8053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8055 if (SWIG_arg_fail(1)) SWIG_fail;
8056 arg2 = obj1;
8057 arg3 = obj2;
8058 {
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 (arg1)->_setCallbackInfo(arg2,arg3);
8061
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 Py_INCREF(Py_None); resultobj = Py_None;
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8073 PyObject *obj;
8074 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8075 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8076 Py_INCREF(obj);
8077 return Py_BuildValue((char *)"");
8078 }
8079 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8080 PyObject *resultobj;
8081 wxWindow *arg1 = (wxWindow *) 0 ;
8082 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8083 bool arg3 = (bool) true ;
8084 bool result;
8085 PyObject * obj0 = 0 ;
8086 PyObject * obj1 = 0 ;
8087 PyObject * obj2 = 0 ;
8088 char *kwnames[] = {
8089 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8090 };
8091
8092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(1)) SWIG_fail;
8095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8096 if (SWIG_arg_fail(2)) SWIG_fail;
8097 if (obj2) {
8098 {
8099 arg3 = (bool)(SWIG_As_bool(obj2));
8100 if (SWIG_arg_fail(3)) SWIG_fail;
8101 }
8102 }
8103 {
8104 if (!wxPyCheckForApp()) SWIG_fail;
8105 PyThreadState* __tstate = wxPyBeginAllowThreads();
8106 result = (bool)wxShowTip(arg1,arg2,arg3);
8107
8108 wxPyEndAllowThreads(__tstate);
8109 if (PyErr_Occurred()) SWIG_fail;
8110 }
8111 {
8112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8113 }
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8121 PyObject *resultobj;
8122 wxString *arg1 = 0 ;
8123 size_t arg2 ;
8124 wxTipProvider *result;
8125 bool temp1 = false ;
8126 PyObject * obj0 = 0 ;
8127 PyObject * obj1 = 0 ;
8128 char *kwnames[] = {
8129 (char *) "filename",(char *) "currentTip", NULL
8130 };
8131
8132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8133 {
8134 arg1 = wxString_in_helper(obj0);
8135 if (arg1 == NULL) SWIG_fail;
8136 temp1 = true;
8137 }
8138 {
8139 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8140 if (SWIG_arg_fail(2)) SWIG_fail;
8141 }
8142 {
8143 if (!wxPyCheckForApp()) SWIG_fail;
8144 PyThreadState* __tstate = wxPyBeginAllowThreads();
8145 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8146
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8151 {
8152 if (temp1)
8153 delete arg1;
8154 }
8155 return resultobj;
8156 fail:
8157 {
8158 if (temp1)
8159 delete arg1;
8160 }
8161 return NULL;
8162 }
8163
8164
8165 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8166 PyObject *resultobj;
8167 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8168 int arg2 = (int) -1 ;
8169 wxPyTimer *result;
8170 PyObject * obj0 = 0 ;
8171 PyObject * obj1 = 0 ;
8172 char *kwnames[] = {
8173 (char *) "owner",(char *) "id", NULL
8174 };
8175
8176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8177 if (obj0) {
8178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8179 if (SWIG_arg_fail(1)) SWIG_fail;
8180 }
8181 if (obj1) {
8182 {
8183 arg2 = (int)(SWIG_As_int(obj1));
8184 if (SWIG_arg_fail(2)) SWIG_fail;
8185 }
8186 }
8187 {
8188 if (!wxPyCheckForApp()) SWIG_fail;
8189 PyThreadState* __tstate = wxPyBeginAllowThreads();
8190 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8191
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj;
8204 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8205 PyObject * obj0 = 0 ;
8206 char *kwnames[] = {
8207 (char *) "self", NULL
8208 };
8209
8210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8212 if (SWIG_arg_fail(1)) SWIG_fail;
8213 {
8214 PyThreadState* __tstate = wxPyBeginAllowThreads();
8215 delete arg1;
8216
8217 wxPyEndAllowThreads(__tstate);
8218 if (PyErr_Occurred()) SWIG_fail;
8219 }
8220 Py_INCREF(Py_None); resultobj = Py_None;
8221 return resultobj;
8222 fail:
8223 return NULL;
8224 }
8225
8226
8227 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8228 PyObject *resultobj;
8229 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8230 PyObject *arg2 = (PyObject *) 0 ;
8231 PyObject *arg3 = (PyObject *) 0 ;
8232 int arg4 = (int) 1 ;
8233 PyObject * obj0 = 0 ;
8234 PyObject * obj1 = 0 ;
8235 PyObject * obj2 = 0 ;
8236 PyObject * obj3 = 0 ;
8237 char *kwnames[] = {
8238 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8239 };
8240
8241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(1)) SWIG_fail;
8244 arg2 = obj1;
8245 arg3 = obj2;
8246 if (obj3) {
8247 {
8248 arg4 = (int)(SWIG_As_int(obj3));
8249 if (SWIG_arg_fail(4)) SWIG_fail;
8250 }
8251 }
8252 {
8253 PyThreadState* __tstate = wxPyBeginAllowThreads();
8254 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8255
8256 wxPyEndAllowThreads(__tstate);
8257 if (PyErr_Occurred()) SWIG_fail;
8258 }
8259 Py_INCREF(Py_None); resultobj = Py_None;
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8267 PyObject *resultobj;
8268 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8269 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8270 int arg3 = (int) -1 ;
8271 PyObject * obj0 = 0 ;
8272 PyObject * obj1 = 0 ;
8273 PyObject * obj2 = 0 ;
8274 char *kwnames[] = {
8275 (char *) "self",(char *) "owner",(char *) "id", NULL
8276 };
8277
8278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8280 if (SWIG_arg_fail(1)) SWIG_fail;
8281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8282 if (SWIG_arg_fail(2)) SWIG_fail;
8283 if (obj2) {
8284 {
8285 arg3 = (int)(SWIG_As_int(obj2));
8286 if (SWIG_arg_fail(3)) SWIG_fail;
8287 }
8288 }
8289 {
8290 PyThreadState* __tstate = wxPyBeginAllowThreads();
8291 (arg1)->SetOwner(arg2,arg3);
8292
8293 wxPyEndAllowThreads(__tstate);
8294 if (PyErr_Occurred()) SWIG_fail;
8295 }
8296 Py_INCREF(Py_None); resultobj = Py_None;
8297 return resultobj;
8298 fail:
8299 return NULL;
8300 }
8301
8302
8303 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8304 PyObject *resultobj;
8305 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8306 wxEvtHandler *result;
8307 PyObject * obj0 = 0 ;
8308 char *kwnames[] = {
8309 (char *) "self", NULL
8310 };
8311
8312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8314 if (SWIG_arg_fail(1)) SWIG_fail;
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 result = (wxEvtHandler *)(arg1)->GetOwner();
8318
8319 wxPyEndAllowThreads(__tstate);
8320 if (PyErr_Occurred()) SWIG_fail;
8321 }
8322 {
8323 resultobj = wxPyMake_wxObject(result, 0);
8324 }
8325 return resultobj;
8326 fail:
8327 return NULL;
8328 }
8329
8330
8331 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8332 PyObject *resultobj;
8333 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8334 int arg2 = (int) -1 ;
8335 bool arg3 = (bool) false ;
8336 bool result;
8337 PyObject * obj0 = 0 ;
8338 PyObject * obj1 = 0 ;
8339 PyObject * obj2 = 0 ;
8340 char *kwnames[] = {
8341 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8342 };
8343
8344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8346 if (SWIG_arg_fail(1)) SWIG_fail;
8347 if (obj1) {
8348 {
8349 arg2 = (int)(SWIG_As_int(obj1));
8350 if (SWIG_arg_fail(2)) SWIG_fail;
8351 }
8352 }
8353 if (obj2) {
8354 {
8355 arg3 = (bool)(SWIG_As_bool(obj2));
8356 if (SWIG_arg_fail(3)) SWIG_fail;
8357 }
8358 }
8359 {
8360 PyThreadState* __tstate = wxPyBeginAllowThreads();
8361 result = (bool)(arg1)->Start(arg2,arg3);
8362
8363 wxPyEndAllowThreads(__tstate);
8364 if (PyErr_Occurred()) SWIG_fail;
8365 }
8366 {
8367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8368 }
8369 return resultobj;
8370 fail:
8371 return NULL;
8372 }
8373
8374
8375 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8376 PyObject *resultobj;
8377 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8378 PyObject * obj0 = 0 ;
8379 char *kwnames[] = {
8380 (char *) "self", NULL
8381 };
8382
8383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8385 if (SWIG_arg_fail(1)) SWIG_fail;
8386 {
8387 PyThreadState* __tstate = wxPyBeginAllowThreads();
8388 (arg1)->Stop();
8389
8390 wxPyEndAllowThreads(__tstate);
8391 if (PyErr_Occurred()) SWIG_fail;
8392 }
8393 Py_INCREF(Py_None); resultobj = Py_None;
8394 return resultobj;
8395 fail:
8396 return NULL;
8397 }
8398
8399
8400 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8401 PyObject *resultobj;
8402 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8403 bool result;
8404 PyObject * obj0 = 0 ;
8405 char *kwnames[] = {
8406 (char *) "self", NULL
8407 };
8408
8409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8411 if (SWIG_arg_fail(1)) SWIG_fail;
8412 {
8413 PyThreadState* __tstate = wxPyBeginAllowThreads();
8414 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8415
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 {
8420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8421 }
8422 return resultobj;
8423 fail:
8424 return NULL;
8425 }
8426
8427
8428 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8429 PyObject *resultobj;
8430 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8431 int result;
8432 PyObject * obj0 = 0 ;
8433 char *kwnames[] = {
8434 (char *) "self", NULL
8435 };
8436
8437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8439 if (SWIG_arg_fail(1)) SWIG_fail;
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8443
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 {
8448 resultobj = SWIG_From_int((int)(result));
8449 }
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj;
8458 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8459 bool result;
8460 PyObject * obj0 = 0 ;
8461 char *kwnames[] = {
8462 (char *) "self", NULL
8463 };
8464
8465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8467 if (SWIG_arg_fail(1)) SWIG_fail;
8468 {
8469 PyThreadState* __tstate = wxPyBeginAllowThreads();
8470 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8471
8472 wxPyEndAllowThreads(__tstate);
8473 if (PyErr_Occurred()) SWIG_fail;
8474 }
8475 {
8476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8477 }
8478 return resultobj;
8479 fail:
8480 return NULL;
8481 }
8482
8483
8484 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8485 PyObject *resultobj;
8486 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8487 int result;
8488 PyObject * obj0 = 0 ;
8489 char *kwnames[] = {
8490 (char *) "self", NULL
8491 };
8492
8493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8495 if (SWIG_arg_fail(1)) SWIG_fail;
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (int)((wxPyTimer const *)arg1)->GetId();
8499
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 {
8504 resultobj = SWIG_From_int((int)(result));
8505 }
8506 return resultobj;
8507 fail:
8508 return NULL;
8509 }
8510
8511
8512 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8513 PyObject *obj;
8514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8515 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8516 Py_INCREF(obj);
8517 return Py_BuildValue((char *)"");
8518 }
8519 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj;
8521 int arg1 = (int) 0 ;
8522 int arg2 = (int) 0 ;
8523 wxTimerEvent *result;
8524 PyObject * obj0 = 0 ;
8525 PyObject * obj1 = 0 ;
8526 char *kwnames[] = {
8527 (char *) "timerid",(char *) "interval", NULL
8528 };
8529
8530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8531 if (obj0) {
8532 {
8533 arg1 = (int)(SWIG_As_int(obj0));
8534 if (SWIG_arg_fail(1)) SWIG_fail;
8535 }
8536 }
8537 if (obj1) {
8538 {
8539 arg2 = (int)(SWIG_As_int(obj1));
8540 if (SWIG_arg_fail(2)) SWIG_fail;
8541 }
8542 }
8543 {
8544 PyThreadState* __tstate = wxPyBeginAllowThreads();
8545 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8546
8547 wxPyEndAllowThreads(__tstate);
8548 if (PyErr_Occurred()) SWIG_fail;
8549 }
8550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8551 return resultobj;
8552 fail:
8553 return NULL;
8554 }
8555
8556
8557 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8558 PyObject *resultobj;
8559 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8560 int result;
8561 PyObject * obj0 = 0 ;
8562 char *kwnames[] = {
8563 (char *) "self", NULL
8564 };
8565
8566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8568 if (SWIG_arg_fail(1)) SWIG_fail;
8569 {
8570 PyThreadState* __tstate = wxPyBeginAllowThreads();
8571 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8572
8573 wxPyEndAllowThreads(__tstate);
8574 if (PyErr_Occurred()) SWIG_fail;
8575 }
8576 {
8577 resultobj = SWIG_From_int((int)(result));
8578 }
8579 return resultobj;
8580 fail:
8581 return NULL;
8582 }
8583
8584
8585 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8586 PyObject *obj;
8587 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8588 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8589 Py_INCREF(obj);
8590 return Py_BuildValue((char *)"");
8591 }
8592 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8593 PyObject *resultobj;
8594 wxTimer *arg1 = 0 ;
8595 wxTimerRunner *result;
8596 PyObject * obj0 = 0 ;
8597
8598 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8599 {
8600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8601 if (SWIG_arg_fail(1)) SWIG_fail;
8602 if (arg1 == NULL) {
8603 SWIG_null_ref("wxTimer");
8604 }
8605 if (SWIG_arg_fail(1)) SWIG_fail;
8606 }
8607 {
8608 if (!wxPyCheckForApp()) SWIG_fail;
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8611
8612 wxPyEndAllowThreads(__tstate);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8616 return resultobj;
8617 fail:
8618 return NULL;
8619 }
8620
8621
8622 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8623 PyObject *resultobj;
8624 wxTimer *arg1 = 0 ;
8625 int arg2 ;
8626 bool arg3 = (bool) false ;
8627 wxTimerRunner *result;
8628 PyObject * obj0 = 0 ;
8629 PyObject * obj1 = 0 ;
8630 PyObject * obj2 = 0 ;
8631
8632 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8633 {
8634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8635 if (SWIG_arg_fail(1)) SWIG_fail;
8636 if (arg1 == NULL) {
8637 SWIG_null_ref("wxTimer");
8638 }
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 }
8641 {
8642 arg2 = (int)(SWIG_As_int(obj1));
8643 if (SWIG_arg_fail(2)) SWIG_fail;
8644 }
8645 if (obj2) {
8646 {
8647 arg3 = (bool)(SWIG_As_bool(obj2));
8648 if (SWIG_arg_fail(3)) SWIG_fail;
8649 }
8650 }
8651 {
8652 if (!wxPyCheckForApp()) SWIG_fail;
8653 PyThreadState* __tstate = wxPyBeginAllowThreads();
8654 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8655
8656 wxPyEndAllowThreads(__tstate);
8657 if (PyErr_Occurred()) SWIG_fail;
8658 }
8659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8660 return resultobj;
8661 fail:
8662 return NULL;
8663 }
8664
8665
8666 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8667 int argc;
8668 PyObject *argv[4];
8669 int ii;
8670
8671 argc = PyObject_Length(args);
8672 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8673 argv[ii] = PyTuple_GetItem(args,ii);
8674 }
8675 if (argc == 1) {
8676 int _v;
8677 {
8678 void *ptr = 0;
8679 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8680 _v = 0;
8681 PyErr_Clear();
8682 } else {
8683 _v = (ptr != 0);
8684 }
8685 }
8686 if (_v) {
8687 return _wrap_new_TimerRunner__SWIG_0(self,args);
8688 }
8689 }
8690 if ((argc >= 2) && (argc <= 3)) {
8691 int _v;
8692 {
8693 void *ptr = 0;
8694 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8695 _v = 0;
8696 PyErr_Clear();
8697 } else {
8698 _v = (ptr != 0);
8699 }
8700 }
8701 if (_v) {
8702 _v = SWIG_Check_int(argv[1]);
8703 if (_v) {
8704 if (argc <= 2) {
8705 return _wrap_new_TimerRunner__SWIG_1(self,args);
8706 }
8707 _v = SWIG_Check_bool(argv[2]);
8708 if (_v) {
8709 return _wrap_new_TimerRunner__SWIG_1(self,args);
8710 }
8711 }
8712 }
8713 }
8714
8715 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8716 return NULL;
8717 }
8718
8719
8720 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj;
8722 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8723 PyObject * obj0 = 0 ;
8724 char *kwnames[] = {
8725 (char *) "self", NULL
8726 };
8727
8728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8730 if (SWIG_arg_fail(1)) SWIG_fail;
8731 {
8732 PyThreadState* __tstate = wxPyBeginAllowThreads();
8733 delete arg1;
8734
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 Py_INCREF(Py_None); resultobj = Py_None;
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8746 PyObject *resultobj;
8747 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8748 int arg2 ;
8749 bool arg3 = (bool) false ;
8750 PyObject * obj0 = 0 ;
8751 PyObject * obj1 = 0 ;
8752 PyObject * obj2 = 0 ;
8753 char *kwnames[] = {
8754 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8755 };
8756
8757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8759 if (SWIG_arg_fail(1)) SWIG_fail;
8760 {
8761 arg2 = (int)(SWIG_As_int(obj1));
8762 if (SWIG_arg_fail(2)) SWIG_fail;
8763 }
8764 if (obj2) {
8765 {
8766 arg3 = (bool)(SWIG_As_bool(obj2));
8767 if (SWIG_arg_fail(3)) SWIG_fail;
8768 }
8769 }
8770 {
8771 PyThreadState* __tstate = wxPyBeginAllowThreads();
8772 (arg1)->Start(arg2,arg3);
8773
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 Py_INCREF(Py_None); resultobj = Py_None;
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8785 PyObject *obj;
8786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8787 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8788 Py_INCREF(obj);
8789 return Py_BuildValue((char *)"");
8790 }
8791 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8792 PyObject *resultobj;
8793 wxLog *result;
8794 char *kwnames[] = {
8795 NULL
8796 };
8797
8798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8799 {
8800 PyThreadState* __tstate = wxPyBeginAllowThreads();
8801 result = (wxLog *)new wxLog();
8802
8803 wxPyEndAllowThreads(__tstate);
8804 if (PyErr_Occurred()) SWIG_fail;
8805 }
8806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8807 return resultobj;
8808 fail:
8809 return NULL;
8810 }
8811
8812
8813 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8814 PyObject *resultobj;
8815 bool result;
8816 char *kwnames[] = {
8817 NULL
8818 };
8819
8820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8821 {
8822 PyThreadState* __tstate = wxPyBeginAllowThreads();
8823 result = (bool)wxLog::IsEnabled();
8824
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 {
8829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8830 }
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8838 PyObject *resultobj;
8839 bool arg1 = (bool) true ;
8840 bool result;
8841 PyObject * obj0 = 0 ;
8842 char *kwnames[] = {
8843 (char *) "doIt", NULL
8844 };
8845
8846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8847 if (obj0) {
8848 {
8849 arg1 = (bool)(SWIG_As_bool(obj0));
8850 if (SWIG_arg_fail(1)) SWIG_fail;
8851 }
8852 }
8853 {
8854 PyThreadState* __tstate = wxPyBeginAllowThreads();
8855 result = (bool)wxLog::EnableLogging(arg1);
8856
8857 wxPyEndAllowThreads(__tstate);
8858 if (PyErr_Occurred()) SWIG_fail;
8859 }
8860 {
8861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8862 }
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8870 PyObject *resultobj;
8871 wxLogLevel arg1 ;
8872 wxChar *arg2 = (wxChar *) 0 ;
8873 time_t arg3 ;
8874 PyObject * obj0 = 0 ;
8875 PyObject * obj1 = 0 ;
8876 PyObject * obj2 = 0 ;
8877 char *kwnames[] = {
8878 (char *) "level",(char *) "szString",(char *) "t", NULL
8879 };
8880
8881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8882 {
8883 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8884 if (SWIG_arg_fail(1)) SWIG_fail;
8885 }
8886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8887 if (SWIG_arg_fail(2)) SWIG_fail;
8888 {
8889 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8890 if (SWIG_arg_fail(3)) SWIG_fail;
8891 }
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8895
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 Py_INCREF(Py_None); resultobj = Py_None;
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj;
8908 wxLog *arg1 = (wxLog *) 0 ;
8909 PyObject * obj0 = 0 ;
8910 char *kwnames[] = {
8911 (char *) "self", NULL
8912 };
8913
8914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8916 if (SWIG_arg_fail(1)) SWIG_fail;
8917 {
8918 PyThreadState* __tstate = wxPyBeginAllowThreads();
8919 (arg1)->Flush();
8920
8921 wxPyEndAllowThreads(__tstate);
8922 if (PyErr_Occurred()) SWIG_fail;
8923 }
8924 Py_INCREF(Py_None); resultobj = Py_None;
8925 return resultobj;
8926 fail:
8927 return NULL;
8928 }
8929
8930
8931 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8932 PyObject *resultobj;
8933 char *kwnames[] = {
8934 NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8938 {
8939 PyThreadState* __tstate = wxPyBeginAllowThreads();
8940 wxLog::FlushActive();
8941
8942 wxPyEndAllowThreads(__tstate);
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 Py_INCREF(Py_None); resultobj = Py_None;
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8953 PyObject *resultobj;
8954 wxLog *result;
8955 char *kwnames[] = {
8956 NULL
8957 };
8958
8959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8960 {
8961 PyThreadState* __tstate = wxPyBeginAllowThreads();
8962 result = (wxLog *)wxLog::GetActiveTarget();
8963
8964 wxPyEndAllowThreads(__tstate);
8965 if (PyErr_Occurred()) SWIG_fail;
8966 }
8967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxLog *arg1 = (wxLog *) 0 ;
8977 wxLog *result;
8978 PyObject * obj0 = 0 ;
8979 char *kwnames[] = {
8980 (char *) "pLogger", NULL
8981 };
8982
8983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8985 if (SWIG_arg_fail(1)) SWIG_fail;
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8994 return resultobj;
8995 fail:
8996 return NULL;
8997 }
8998
8999
9000 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9001 PyObject *resultobj;
9002 char *kwnames[] = {
9003 NULL
9004 };
9005
9006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 wxLog::Suspend();
9010
9011 wxPyEndAllowThreads(__tstate);
9012 if (PyErr_Occurred()) SWIG_fail;
9013 }
9014 Py_INCREF(Py_None); resultobj = Py_None;
9015 return resultobj;
9016 fail:
9017 return NULL;
9018 }
9019
9020
9021 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9022 PyObject *resultobj;
9023 char *kwnames[] = {
9024 NULL
9025 };
9026
9027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9028 {
9029 PyThreadState* __tstate = wxPyBeginAllowThreads();
9030 wxLog::Resume();
9031
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 Py_INCREF(Py_None); resultobj = Py_None;
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9043 PyObject *resultobj;
9044 bool arg1 = (bool) true ;
9045 PyObject * obj0 = 0 ;
9046 char *kwnames[] = {
9047 (char *) "bVerbose", NULL
9048 };
9049
9050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9051 if (obj0) {
9052 {
9053 arg1 = (bool)(SWIG_As_bool(obj0));
9054 if (SWIG_arg_fail(1)) SWIG_fail;
9055 }
9056 }
9057 {
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 wxLog::SetVerbose(arg1);
9060
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 Py_INCREF(Py_None); resultobj = Py_None;
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9072 PyObject *resultobj;
9073 wxLogLevel arg1 ;
9074 PyObject * obj0 = 0 ;
9075 char *kwnames[] = {
9076 (char *) "logLevel", NULL
9077 };
9078
9079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9080 {
9081 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9082 if (SWIG_arg_fail(1)) SWIG_fail;
9083 }
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 wxLog::SetLogLevel(arg1);
9087
9088 wxPyEndAllowThreads(__tstate);
9089 if (PyErr_Occurred()) SWIG_fail;
9090 }
9091 Py_INCREF(Py_None); resultobj = Py_None;
9092 return resultobj;
9093 fail:
9094 return NULL;
9095 }
9096
9097
9098 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9099 PyObject *resultobj;
9100 char *kwnames[] = {
9101 NULL
9102 };
9103
9104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9105 {
9106 PyThreadState* __tstate = wxPyBeginAllowThreads();
9107 wxLog::DontCreateOnDemand();
9108
9109 wxPyEndAllowThreads(__tstate);
9110 if (PyErr_Occurred()) SWIG_fail;
9111 }
9112 Py_INCREF(Py_None); resultobj = Py_None;
9113 return resultobj;
9114 fail:
9115 return NULL;
9116 }
9117
9118
9119 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9120 PyObject *resultobj;
9121 wxTraceMask arg1 ;
9122 PyObject * obj0 = 0 ;
9123 char *kwnames[] = {
9124 (char *) "ulMask", NULL
9125 };
9126
9127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9128 {
9129 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9130 if (SWIG_arg_fail(1)) SWIG_fail;
9131 }
9132 {
9133 PyThreadState* __tstate = wxPyBeginAllowThreads();
9134 wxLog::SetTraceMask(arg1);
9135
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 Py_INCREF(Py_None); resultobj = Py_None;
9140 return resultobj;
9141 fail:
9142 return NULL;
9143 }
9144
9145
9146 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9147 PyObject *resultobj;
9148 wxString *arg1 = 0 ;
9149 bool temp1 = false ;
9150 PyObject * obj0 = 0 ;
9151 char *kwnames[] = {
9152 (char *) "str", NULL
9153 };
9154
9155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9156 {
9157 arg1 = wxString_in_helper(obj0);
9158 if (arg1 == NULL) SWIG_fail;
9159 temp1 = true;
9160 }
9161 {
9162 PyThreadState* __tstate = wxPyBeginAllowThreads();
9163 wxLog::AddTraceMask((wxString const &)*arg1);
9164
9165 wxPyEndAllowThreads(__tstate);
9166 if (PyErr_Occurred()) SWIG_fail;
9167 }
9168 Py_INCREF(Py_None); resultobj = Py_None;
9169 {
9170 if (temp1)
9171 delete arg1;
9172 }
9173 return resultobj;
9174 fail:
9175 {
9176 if (temp1)
9177 delete arg1;
9178 }
9179 return NULL;
9180 }
9181
9182
9183 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj;
9185 wxString *arg1 = 0 ;
9186 bool temp1 = false ;
9187 PyObject * obj0 = 0 ;
9188 char *kwnames[] = {
9189 (char *) "str", NULL
9190 };
9191
9192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9193 {
9194 arg1 = wxString_in_helper(obj0);
9195 if (arg1 == NULL) SWIG_fail;
9196 temp1 = true;
9197 }
9198 {
9199 PyThreadState* __tstate = wxPyBeginAllowThreads();
9200 wxLog::RemoveTraceMask((wxString const &)*arg1);
9201
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 Py_INCREF(Py_None); resultobj = Py_None;
9206 {
9207 if (temp1)
9208 delete arg1;
9209 }
9210 return resultobj;
9211 fail:
9212 {
9213 if (temp1)
9214 delete arg1;
9215 }
9216 return NULL;
9217 }
9218
9219
9220 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9221 PyObject *resultobj;
9222 char *kwnames[] = {
9223 NULL
9224 };
9225
9226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 wxLog::ClearTraceMasks();
9230
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 Py_INCREF(Py_None); resultobj = Py_None;
9235 return resultobj;
9236 fail:
9237 return NULL;
9238 }
9239
9240
9241 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9242 PyObject *resultobj;
9243 wxArrayString *result;
9244 char *kwnames[] = {
9245 NULL
9246 };
9247
9248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9249 {
9250 PyThreadState* __tstate = wxPyBeginAllowThreads();
9251 {
9252 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9253 result = (wxArrayString *) &_result_ref;
9254 }
9255
9256 wxPyEndAllowThreads(__tstate);
9257 if (PyErr_Occurred()) SWIG_fail;
9258 }
9259 {
9260 resultobj = wxArrayString2PyList_helper(*result);
9261 }
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9269 PyObject *resultobj;
9270 wxChar *arg1 = (wxChar *) 0 ;
9271 PyObject * obj0 = 0 ;
9272 char *kwnames[] = {
9273 (char *) "ts", NULL
9274 };
9275
9276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9278 if (SWIG_arg_fail(1)) SWIG_fail;
9279 {
9280 PyThreadState* __tstate = wxPyBeginAllowThreads();
9281 wxLog::SetTimestamp((wxChar const *)arg1);
9282
9283 wxPyEndAllowThreads(__tstate);
9284 if (PyErr_Occurred()) SWIG_fail;
9285 }
9286 Py_INCREF(Py_None); resultobj = Py_None;
9287 return resultobj;
9288 fail:
9289 return NULL;
9290 }
9291
9292
9293 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9294 PyObject *resultobj;
9295 bool result;
9296 char *kwnames[] = {
9297 NULL
9298 };
9299
9300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9301 {
9302 PyThreadState* __tstate = wxPyBeginAllowThreads();
9303 result = (bool)wxLog::GetVerbose();
9304
9305 wxPyEndAllowThreads(__tstate);
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 {
9309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9310 }
9311 return resultobj;
9312 fail:
9313 return NULL;
9314 }
9315
9316
9317 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9318 PyObject *resultobj;
9319 wxTraceMask result;
9320 char *kwnames[] = {
9321 NULL
9322 };
9323
9324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 result = (wxTraceMask)wxLog::GetTraceMask();
9328
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 {
9333 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9334 }
9335 return resultobj;
9336 fail:
9337 return NULL;
9338 }
9339
9340
9341 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9342 PyObject *resultobj;
9343 wxChar *arg1 = (wxChar *) 0 ;
9344 bool result;
9345 PyObject * obj0 = 0 ;
9346 char *kwnames[] = {
9347 (char *) "mask", NULL
9348 };
9349
9350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9352 if (SWIG_arg_fail(1)) SWIG_fail;
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9356
9357 wxPyEndAllowThreads(__tstate);
9358 if (PyErr_Occurred()) SWIG_fail;
9359 }
9360 {
9361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9362 }
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj;
9371 wxLogLevel result;
9372 char *kwnames[] = {
9373 NULL
9374 };
9375
9376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9377 {
9378 PyThreadState* __tstate = wxPyBeginAllowThreads();
9379 result = (wxLogLevel)wxLog::GetLogLevel();
9380
9381 wxPyEndAllowThreads(__tstate);
9382 if (PyErr_Occurred()) SWIG_fail;
9383 }
9384 {
9385 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9386 }
9387 return resultobj;
9388 fail:
9389 return NULL;
9390 }
9391
9392
9393 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9394 PyObject *resultobj;
9395 wxChar *result;
9396 char *kwnames[] = {
9397 NULL
9398 };
9399
9400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 result = (wxChar *)wxLog::GetTimestamp();
9404
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9416 PyObject *resultobj;
9417 wxString result;
9418 char *kwnames[] = {
9419 NULL
9420 };
9421
9422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9423 {
9424 PyThreadState* __tstate = wxPyBeginAllowThreads();
9425 result = Log_TimeStamp();
9426
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 {
9431 #if wxUSE_UNICODE
9432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9433 #else
9434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9435 #endif
9436 }
9437 return resultobj;
9438 fail:
9439 return NULL;
9440 }
9441
9442
9443 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9444 PyObject *resultobj;
9445 wxLog *arg1 = (wxLog *) 0 ;
9446 PyObject * obj0 = 0 ;
9447 char *kwnames[] = {
9448 (char *) "self", NULL
9449 };
9450
9451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9453 if (SWIG_arg_fail(1)) SWIG_fail;
9454 {
9455 PyThreadState* __tstate = wxPyBeginAllowThreads();
9456 wxLog_Destroy(arg1);
9457
9458 wxPyEndAllowThreads(__tstate);
9459 if (PyErr_Occurred()) SWIG_fail;
9460 }
9461 Py_INCREF(Py_None); resultobj = Py_None;
9462 return resultobj;
9463 fail:
9464 return NULL;
9465 }
9466
9467
9468 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9469 PyObject *obj;
9470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9471 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9472 Py_INCREF(obj);
9473 return Py_BuildValue((char *)"");
9474 }
9475 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9476 PyObject *resultobj;
9477 wxLogStderr *result;
9478 char *kwnames[] = {
9479 NULL
9480 };
9481
9482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9483 {
9484 PyThreadState* __tstate = wxPyBeginAllowThreads();
9485 result = (wxLogStderr *)new wxLogStderr();
9486
9487 wxPyEndAllowThreads(__tstate);
9488 if (PyErr_Occurred()) SWIG_fail;
9489 }
9490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9491 return resultobj;
9492 fail:
9493 return NULL;
9494 }
9495
9496
9497 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9498 PyObject *obj;
9499 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9500 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9501 Py_INCREF(obj);
9502 return Py_BuildValue((char *)"");
9503 }
9504 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj;
9506 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9507 wxLogTextCtrl *result;
9508 PyObject * obj0 = 0 ;
9509 char *kwnames[] = {
9510 (char *) "pTextCtrl", NULL
9511 };
9512
9513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9515 if (SWIG_arg_fail(1)) SWIG_fail;
9516 {
9517 PyThreadState* __tstate = wxPyBeginAllowThreads();
9518 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9519
9520 wxPyEndAllowThreads(__tstate);
9521 if (PyErr_Occurred()) SWIG_fail;
9522 }
9523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9531 PyObject *obj;
9532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9533 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9534 Py_INCREF(obj);
9535 return Py_BuildValue((char *)"");
9536 }
9537 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9538 PyObject *resultobj;
9539 wxLogGui *result;
9540 char *kwnames[] = {
9541 NULL
9542 };
9543
9544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9545 {
9546 PyThreadState* __tstate = wxPyBeginAllowThreads();
9547 result = (wxLogGui *)new wxLogGui();
9548
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9560 PyObject *obj;
9561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9562 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9563 Py_INCREF(obj);
9564 return Py_BuildValue((char *)"");
9565 }
9566 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9567 PyObject *resultobj;
9568 wxFrame *arg1 = (wxFrame *) 0 ;
9569 wxString *arg2 = 0 ;
9570 bool arg3 = (bool) true ;
9571 bool arg4 = (bool) true ;
9572 wxLogWindow *result;
9573 bool temp2 = false ;
9574 PyObject * obj0 = 0 ;
9575 PyObject * obj1 = 0 ;
9576 PyObject * obj2 = 0 ;
9577 PyObject * obj3 = 0 ;
9578 char *kwnames[] = {
9579 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9580 };
9581
9582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9584 if (SWIG_arg_fail(1)) SWIG_fail;
9585 {
9586 arg2 = wxString_in_helper(obj1);
9587 if (arg2 == NULL) SWIG_fail;
9588 temp2 = true;
9589 }
9590 if (obj2) {
9591 {
9592 arg3 = (bool)(SWIG_As_bool(obj2));
9593 if (SWIG_arg_fail(3)) SWIG_fail;
9594 }
9595 }
9596 if (obj3) {
9597 {
9598 arg4 = (bool)(SWIG_As_bool(obj3));
9599 if (SWIG_arg_fail(4)) SWIG_fail;
9600 }
9601 }
9602 {
9603 PyThreadState* __tstate = wxPyBeginAllowThreads();
9604 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9605
9606 wxPyEndAllowThreads(__tstate);
9607 if (PyErr_Occurred()) SWIG_fail;
9608 }
9609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9610 {
9611 if (temp2)
9612 delete arg2;
9613 }
9614 return resultobj;
9615 fail:
9616 {
9617 if (temp2)
9618 delete arg2;
9619 }
9620 return NULL;
9621 }
9622
9623
9624 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9625 PyObject *resultobj;
9626 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9627 bool arg2 = (bool) true ;
9628 PyObject * obj0 = 0 ;
9629 PyObject * obj1 = 0 ;
9630 char *kwnames[] = {
9631 (char *) "self",(char *) "bShow", NULL
9632 };
9633
9634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9636 if (SWIG_arg_fail(1)) SWIG_fail;
9637 if (obj1) {
9638 {
9639 arg2 = (bool)(SWIG_As_bool(obj1));
9640 if (SWIG_arg_fail(2)) SWIG_fail;
9641 }
9642 }
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 (arg1)->Show(arg2);
9646
9647 wxPyEndAllowThreads(__tstate);
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 Py_INCREF(Py_None); resultobj = Py_None;
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj;
9659 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9660 wxFrame *result;
9661 PyObject * obj0 = 0 ;
9662 char *kwnames[] = {
9663 (char *) "self", NULL
9664 };
9665
9666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9668 if (SWIG_arg_fail(1)) SWIG_fail;
9669 {
9670 PyThreadState* __tstate = wxPyBeginAllowThreads();
9671 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9672
9673 wxPyEndAllowThreads(__tstate);
9674 if (PyErr_Occurred()) SWIG_fail;
9675 }
9676 {
9677 resultobj = wxPyMake_wxObject(result, 0);
9678 }
9679 return resultobj;
9680 fail:
9681 return NULL;
9682 }
9683
9684
9685 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj;
9687 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9688 wxLog *result;
9689 PyObject * obj0 = 0 ;
9690 char *kwnames[] = {
9691 (char *) "self", NULL
9692 };
9693
9694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9696 if (SWIG_arg_fail(1)) SWIG_fail;
9697 {
9698 PyThreadState* __tstate = wxPyBeginAllowThreads();
9699 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9700
9701 wxPyEndAllowThreads(__tstate);
9702 if (PyErr_Occurred()) SWIG_fail;
9703 }
9704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9705 return resultobj;
9706 fail:
9707 return NULL;
9708 }
9709
9710
9711 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9712 PyObject *resultobj;
9713 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9714 bool result;
9715 PyObject * obj0 = 0 ;
9716 char *kwnames[] = {
9717 (char *) "self", NULL
9718 };
9719
9720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9722 if (SWIG_arg_fail(1)) SWIG_fail;
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9726
9727 wxPyEndAllowThreads(__tstate);
9728 if (PyErr_Occurred()) SWIG_fail;
9729 }
9730 {
9731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9732 }
9733 return resultobj;
9734 fail:
9735 return NULL;
9736 }
9737
9738
9739 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9740 PyObject *resultobj;
9741 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9742 bool arg2 ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char *kwnames[] = {
9746 (char *) "self",(char *) "bDoPass", NULL
9747 };
9748
9749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9751 if (SWIG_arg_fail(1)) SWIG_fail;
9752 {
9753 arg2 = (bool)(SWIG_As_bool(obj1));
9754 if (SWIG_arg_fail(2)) SWIG_fail;
9755 }
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 (arg1)->PassMessages(arg2);
9759
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 Py_INCREF(Py_None); resultobj = Py_None;
9764 return resultobj;
9765 fail:
9766 return NULL;
9767 }
9768
9769
9770 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9771 PyObject *obj;
9772 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9773 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9774 Py_INCREF(obj);
9775 return Py_BuildValue((char *)"");
9776 }
9777 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9778 PyObject *resultobj;
9779 wxLog *arg1 = (wxLog *) 0 ;
9780 wxLogChain *result;
9781 PyObject * obj0 = 0 ;
9782 char *kwnames[] = {
9783 (char *) "logger", NULL
9784 };
9785
9786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9788 if (SWIG_arg_fail(1)) SWIG_fail;
9789 {
9790 PyThreadState* __tstate = wxPyBeginAllowThreads();
9791 result = (wxLogChain *)new wxLogChain(arg1);
9792
9793 wxPyEndAllowThreads(__tstate);
9794 if (PyErr_Occurred()) SWIG_fail;
9795 }
9796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9797 return resultobj;
9798 fail:
9799 return NULL;
9800 }
9801
9802
9803 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9804 PyObject *resultobj;
9805 wxLogChain *arg1 = (wxLogChain *) 0 ;
9806 wxLog *arg2 = (wxLog *) 0 ;
9807 PyObject * obj0 = 0 ;
9808 PyObject * obj1 = 0 ;
9809 char *kwnames[] = {
9810 (char *) "self",(char *) "logger", NULL
9811 };
9812
9813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9815 if (SWIG_arg_fail(1)) SWIG_fail;
9816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9817 if (SWIG_arg_fail(2)) SWIG_fail;
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 (arg1)->SetLog(arg2);
9821
9822 wxPyEndAllowThreads(__tstate);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 Py_INCREF(Py_None); resultobj = Py_None;
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9833 PyObject *resultobj;
9834 wxLogChain *arg1 = (wxLogChain *) 0 ;
9835 bool arg2 ;
9836 PyObject * obj0 = 0 ;
9837 PyObject * obj1 = 0 ;
9838 char *kwnames[] = {
9839 (char *) "self",(char *) "bDoPass", NULL
9840 };
9841
9842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9844 if (SWIG_arg_fail(1)) SWIG_fail;
9845 {
9846 arg2 = (bool)(SWIG_As_bool(obj1));
9847 if (SWIG_arg_fail(2)) SWIG_fail;
9848 }
9849 {
9850 PyThreadState* __tstate = wxPyBeginAllowThreads();
9851 (arg1)->PassMessages(arg2);
9852
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 Py_INCREF(Py_None); resultobj = Py_None;
9857 return resultobj;
9858 fail:
9859 return NULL;
9860 }
9861
9862
9863 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9864 PyObject *resultobj;
9865 wxLogChain *arg1 = (wxLogChain *) 0 ;
9866 bool result;
9867 PyObject * obj0 = 0 ;
9868 char *kwnames[] = {
9869 (char *) "self", NULL
9870 };
9871
9872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9874 if (SWIG_arg_fail(1)) SWIG_fail;
9875 {
9876 PyThreadState* __tstate = wxPyBeginAllowThreads();
9877 result = (bool)(arg1)->IsPassingMessages();
9878
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 {
9883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9884 }
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9892 PyObject *resultobj;
9893 wxLogChain *arg1 = (wxLogChain *) 0 ;
9894 wxLog *result;
9895 PyObject * obj0 = 0 ;
9896 char *kwnames[] = {
9897 (char *) "self", NULL
9898 };
9899
9900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9902 if (SWIG_arg_fail(1)) SWIG_fail;
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 result = (wxLog *)(arg1)->GetOldLog();
9906
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9918 PyObject *obj;
9919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9920 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9921 Py_INCREF(obj);
9922 return Py_BuildValue((char *)"");
9923 }
9924 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9925 PyObject *resultobj;
9926 unsigned long result;
9927 char *kwnames[] = {
9928 NULL
9929 };
9930
9931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (unsigned long)wxSysErrorCode();
9935
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 {
9940 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9941 }
9942 return resultobj;
9943 fail:
9944 return NULL;
9945 }
9946
9947
9948 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9949 PyObject *resultobj;
9950 unsigned long arg1 = (unsigned long) 0 ;
9951 wxString result;
9952 PyObject * obj0 = 0 ;
9953 char *kwnames[] = {
9954 (char *) "nErrCode", NULL
9955 };
9956
9957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9958 if (obj0) {
9959 {
9960 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9961 if (SWIG_arg_fail(1)) SWIG_fail;
9962 }
9963 }
9964 {
9965 PyThreadState* __tstate = wxPyBeginAllowThreads();
9966 result = wxSysErrorMsg(arg1);
9967
9968 wxPyEndAllowThreads(__tstate);
9969 if (PyErr_Occurred()) SWIG_fail;
9970 }
9971 {
9972 #if wxUSE_UNICODE
9973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9974 #else
9975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9976 #endif
9977 }
9978 return resultobj;
9979 fail:
9980 return NULL;
9981 }
9982
9983
9984 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9985 PyObject *resultobj;
9986 wxString *arg1 = 0 ;
9987 bool temp1 = false ;
9988 PyObject * obj0 = 0 ;
9989 char *kwnames[] = {
9990 (char *) "msg", NULL
9991 };
9992
9993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9994 {
9995 arg1 = wxString_in_helper(obj0);
9996 if (arg1 == NULL) SWIG_fail;
9997 temp1 = true;
9998 }
9999 {
10000 PyThreadState* __tstate = wxPyBeginAllowThreads();
10001 wxPyLogFatalError((wxString const &)*arg1);
10002
10003 wxPyEndAllowThreads(__tstate);
10004 if (PyErr_Occurred()) SWIG_fail;
10005 }
10006 Py_INCREF(Py_None); resultobj = Py_None;
10007 {
10008 if (temp1)
10009 delete arg1;
10010 }
10011 return resultobj;
10012 fail:
10013 {
10014 if (temp1)
10015 delete arg1;
10016 }
10017 return NULL;
10018 }
10019
10020
10021 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj;
10023 wxString *arg1 = 0 ;
10024 bool temp1 = false ;
10025 PyObject * obj0 = 0 ;
10026 char *kwnames[] = {
10027 (char *) "msg", NULL
10028 };
10029
10030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10031 {
10032 arg1 = wxString_in_helper(obj0);
10033 if (arg1 == NULL) SWIG_fail;
10034 temp1 = true;
10035 }
10036 {
10037 PyThreadState* __tstate = wxPyBeginAllowThreads();
10038 wxPyLogError((wxString const &)*arg1);
10039
10040 wxPyEndAllowThreads(__tstate);
10041 if (PyErr_Occurred()) SWIG_fail;
10042 }
10043 Py_INCREF(Py_None); resultobj = Py_None;
10044 {
10045 if (temp1)
10046 delete arg1;
10047 }
10048 return resultobj;
10049 fail:
10050 {
10051 if (temp1)
10052 delete arg1;
10053 }
10054 return NULL;
10055 }
10056
10057
10058 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10059 PyObject *resultobj;
10060 wxString *arg1 = 0 ;
10061 bool temp1 = false ;
10062 PyObject * obj0 = 0 ;
10063 char *kwnames[] = {
10064 (char *) "msg", NULL
10065 };
10066
10067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10068 {
10069 arg1 = wxString_in_helper(obj0);
10070 if (arg1 == NULL) SWIG_fail;
10071 temp1 = true;
10072 }
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 wxPyLogWarning((wxString const &)*arg1);
10076
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 Py_INCREF(Py_None); resultobj = Py_None;
10081 {
10082 if (temp1)
10083 delete arg1;
10084 }
10085 return resultobj;
10086 fail:
10087 {
10088 if (temp1)
10089 delete arg1;
10090 }
10091 return NULL;
10092 }
10093
10094
10095 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj;
10097 wxString *arg1 = 0 ;
10098 bool temp1 = false ;
10099 PyObject * obj0 = 0 ;
10100 char *kwnames[] = {
10101 (char *) "msg", NULL
10102 };
10103
10104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10105 {
10106 arg1 = wxString_in_helper(obj0);
10107 if (arg1 == NULL) SWIG_fail;
10108 temp1 = true;
10109 }
10110 {
10111 PyThreadState* __tstate = wxPyBeginAllowThreads();
10112 wxPyLogMessage((wxString const &)*arg1);
10113
10114 wxPyEndAllowThreads(__tstate);
10115 if (PyErr_Occurred()) SWIG_fail;
10116 }
10117 Py_INCREF(Py_None); resultobj = Py_None;
10118 {
10119 if (temp1)
10120 delete arg1;
10121 }
10122 return resultobj;
10123 fail:
10124 {
10125 if (temp1)
10126 delete arg1;
10127 }
10128 return NULL;
10129 }
10130
10131
10132 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10133 PyObject *resultobj;
10134 wxString *arg1 = 0 ;
10135 bool temp1 = false ;
10136 PyObject * obj0 = 0 ;
10137 char *kwnames[] = {
10138 (char *) "msg", NULL
10139 };
10140
10141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10142 {
10143 arg1 = wxString_in_helper(obj0);
10144 if (arg1 == NULL) SWIG_fail;
10145 temp1 = true;
10146 }
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 wxPyLogInfo((wxString const &)*arg1);
10150
10151 wxPyEndAllowThreads(__tstate);
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 Py_INCREF(Py_None); resultobj = Py_None;
10155 {
10156 if (temp1)
10157 delete arg1;
10158 }
10159 return resultobj;
10160 fail:
10161 {
10162 if (temp1)
10163 delete arg1;
10164 }
10165 return NULL;
10166 }
10167
10168
10169 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10170 PyObject *resultobj;
10171 wxString *arg1 = 0 ;
10172 bool temp1 = false ;
10173 PyObject * obj0 = 0 ;
10174 char *kwnames[] = {
10175 (char *) "msg", NULL
10176 };
10177
10178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10179 {
10180 arg1 = wxString_in_helper(obj0);
10181 if (arg1 == NULL) SWIG_fail;
10182 temp1 = true;
10183 }
10184 {
10185 PyThreadState* __tstate = wxPyBeginAllowThreads();
10186 wxPyLogDebug((wxString const &)*arg1);
10187
10188 wxPyEndAllowThreads(__tstate);
10189 if (PyErr_Occurred()) SWIG_fail;
10190 }
10191 Py_INCREF(Py_None); resultobj = Py_None;
10192 {
10193 if (temp1)
10194 delete arg1;
10195 }
10196 return resultobj;
10197 fail:
10198 {
10199 if (temp1)
10200 delete arg1;
10201 }
10202 return NULL;
10203 }
10204
10205
10206 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj;
10208 wxString *arg1 = 0 ;
10209 bool temp1 = false ;
10210 PyObject * obj0 = 0 ;
10211 char *kwnames[] = {
10212 (char *) "msg", NULL
10213 };
10214
10215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10216 {
10217 arg1 = wxString_in_helper(obj0);
10218 if (arg1 == NULL) SWIG_fail;
10219 temp1 = true;
10220 }
10221 {
10222 PyThreadState* __tstate = wxPyBeginAllowThreads();
10223 wxPyLogVerbose((wxString const &)*arg1);
10224
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 Py_INCREF(Py_None); resultobj = Py_None;
10229 {
10230 if (temp1)
10231 delete arg1;
10232 }
10233 return resultobj;
10234 fail:
10235 {
10236 if (temp1)
10237 delete arg1;
10238 }
10239 return NULL;
10240 }
10241
10242
10243 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10244 PyObject *resultobj;
10245 wxString *arg1 = 0 ;
10246 bool temp1 = false ;
10247 PyObject * obj0 = 0 ;
10248 char *kwnames[] = {
10249 (char *) "msg", NULL
10250 };
10251
10252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10253 {
10254 arg1 = wxString_in_helper(obj0);
10255 if (arg1 == NULL) SWIG_fail;
10256 temp1 = true;
10257 }
10258 {
10259 PyThreadState* __tstate = wxPyBeginAllowThreads();
10260 wxPyLogStatus((wxString const &)*arg1);
10261
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 Py_INCREF(Py_None); resultobj = Py_None;
10266 {
10267 if (temp1)
10268 delete arg1;
10269 }
10270 return resultobj;
10271 fail:
10272 {
10273 if (temp1)
10274 delete arg1;
10275 }
10276 return NULL;
10277 }
10278
10279
10280 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10281 PyObject *resultobj;
10282 wxFrame *arg1 = (wxFrame *) 0 ;
10283 wxString *arg2 = 0 ;
10284 bool temp2 = false ;
10285 PyObject * obj0 = 0 ;
10286 PyObject * obj1 = 0 ;
10287 char *kwnames[] = {
10288 (char *) "pFrame",(char *) "msg", NULL
10289 };
10290
10291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10293 if (SWIG_arg_fail(1)) SWIG_fail;
10294 {
10295 arg2 = wxString_in_helper(obj1);
10296 if (arg2 == NULL) SWIG_fail;
10297 temp2 = true;
10298 }
10299 {
10300 PyThreadState* __tstate = wxPyBeginAllowThreads();
10301 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10302
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 Py_INCREF(Py_None); resultobj = Py_None;
10307 {
10308 if (temp2)
10309 delete arg2;
10310 }
10311 return resultobj;
10312 fail:
10313 {
10314 if (temp2)
10315 delete arg2;
10316 }
10317 return NULL;
10318 }
10319
10320
10321 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10322 PyObject *resultobj;
10323 wxString *arg1 = 0 ;
10324 bool temp1 = false ;
10325 PyObject * obj0 = 0 ;
10326 char *kwnames[] = {
10327 (char *) "msg", NULL
10328 };
10329
10330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10331 {
10332 arg1 = wxString_in_helper(obj0);
10333 if (arg1 == NULL) SWIG_fail;
10334 temp1 = true;
10335 }
10336 {
10337 PyThreadState* __tstate = wxPyBeginAllowThreads();
10338 wxPyLogSysError((wxString const &)*arg1);
10339
10340 wxPyEndAllowThreads(__tstate);
10341 if (PyErr_Occurred()) SWIG_fail;
10342 }
10343 Py_INCREF(Py_None); resultobj = Py_None;
10344 {
10345 if (temp1)
10346 delete arg1;
10347 }
10348 return resultobj;
10349 fail:
10350 {
10351 if (temp1)
10352 delete arg1;
10353 }
10354 return NULL;
10355 }
10356
10357
10358 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj;
10360 unsigned long arg1 ;
10361 wxString *arg2 = 0 ;
10362 bool temp2 = false ;
10363 PyObject * obj0 = 0 ;
10364 PyObject * obj1 = 0 ;
10365 char *kwnames[] = {
10366 (char *) "level",(char *) "msg", NULL
10367 };
10368
10369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10370 {
10371 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10372 if (SWIG_arg_fail(1)) SWIG_fail;
10373 }
10374 {
10375 arg2 = wxString_in_helper(obj1);
10376 if (arg2 == NULL) SWIG_fail;
10377 temp2 = true;
10378 }
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10382
10383 wxPyEndAllowThreads(__tstate);
10384 if (PyErr_Occurred()) SWIG_fail;
10385 }
10386 Py_INCREF(Py_None); resultobj = Py_None;
10387 {
10388 if (temp2)
10389 delete arg2;
10390 }
10391 return resultobj;
10392 fail:
10393 {
10394 if (temp2)
10395 delete arg2;
10396 }
10397 return NULL;
10398 }
10399
10400
10401 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10402 PyObject *resultobj;
10403 unsigned long arg1 ;
10404 wxString *arg2 = 0 ;
10405 bool temp2 = false ;
10406 PyObject * obj0 = 0 ;
10407 PyObject * obj1 = 0 ;
10408
10409 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10410 {
10411 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10412 if (SWIG_arg_fail(1)) SWIG_fail;
10413 }
10414 {
10415 arg2 = wxString_in_helper(obj1);
10416 if (arg2 == NULL) SWIG_fail;
10417 temp2 = true;
10418 }
10419 {
10420 PyThreadState* __tstate = wxPyBeginAllowThreads();
10421 wxPyLogTrace(arg1,(wxString const &)*arg2);
10422
10423 wxPyEndAllowThreads(__tstate);
10424 if (PyErr_Occurred()) SWIG_fail;
10425 }
10426 Py_INCREF(Py_None); resultobj = Py_None;
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return resultobj;
10432 fail:
10433 {
10434 if (temp2)
10435 delete arg2;
10436 }
10437 return NULL;
10438 }
10439
10440
10441 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10442 PyObject *resultobj;
10443 wxString *arg1 = 0 ;
10444 wxString *arg2 = 0 ;
10445 bool temp1 = false ;
10446 bool temp2 = false ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449
10450 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10451 {
10452 arg1 = wxString_in_helper(obj0);
10453 if (arg1 == NULL) SWIG_fail;
10454 temp1 = true;
10455 }
10456 {
10457 arg2 = wxString_in_helper(obj1);
10458 if (arg2 == NULL) SWIG_fail;
10459 temp2 = true;
10460 }
10461 {
10462 PyThreadState* __tstate = wxPyBeginAllowThreads();
10463 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10464
10465 wxPyEndAllowThreads(__tstate);
10466 if (PyErr_Occurred()) SWIG_fail;
10467 }
10468 Py_INCREF(Py_None); resultobj = Py_None;
10469 {
10470 if (temp1)
10471 delete arg1;
10472 }
10473 {
10474 if (temp2)
10475 delete arg2;
10476 }
10477 return resultobj;
10478 fail:
10479 {
10480 if (temp1)
10481 delete arg1;
10482 }
10483 {
10484 if (temp2)
10485 delete arg2;
10486 }
10487 return NULL;
10488 }
10489
10490
10491 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10492 int argc;
10493 PyObject *argv[3];
10494 int ii;
10495
10496 argc = PyObject_Length(args);
10497 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10498 argv[ii] = PyTuple_GetItem(args,ii);
10499 }
10500 if (argc == 2) {
10501 int _v;
10502 {
10503 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10504 }
10505 if (_v) {
10506 {
10507 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10508 }
10509 if (_v) {
10510 return _wrap_LogTrace__SWIG_1(self,args);
10511 }
10512 }
10513 }
10514 if (argc == 2) {
10515 int _v;
10516 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10517 if (_v) {
10518 {
10519 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10520 }
10521 if (_v) {
10522 return _wrap_LogTrace__SWIG_0(self,args);
10523 }
10524 }
10525 }
10526
10527 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10528 return NULL;
10529 }
10530
10531
10532 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10533 PyObject *resultobj;
10534 wxString *arg1 = 0 ;
10535 wxString *arg2 = 0 ;
10536 bool temp1 = false ;
10537 bool temp2 = false ;
10538 PyObject * obj0 = 0 ;
10539 PyObject * obj1 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "title",(char *) "text", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10545 {
10546 arg1 = wxString_in_helper(obj0);
10547 if (arg1 == NULL) SWIG_fail;
10548 temp1 = true;
10549 }
10550 {
10551 arg2 = wxString_in_helper(obj1);
10552 if (arg2 == NULL) SWIG_fail;
10553 temp2 = true;
10554 }
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10558
10559 wxPyEndAllowThreads(__tstate);
10560 if (PyErr_Occurred()) SWIG_fail;
10561 }
10562 Py_INCREF(Py_None); resultobj = Py_None;
10563 {
10564 if (temp1)
10565 delete arg1;
10566 }
10567 {
10568 if (temp2)
10569 delete arg2;
10570 }
10571 return resultobj;
10572 fail:
10573 {
10574 if (temp1)
10575 delete arg1;
10576 }
10577 {
10578 if (temp2)
10579 delete arg2;
10580 }
10581 return NULL;
10582 }
10583
10584
10585 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10586 PyObject *resultobj;
10587 wxLogNull *result;
10588 char *kwnames[] = {
10589 NULL
10590 };
10591
10592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (wxLogNull *)new wxLogNull();
10596
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10601 return resultobj;
10602 fail:
10603 return NULL;
10604 }
10605
10606
10607 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10608 PyObject *resultobj;
10609 wxLogNull *arg1 = (wxLogNull *) 0 ;
10610 PyObject * obj0 = 0 ;
10611 char *kwnames[] = {
10612 (char *) "self", NULL
10613 };
10614
10615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10617 if (SWIG_arg_fail(1)) SWIG_fail;
10618 {
10619 PyThreadState* __tstate = wxPyBeginAllowThreads();
10620 delete arg1;
10621
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 Py_INCREF(Py_None); resultobj = Py_None;
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10633 PyObject *obj;
10634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10635 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10636 Py_INCREF(obj);
10637 return Py_BuildValue((char *)"");
10638 }
10639 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj;
10641 wxPyLog *result;
10642 char *kwnames[] = {
10643 NULL
10644 };
10645
10646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10647 {
10648 PyThreadState* __tstate = wxPyBeginAllowThreads();
10649 result = (wxPyLog *)new wxPyLog();
10650
10651 wxPyEndAllowThreads(__tstate);
10652 if (PyErr_Occurred()) SWIG_fail;
10653 }
10654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10655 return resultobj;
10656 fail:
10657 return NULL;
10658 }
10659
10660
10661 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10662 PyObject *resultobj;
10663 wxPyLog *arg1 = (wxPyLog *) 0 ;
10664 PyObject *arg2 = (PyObject *) 0 ;
10665 PyObject *arg3 = (PyObject *) 0 ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 PyObject * obj2 = 0 ;
10669 char *kwnames[] = {
10670 (char *) "self",(char *) "self",(char *) "_class", NULL
10671 };
10672
10673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10675 if (SWIG_arg_fail(1)) SWIG_fail;
10676 arg2 = obj1;
10677 arg3 = obj2;
10678 {
10679 PyThreadState* __tstate = wxPyBeginAllowThreads();
10680 (arg1)->_setCallbackInfo(arg2,arg3);
10681
10682 wxPyEndAllowThreads(__tstate);
10683 if (PyErr_Occurred()) SWIG_fail;
10684 }
10685 Py_INCREF(Py_None); resultobj = Py_None;
10686 return resultobj;
10687 fail:
10688 return NULL;
10689 }
10690
10691
10692 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10693 PyObject *obj;
10694 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10695 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10696 Py_INCREF(obj);
10697 return Py_BuildValue((char *)"");
10698 }
10699 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10700 PyObject *resultobj;
10701 int arg1 ;
10702 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10703 int arg3 = (int) wxKILL_NOCHILDREN ;
10704 wxKillError result;
10705 PyObject * obj0 = 0 ;
10706 PyObject * obj1 = 0 ;
10707 PyObject * obj2 = 0 ;
10708 char *kwnames[] = {
10709 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10710 };
10711
10712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10713 {
10714 arg1 = (int)(SWIG_As_int(obj0));
10715 if (SWIG_arg_fail(1)) SWIG_fail;
10716 }
10717 if (obj1) {
10718 {
10719 arg2 = (wxSignal)(SWIG_As_int(obj1));
10720 if (SWIG_arg_fail(2)) SWIG_fail;
10721 }
10722 }
10723 if (obj2) {
10724 {
10725 arg3 = (int)(SWIG_As_int(obj2));
10726 if (SWIG_arg_fail(3)) SWIG_fail;
10727 }
10728 }
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10732
10733 wxPyEndAllowThreads(__tstate);
10734 if (PyErr_Occurred()) SWIG_fail;
10735 }
10736 resultobj = SWIG_From_int((result));
10737 return resultobj;
10738 fail:
10739 return NULL;
10740 }
10741
10742
10743 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10744 PyObject *resultobj;
10745 int arg1 ;
10746 bool result;
10747 PyObject * obj0 = 0 ;
10748 char *kwnames[] = {
10749 (char *) "pid", NULL
10750 };
10751
10752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10753 {
10754 arg1 = (int)(SWIG_As_int(obj0));
10755 if (SWIG_arg_fail(1)) SWIG_fail;
10756 }
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 result = (bool)wxPyProcess::Exists(arg1);
10760
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 {
10765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10766 }
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj;
10775 wxString *arg1 = 0 ;
10776 int arg2 = (int) wxEXEC_ASYNC ;
10777 wxPyProcess *result;
10778 bool temp1 = false ;
10779 PyObject * obj0 = 0 ;
10780 PyObject * obj1 = 0 ;
10781 char *kwnames[] = {
10782 (char *) "cmd",(char *) "flags", NULL
10783 };
10784
10785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10786 {
10787 arg1 = wxString_in_helper(obj0);
10788 if (arg1 == NULL) SWIG_fail;
10789 temp1 = true;
10790 }
10791 if (obj1) {
10792 {
10793 arg2 = (int)(SWIG_As_int(obj1));
10794 if (SWIG_arg_fail(2)) SWIG_fail;
10795 }
10796 }
10797 {
10798 PyThreadState* __tstate = wxPyBeginAllowThreads();
10799 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10800
10801 wxPyEndAllowThreads(__tstate);
10802 if (PyErr_Occurred()) SWIG_fail;
10803 }
10804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10805 {
10806 if (temp1)
10807 delete arg1;
10808 }
10809 return resultobj;
10810 fail:
10811 {
10812 if (temp1)
10813 delete arg1;
10814 }
10815 return NULL;
10816 }
10817
10818
10819 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj;
10821 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10822 int arg2 = (int) -1 ;
10823 wxPyProcess *result;
10824 PyObject * obj0 = 0 ;
10825 PyObject * obj1 = 0 ;
10826 char *kwnames[] = {
10827 (char *) "parent",(char *) "id", NULL
10828 };
10829
10830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10831 if (obj0) {
10832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10833 if (SWIG_arg_fail(1)) SWIG_fail;
10834 }
10835 if (obj1) {
10836 {
10837 arg2 = (int)(SWIG_As_int(obj1));
10838 if (SWIG_arg_fail(2)) SWIG_fail;
10839 }
10840 }
10841 {
10842 PyThreadState* __tstate = wxPyBeginAllowThreads();
10843 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10844
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10856 PyObject *resultobj;
10857 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10858 PyObject *arg2 = (PyObject *) 0 ;
10859 PyObject *arg3 = (PyObject *) 0 ;
10860 PyObject * obj0 = 0 ;
10861 PyObject * obj1 = 0 ;
10862 PyObject * obj2 = 0 ;
10863 char *kwnames[] = {
10864 (char *) "self",(char *) "self",(char *) "_class", NULL
10865 };
10866
10867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10869 if (SWIG_arg_fail(1)) SWIG_fail;
10870 arg2 = obj1;
10871 arg3 = obj2;
10872 {
10873 PyThreadState* __tstate = wxPyBeginAllowThreads();
10874 (arg1)->_setCallbackInfo(arg2,arg3);
10875
10876 wxPyEndAllowThreads(__tstate);
10877 if (PyErr_Occurred()) SWIG_fail;
10878 }
10879 Py_INCREF(Py_None); resultobj = Py_None;
10880 return resultobj;
10881 fail:
10882 return NULL;
10883 }
10884
10885
10886 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10887 PyObject *resultobj;
10888 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10889 int arg2 ;
10890 int arg3 ;
10891 PyObject * obj0 = 0 ;
10892 PyObject * obj1 = 0 ;
10893 PyObject * obj2 = 0 ;
10894 char *kwnames[] = {
10895 (char *) "self",(char *) "pid",(char *) "status", NULL
10896 };
10897
10898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10900 if (SWIG_arg_fail(1)) SWIG_fail;
10901 {
10902 arg2 = (int)(SWIG_As_int(obj1));
10903 if (SWIG_arg_fail(2)) SWIG_fail;
10904 }
10905 {
10906 arg3 = (int)(SWIG_As_int(obj2));
10907 if (SWIG_arg_fail(3)) SWIG_fail;
10908 }
10909 {
10910 PyThreadState* __tstate = wxPyBeginAllowThreads();
10911 (arg1)->base_OnTerminate(arg2,arg3);
10912
10913 wxPyEndAllowThreads(__tstate);
10914 if (PyErr_Occurred()) SWIG_fail;
10915 }
10916 Py_INCREF(Py_None); resultobj = Py_None;
10917 return resultobj;
10918 fail:
10919 return NULL;
10920 }
10921
10922
10923 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10924 PyObject *resultobj;
10925 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10926 PyObject * obj0 = 0 ;
10927 char *kwnames[] = {
10928 (char *) "self", NULL
10929 };
10930
10931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10933 if (SWIG_arg_fail(1)) SWIG_fail;
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 (arg1)->Redirect();
10937
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 Py_INCREF(Py_None); resultobj = Py_None;
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj;
10950 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10951 bool result;
10952 PyObject * obj0 = 0 ;
10953 char *kwnames[] = {
10954 (char *) "self", NULL
10955 };
10956
10957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10959 if (SWIG_arg_fail(1)) SWIG_fail;
10960 {
10961 PyThreadState* __tstate = wxPyBeginAllowThreads();
10962 result = (bool)(arg1)->IsRedirected();
10963
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 {
10968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10969 }
10970 return resultobj;
10971 fail:
10972 return NULL;
10973 }
10974
10975
10976 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10977 PyObject *resultobj;
10978 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10979 PyObject * obj0 = 0 ;
10980 char *kwnames[] = {
10981 (char *) "self", NULL
10982 };
10983
10984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10986 if (SWIG_arg_fail(1)) SWIG_fail;
10987 {
10988 PyThreadState* __tstate = wxPyBeginAllowThreads();
10989 (arg1)->Detach();
10990
10991 wxPyEndAllowThreads(__tstate);
10992 if (PyErr_Occurred()) SWIG_fail;
10993 }
10994 Py_INCREF(Py_None); resultobj = Py_None;
10995 return resultobj;
10996 fail:
10997 return NULL;
10998 }
10999
11000
11001 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11002 PyObject *resultobj;
11003 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11004 wxInputStream *result;
11005 PyObject * obj0 = 0 ;
11006 char *kwnames[] = {
11007 (char *) "self", NULL
11008 };
11009
11010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11012 if (SWIG_arg_fail(1)) SWIG_fail;
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 result = (wxInputStream *)(arg1)->GetInputStream();
11016
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 {
11021 wxPyInputStream * _ptr = NULL;
11022
11023 if (result) {
11024 _ptr = new wxPyInputStream(result);
11025 }
11026 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11027 }
11028 return resultobj;
11029 fail:
11030 return NULL;
11031 }
11032
11033
11034 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11035 PyObject *resultobj;
11036 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11037 wxInputStream *result;
11038 PyObject * obj0 = 0 ;
11039 char *kwnames[] = {
11040 (char *) "self", NULL
11041 };
11042
11043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11045 if (SWIG_arg_fail(1)) SWIG_fail;
11046 {
11047 PyThreadState* __tstate = wxPyBeginAllowThreads();
11048 result = (wxInputStream *)(arg1)->GetErrorStream();
11049
11050 wxPyEndAllowThreads(__tstate);
11051 if (PyErr_Occurred()) SWIG_fail;
11052 }
11053 {
11054 wxPyInputStream * _ptr = NULL;
11055
11056 if (result) {
11057 _ptr = new wxPyInputStream(result);
11058 }
11059 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11060 }
11061 return resultobj;
11062 fail:
11063 return NULL;
11064 }
11065
11066
11067 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11068 PyObject *resultobj;
11069 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11070 wxOutputStream *result;
11071 PyObject * obj0 = 0 ;
11072 char *kwnames[] = {
11073 (char *) "self", NULL
11074 };
11075
11076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11078 if (SWIG_arg_fail(1)) SWIG_fail;
11079 {
11080 PyThreadState* __tstate = wxPyBeginAllowThreads();
11081 result = (wxOutputStream *)(arg1)->GetOutputStream();
11082
11083 wxPyEndAllowThreads(__tstate);
11084 if (PyErr_Occurred()) SWIG_fail;
11085 }
11086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11087 return resultobj;
11088 fail:
11089 return NULL;
11090 }
11091
11092
11093 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11094 PyObject *resultobj;
11095 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11096 PyObject * obj0 = 0 ;
11097 char *kwnames[] = {
11098 (char *) "self", NULL
11099 };
11100
11101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11103 if (SWIG_arg_fail(1)) SWIG_fail;
11104 {
11105 PyThreadState* __tstate = wxPyBeginAllowThreads();
11106 (arg1)->CloseOutput();
11107
11108 wxPyEndAllowThreads(__tstate);
11109 if (PyErr_Occurred()) SWIG_fail;
11110 }
11111 Py_INCREF(Py_None); resultobj = Py_None;
11112 return resultobj;
11113 fail:
11114 return NULL;
11115 }
11116
11117
11118 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11119 PyObject *resultobj;
11120 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11121 bool result;
11122 PyObject * obj0 = 0 ;
11123 char *kwnames[] = {
11124 (char *) "self", NULL
11125 };
11126
11127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11129 if (SWIG_arg_fail(1)) SWIG_fail;
11130 {
11131 PyThreadState* __tstate = wxPyBeginAllowThreads();
11132 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11133
11134 wxPyEndAllowThreads(__tstate);
11135 if (PyErr_Occurred()) SWIG_fail;
11136 }
11137 {
11138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11139 }
11140 return resultobj;
11141 fail:
11142 return NULL;
11143 }
11144
11145
11146 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11147 PyObject *resultobj;
11148 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11149 bool result;
11150 PyObject * obj0 = 0 ;
11151 char *kwnames[] = {
11152 (char *) "self", NULL
11153 };
11154
11155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11157 if (SWIG_arg_fail(1)) SWIG_fail;
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 {
11166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11167 }
11168 return resultobj;
11169 fail:
11170 return NULL;
11171 }
11172
11173
11174 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11175 PyObject *resultobj;
11176 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11177 bool result;
11178 PyObject * obj0 = 0 ;
11179 char *kwnames[] = {
11180 (char *) "self", NULL
11181 };
11182
11183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11185 if (SWIG_arg_fail(1)) SWIG_fail;
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11189
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 {
11194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11195 }
11196 return resultobj;
11197 fail:
11198 return NULL;
11199 }
11200
11201
11202 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11203 PyObject *obj;
11204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11205 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11206 Py_INCREF(obj);
11207 return Py_BuildValue((char *)"");
11208 }
11209 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11210 PyObject *resultobj;
11211 int arg1 = (int) 0 ;
11212 int arg2 = (int) 0 ;
11213 int arg3 = (int) 0 ;
11214 wxProcessEvent *result;
11215 PyObject * obj0 = 0 ;
11216 PyObject * obj1 = 0 ;
11217 PyObject * obj2 = 0 ;
11218 char *kwnames[] = {
11219 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11220 };
11221
11222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11223 if (obj0) {
11224 {
11225 arg1 = (int)(SWIG_As_int(obj0));
11226 if (SWIG_arg_fail(1)) SWIG_fail;
11227 }
11228 }
11229 if (obj1) {
11230 {
11231 arg2 = (int)(SWIG_As_int(obj1));
11232 if (SWIG_arg_fail(2)) SWIG_fail;
11233 }
11234 }
11235 if (obj2) {
11236 {
11237 arg3 = (int)(SWIG_As_int(obj2));
11238 if (SWIG_arg_fail(3)) SWIG_fail;
11239 }
11240 }
11241 {
11242 PyThreadState* __tstate = wxPyBeginAllowThreads();
11243 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11244
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11249 return resultobj;
11250 fail:
11251 return NULL;
11252 }
11253
11254
11255 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11256 PyObject *resultobj;
11257 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11258 int result;
11259 PyObject * obj0 = 0 ;
11260 char *kwnames[] = {
11261 (char *) "self", NULL
11262 };
11263
11264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11266 if (SWIG_arg_fail(1)) SWIG_fail;
11267 {
11268 PyThreadState* __tstate = wxPyBeginAllowThreads();
11269 result = (int)(arg1)->GetPid();
11270
11271 wxPyEndAllowThreads(__tstate);
11272 if (PyErr_Occurred()) SWIG_fail;
11273 }
11274 {
11275 resultobj = SWIG_From_int((int)(result));
11276 }
11277 return resultobj;
11278 fail:
11279 return NULL;
11280 }
11281
11282
11283 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11284 PyObject *resultobj;
11285 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11286 int result;
11287 PyObject * obj0 = 0 ;
11288 char *kwnames[] = {
11289 (char *) "self", NULL
11290 };
11291
11292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11294 if (SWIG_arg_fail(1)) SWIG_fail;
11295 {
11296 PyThreadState* __tstate = wxPyBeginAllowThreads();
11297 result = (int)(arg1)->GetExitCode();
11298
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 {
11303 resultobj = SWIG_From_int((int)(result));
11304 }
11305 return resultobj;
11306 fail:
11307 return NULL;
11308 }
11309
11310
11311 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11312 PyObject *resultobj;
11313 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11314 int arg2 ;
11315 PyObject * obj0 = 0 ;
11316 PyObject * obj1 = 0 ;
11317 char *kwnames[] = {
11318 (char *) "self",(char *) "m_pid", NULL
11319 };
11320
11321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11323 if (SWIG_arg_fail(1)) SWIG_fail;
11324 {
11325 arg2 = (int)(SWIG_As_int(obj1));
11326 if (SWIG_arg_fail(2)) SWIG_fail;
11327 }
11328 if (arg1) (arg1)->m_pid = arg2;
11329
11330 Py_INCREF(Py_None); resultobj = Py_None;
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj;
11339 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11340 int result;
11341 PyObject * obj0 = 0 ;
11342 char *kwnames[] = {
11343 (char *) "self", NULL
11344 };
11345
11346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11348 if (SWIG_arg_fail(1)) SWIG_fail;
11349 result = (int) ((arg1)->m_pid);
11350
11351 {
11352 resultobj = SWIG_From_int((int)(result));
11353 }
11354 return resultobj;
11355 fail:
11356 return NULL;
11357 }
11358
11359
11360 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11361 PyObject *resultobj;
11362 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11363 int arg2 ;
11364 PyObject * obj0 = 0 ;
11365 PyObject * obj1 = 0 ;
11366 char *kwnames[] = {
11367 (char *) "self",(char *) "m_exitcode", NULL
11368 };
11369
11370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11372 if (SWIG_arg_fail(1)) SWIG_fail;
11373 {
11374 arg2 = (int)(SWIG_As_int(obj1));
11375 if (SWIG_arg_fail(2)) SWIG_fail;
11376 }
11377 if (arg1) (arg1)->m_exitcode = arg2;
11378
11379 Py_INCREF(Py_None); resultobj = Py_None;
11380 return resultobj;
11381 fail:
11382 return NULL;
11383 }
11384
11385
11386 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11387 PyObject *resultobj;
11388 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11389 int result;
11390 PyObject * obj0 = 0 ;
11391 char *kwnames[] = {
11392 (char *) "self", NULL
11393 };
11394
11395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11397 if (SWIG_arg_fail(1)) SWIG_fail;
11398 result = (int) ((arg1)->m_exitcode);
11399
11400 {
11401 resultobj = SWIG_From_int((int)(result));
11402 }
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11410 PyObject *obj;
11411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11412 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11413 Py_INCREF(obj);
11414 return Py_BuildValue((char *)"");
11415 }
11416 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj;
11418 wxString *arg1 = 0 ;
11419 int arg2 = (int) wxEXEC_ASYNC ;
11420 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11421 long result;
11422 bool temp1 = false ;
11423 PyObject * obj0 = 0 ;
11424 PyObject * obj1 = 0 ;
11425 PyObject * obj2 = 0 ;
11426 char *kwnames[] = {
11427 (char *) "command",(char *) "flags",(char *) "process", NULL
11428 };
11429
11430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11431 {
11432 arg1 = wxString_in_helper(obj0);
11433 if (arg1 == NULL) SWIG_fail;
11434 temp1 = true;
11435 }
11436 if (obj1) {
11437 {
11438 arg2 = (int)(SWIG_As_int(obj1));
11439 if (SWIG_arg_fail(2)) SWIG_fail;
11440 }
11441 }
11442 if (obj2) {
11443 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11444 if (SWIG_arg_fail(3)) SWIG_fail;
11445 }
11446 {
11447 if (!wxPyCheckForApp()) SWIG_fail;
11448 PyThreadState* __tstate = wxPyBeginAllowThreads();
11449 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11450
11451 wxPyEndAllowThreads(__tstate);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 {
11455 resultobj = SWIG_From_long((long)(result));
11456 }
11457 {
11458 if (temp1)
11459 delete arg1;
11460 }
11461 return resultobj;
11462 fail:
11463 {
11464 if (temp1)
11465 delete arg1;
11466 }
11467 return NULL;
11468 }
11469
11470
11471 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj;
11473 long arg1 ;
11474 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11475 wxKillError *arg3 = (wxKillError *) 0 ;
11476 int arg4 = (int) wxKILL_NOCHILDREN ;
11477 int result;
11478 wxKillError temp3 ;
11479 PyObject * obj0 = 0 ;
11480 PyObject * obj1 = 0 ;
11481 PyObject * obj2 = 0 ;
11482 char *kwnames[] = {
11483 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11484 };
11485
11486 {
11487 arg3 = &temp3;
11488 }
11489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11490 {
11491 arg1 = (long)(SWIG_As_long(obj0));
11492 if (SWIG_arg_fail(1)) SWIG_fail;
11493 }
11494 if (obj1) {
11495 {
11496 arg2 = (wxSignal)(SWIG_As_int(obj1));
11497 if (SWIG_arg_fail(2)) SWIG_fail;
11498 }
11499 }
11500 if (obj2) {
11501 {
11502 arg4 = (int)(SWIG_As_int(obj2));
11503 if (SWIG_arg_fail(4)) SWIG_fail;
11504 }
11505 }
11506 {
11507 PyThreadState* __tstate = wxPyBeginAllowThreads();
11508 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11509
11510 wxPyEndAllowThreads(__tstate);
11511 if (PyErr_Occurred()) SWIG_fail;
11512 }
11513 {
11514 resultobj = SWIG_From_int((int)(result));
11515 }
11516 {
11517 PyObject* o;
11518 o = PyInt_FromLong((long) (*arg3));
11519 resultobj = t_output_helper(resultobj, o);
11520 }
11521 return resultobj;
11522 fail:
11523 return NULL;
11524 }
11525
11526
11527 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11528 PyObject *resultobj;
11529 int arg1 = (int) wxJOYSTICK1 ;
11530 wxJoystick *result;
11531 PyObject * obj0 = 0 ;
11532 char *kwnames[] = {
11533 (char *) "joystick", NULL
11534 };
11535
11536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11537 if (obj0) {
11538 {
11539 arg1 = (int)(SWIG_As_int(obj0));
11540 if (SWIG_arg_fail(1)) SWIG_fail;
11541 }
11542 }
11543 {
11544 if (!wxPyCheckForApp()) SWIG_fail;
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 result = (wxJoystick *)new wxJoystick(arg1);
11547
11548 wxPyEndAllowThreads(__tstate);
11549 if (PyErr_Occurred()) SWIG_fail;
11550 }
11551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11552 return resultobj;
11553 fail:
11554 return NULL;
11555 }
11556
11557
11558 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11559 PyObject *resultobj;
11560 wxJoystick *arg1 = (wxJoystick *) 0 ;
11561 PyObject * obj0 = 0 ;
11562 char *kwnames[] = {
11563 (char *) "self", NULL
11564 };
11565
11566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11568 if (SWIG_arg_fail(1)) SWIG_fail;
11569 {
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 delete arg1;
11572
11573 wxPyEndAllowThreads(__tstate);
11574 if (PyErr_Occurred()) SWIG_fail;
11575 }
11576 Py_INCREF(Py_None); resultobj = Py_None;
11577 return resultobj;
11578 fail:
11579 return NULL;
11580 }
11581
11582
11583 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11584 PyObject *resultobj;
11585 wxJoystick *arg1 = (wxJoystick *) 0 ;
11586 wxPoint result;
11587 PyObject * obj0 = 0 ;
11588 char *kwnames[] = {
11589 (char *) "self", NULL
11590 };
11591
11592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11594 if (SWIG_arg_fail(1)) SWIG_fail;
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = (arg1)->GetPosition();
11598
11599 wxPyEndAllowThreads(__tstate);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 }
11602 {
11603 wxPoint * resultptr;
11604 resultptr = new wxPoint((wxPoint &)(result));
11605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11606 }
11607 return resultobj;
11608 fail:
11609 return NULL;
11610 }
11611
11612
11613 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11614 PyObject *resultobj;
11615 wxJoystick *arg1 = (wxJoystick *) 0 ;
11616 int result;
11617 PyObject * obj0 = 0 ;
11618 char *kwnames[] = {
11619 (char *) "self", NULL
11620 };
11621
11622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11624 if (SWIG_arg_fail(1)) SWIG_fail;
11625 {
11626 PyThreadState* __tstate = wxPyBeginAllowThreads();
11627 result = (int)(arg1)->GetZPosition();
11628
11629 wxPyEndAllowThreads(__tstate);
11630 if (PyErr_Occurred()) SWIG_fail;
11631 }
11632 {
11633 resultobj = SWIG_From_int((int)(result));
11634 }
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11642 PyObject *resultobj;
11643 wxJoystick *arg1 = (wxJoystick *) 0 ;
11644 int result;
11645 PyObject * obj0 = 0 ;
11646 char *kwnames[] = {
11647 (char *) "self", NULL
11648 };
11649
11650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11652 if (SWIG_arg_fail(1)) SWIG_fail;
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (int)(arg1)->GetButtonState();
11656
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = SWIG_From_int((int)(result));
11662 }
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11670 PyObject *resultobj;
11671 wxJoystick *arg1 = (wxJoystick *) 0 ;
11672 int result;
11673 PyObject * obj0 = 0 ;
11674 char *kwnames[] = {
11675 (char *) "self", NULL
11676 };
11677
11678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11680 if (SWIG_arg_fail(1)) SWIG_fail;
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (int)(arg1)->GetPOVPosition();
11684
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 {
11689 resultobj = SWIG_From_int((int)(result));
11690 }
11691 return resultobj;
11692 fail:
11693 return NULL;
11694 }
11695
11696
11697 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11698 PyObject *resultobj;
11699 wxJoystick *arg1 = (wxJoystick *) 0 ;
11700 int result;
11701 PyObject * obj0 = 0 ;
11702 char *kwnames[] = {
11703 (char *) "self", NULL
11704 };
11705
11706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11708 if (SWIG_arg_fail(1)) SWIG_fail;
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (int)(arg1)->GetPOVCTSPosition();
11712
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 {
11717 resultobj = SWIG_From_int((int)(result));
11718 }
11719 return resultobj;
11720 fail:
11721 return NULL;
11722 }
11723
11724
11725 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11726 PyObject *resultobj;
11727 wxJoystick *arg1 = (wxJoystick *) 0 ;
11728 int result;
11729 PyObject * obj0 = 0 ;
11730 char *kwnames[] = {
11731 (char *) "self", NULL
11732 };
11733
11734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11736 if (SWIG_arg_fail(1)) SWIG_fail;
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 result = (int)(arg1)->GetRudderPosition();
11740
11741 wxPyEndAllowThreads(__tstate);
11742 if (PyErr_Occurred()) SWIG_fail;
11743 }
11744 {
11745 resultobj = SWIG_From_int((int)(result));
11746 }
11747 return resultobj;
11748 fail:
11749 return NULL;
11750 }
11751
11752
11753 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11754 PyObject *resultobj;
11755 wxJoystick *arg1 = (wxJoystick *) 0 ;
11756 int result;
11757 PyObject * obj0 = 0 ;
11758 char *kwnames[] = {
11759 (char *) "self", NULL
11760 };
11761
11762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11764 if (SWIG_arg_fail(1)) SWIG_fail;
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (int)(arg1)->GetUPosition();
11768
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 resultobj = SWIG_From_int((int)(result));
11774 }
11775 return resultobj;
11776 fail:
11777 return NULL;
11778 }
11779
11780
11781 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11782 PyObject *resultobj;
11783 wxJoystick *arg1 = (wxJoystick *) 0 ;
11784 int result;
11785 PyObject * obj0 = 0 ;
11786 char *kwnames[] = {
11787 (char *) "self", NULL
11788 };
11789
11790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11792 if (SWIG_arg_fail(1)) SWIG_fail;
11793 {
11794 PyThreadState* __tstate = wxPyBeginAllowThreads();
11795 result = (int)(arg1)->GetVPosition();
11796
11797 wxPyEndAllowThreads(__tstate);
11798 if (PyErr_Occurred()) SWIG_fail;
11799 }
11800 {
11801 resultobj = SWIG_From_int((int)(result));
11802 }
11803 return resultobj;
11804 fail:
11805 return NULL;
11806 }
11807
11808
11809 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11810 PyObject *resultobj;
11811 wxJoystick *arg1 = (wxJoystick *) 0 ;
11812 int result;
11813 PyObject * obj0 = 0 ;
11814 char *kwnames[] = {
11815 (char *) "self", NULL
11816 };
11817
11818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11820 if (SWIG_arg_fail(1)) SWIG_fail;
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (int)(arg1)->GetMovementThreshold();
11824
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 {
11829 resultobj = SWIG_From_int((int)(result));
11830 }
11831 return resultobj;
11832 fail:
11833 return NULL;
11834 }
11835
11836
11837 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11838 PyObject *resultobj;
11839 wxJoystick *arg1 = (wxJoystick *) 0 ;
11840 int arg2 ;
11841 PyObject * obj0 = 0 ;
11842 PyObject * obj1 = 0 ;
11843 char *kwnames[] = {
11844 (char *) "self",(char *) "threshold", NULL
11845 };
11846
11847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11849 if (SWIG_arg_fail(1)) SWIG_fail;
11850 {
11851 arg2 = (int)(SWIG_As_int(obj1));
11852 if (SWIG_arg_fail(2)) SWIG_fail;
11853 }
11854 {
11855 PyThreadState* __tstate = wxPyBeginAllowThreads();
11856 (arg1)->SetMovementThreshold(arg2);
11857
11858 wxPyEndAllowThreads(__tstate);
11859 if (PyErr_Occurred()) SWIG_fail;
11860 }
11861 Py_INCREF(Py_None); resultobj = Py_None;
11862 return resultobj;
11863 fail:
11864 return NULL;
11865 }
11866
11867
11868 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj;
11870 wxJoystick *arg1 = (wxJoystick *) 0 ;
11871 bool result;
11872 PyObject * obj0 = 0 ;
11873 char *kwnames[] = {
11874 (char *) "self", NULL
11875 };
11876
11877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11879 if (SWIG_arg_fail(1)) SWIG_fail;
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = (bool)(arg1)->IsOk();
11883
11884 wxPyEndAllowThreads(__tstate);
11885 if (PyErr_Occurred()) SWIG_fail;
11886 }
11887 {
11888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11889 }
11890 return resultobj;
11891 fail:
11892 return NULL;
11893 }
11894
11895
11896 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11897 PyObject *resultobj;
11898 wxJoystick *arg1 = (wxJoystick *) 0 ;
11899 int result;
11900 PyObject * obj0 = 0 ;
11901 char *kwnames[] = {
11902 (char *) "self", NULL
11903 };
11904
11905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11907 if (SWIG_arg_fail(1)) SWIG_fail;
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (int)(arg1)->GetNumberJoysticks();
11911
11912 wxPyEndAllowThreads(__tstate);
11913 if (PyErr_Occurred()) SWIG_fail;
11914 }
11915 {
11916 resultobj = SWIG_From_int((int)(result));
11917 }
11918 return resultobj;
11919 fail:
11920 return NULL;
11921 }
11922
11923
11924 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11925 PyObject *resultobj;
11926 wxJoystick *arg1 = (wxJoystick *) 0 ;
11927 int result;
11928 PyObject * obj0 = 0 ;
11929 char *kwnames[] = {
11930 (char *) "self", NULL
11931 };
11932
11933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11935 if (SWIG_arg_fail(1)) SWIG_fail;
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (int)(arg1)->GetManufacturerId();
11939
11940 wxPyEndAllowThreads(__tstate);
11941 if (PyErr_Occurred()) SWIG_fail;
11942 }
11943 {
11944 resultobj = SWIG_From_int((int)(result));
11945 }
11946 return resultobj;
11947 fail:
11948 return NULL;
11949 }
11950
11951
11952 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11953 PyObject *resultobj;
11954 wxJoystick *arg1 = (wxJoystick *) 0 ;
11955 int result;
11956 PyObject * obj0 = 0 ;
11957 char *kwnames[] = {
11958 (char *) "self", NULL
11959 };
11960
11961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11963 if (SWIG_arg_fail(1)) SWIG_fail;
11964 {
11965 PyThreadState* __tstate = wxPyBeginAllowThreads();
11966 result = (int)(arg1)->GetProductId();
11967
11968 wxPyEndAllowThreads(__tstate);
11969 if (PyErr_Occurred()) SWIG_fail;
11970 }
11971 {
11972 resultobj = SWIG_From_int((int)(result));
11973 }
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11981 PyObject *resultobj;
11982 wxJoystick *arg1 = (wxJoystick *) 0 ;
11983 wxString result;
11984 PyObject * obj0 = 0 ;
11985 char *kwnames[] = {
11986 (char *) "self", NULL
11987 };
11988
11989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11991 if (SWIG_arg_fail(1)) SWIG_fail;
11992 {
11993 PyThreadState* __tstate = wxPyBeginAllowThreads();
11994 result = (arg1)->GetProductName();
11995
11996 wxPyEndAllowThreads(__tstate);
11997 if (PyErr_Occurred()) SWIG_fail;
11998 }
11999 {
12000 #if wxUSE_UNICODE
12001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12002 #else
12003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12004 #endif
12005 }
12006 return resultobj;
12007 fail:
12008 return NULL;
12009 }
12010
12011
12012 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12013 PyObject *resultobj;
12014 wxJoystick *arg1 = (wxJoystick *) 0 ;
12015 int result;
12016 PyObject * obj0 = 0 ;
12017 char *kwnames[] = {
12018 (char *) "self", NULL
12019 };
12020
12021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12023 if (SWIG_arg_fail(1)) SWIG_fail;
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 result = (int)(arg1)->GetXMin();
12027
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 {
12032 resultobj = SWIG_From_int((int)(result));
12033 }
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj;
12042 wxJoystick *arg1 = (wxJoystick *) 0 ;
12043 int result;
12044 PyObject * obj0 = 0 ;
12045 char *kwnames[] = {
12046 (char *) "self", NULL
12047 };
12048
12049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12051 if (SWIG_arg_fail(1)) SWIG_fail;
12052 {
12053 PyThreadState* __tstate = wxPyBeginAllowThreads();
12054 result = (int)(arg1)->GetYMin();
12055
12056 wxPyEndAllowThreads(__tstate);
12057 if (PyErr_Occurred()) SWIG_fail;
12058 }
12059 {
12060 resultobj = SWIG_From_int((int)(result));
12061 }
12062 return resultobj;
12063 fail:
12064 return NULL;
12065 }
12066
12067
12068 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12069 PyObject *resultobj;
12070 wxJoystick *arg1 = (wxJoystick *) 0 ;
12071 int result;
12072 PyObject * obj0 = 0 ;
12073 char *kwnames[] = {
12074 (char *) "self", NULL
12075 };
12076
12077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12079 if (SWIG_arg_fail(1)) SWIG_fail;
12080 {
12081 PyThreadState* __tstate = wxPyBeginAllowThreads();
12082 result = (int)(arg1)->GetZMin();
12083
12084 wxPyEndAllowThreads(__tstate);
12085 if (PyErr_Occurred()) SWIG_fail;
12086 }
12087 {
12088 resultobj = SWIG_From_int((int)(result));
12089 }
12090 return resultobj;
12091 fail:
12092 return NULL;
12093 }
12094
12095
12096 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12097 PyObject *resultobj;
12098 wxJoystick *arg1 = (wxJoystick *) 0 ;
12099 int result;
12100 PyObject * obj0 = 0 ;
12101 char *kwnames[] = {
12102 (char *) "self", NULL
12103 };
12104
12105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12107 if (SWIG_arg_fail(1)) SWIG_fail;
12108 {
12109 PyThreadState* __tstate = wxPyBeginAllowThreads();
12110 result = (int)(arg1)->GetXMax();
12111
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 {
12116 resultobj = SWIG_From_int((int)(result));
12117 }
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12125 PyObject *resultobj;
12126 wxJoystick *arg1 = (wxJoystick *) 0 ;
12127 int result;
12128 PyObject * obj0 = 0 ;
12129 char *kwnames[] = {
12130 (char *) "self", NULL
12131 };
12132
12133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(1)) SWIG_fail;
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (int)(arg1)->GetYMax();
12139
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 resultobj = SWIG_From_int((int)(result));
12145 }
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj;
12154 wxJoystick *arg1 = (wxJoystick *) 0 ;
12155 int result;
12156 PyObject * obj0 = 0 ;
12157 char *kwnames[] = {
12158 (char *) "self", NULL
12159 };
12160
12161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12163 if (SWIG_arg_fail(1)) SWIG_fail;
12164 {
12165 PyThreadState* __tstate = wxPyBeginAllowThreads();
12166 result = (int)(arg1)->GetZMax();
12167
12168 wxPyEndAllowThreads(__tstate);
12169 if (PyErr_Occurred()) SWIG_fail;
12170 }
12171 {
12172 resultobj = SWIG_From_int((int)(result));
12173 }
12174 return resultobj;
12175 fail:
12176 return NULL;
12177 }
12178
12179
12180 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12181 PyObject *resultobj;
12182 wxJoystick *arg1 = (wxJoystick *) 0 ;
12183 int result;
12184 PyObject * obj0 = 0 ;
12185 char *kwnames[] = {
12186 (char *) "self", NULL
12187 };
12188
12189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12191 if (SWIG_arg_fail(1)) SWIG_fail;
12192 {
12193 PyThreadState* __tstate = wxPyBeginAllowThreads();
12194 result = (int)(arg1)->GetNumberButtons();
12195
12196 wxPyEndAllowThreads(__tstate);
12197 if (PyErr_Occurred()) SWIG_fail;
12198 }
12199 {
12200 resultobj = SWIG_From_int((int)(result));
12201 }
12202 return resultobj;
12203 fail:
12204 return NULL;
12205 }
12206
12207
12208 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12209 PyObject *resultobj;
12210 wxJoystick *arg1 = (wxJoystick *) 0 ;
12211 int result;
12212 PyObject * obj0 = 0 ;
12213 char *kwnames[] = {
12214 (char *) "self", NULL
12215 };
12216
12217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12219 if (SWIG_arg_fail(1)) SWIG_fail;
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = (int)(arg1)->GetNumberAxes();
12223
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 {
12228 resultobj = SWIG_From_int((int)(result));
12229 }
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12237 PyObject *resultobj;
12238 wxJoystick *arg1 = (wxJoystick *) 0 ;
12239 int result;
12240 PyObject * obj0 = 0 ;
12241 char *kwnames[] = {
12242 (char *) "self", NULL
12243 };
12244
12245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12247 if (SWIG_arg_fail(1)) SWIG_fail;
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 result = (int)(arg1)->GetMaxButtons();
12251
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 {
12256 resultobj = SWIG_From_int((int)(result));
12257 }
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj;
12266 wxJoystick *arg1 = (wxJoystick *) 0 ;
12267 int result;
12268 PyObject * obj0 = 0 ;
12269 char *kwnames[] = {
12270 (char *) "self", NULL
12271 };
12272
12273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12275 if (SWIG_arg_fail(1)) SWIG_fail;
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 result = (int)(arg1)->GetMaxAxes();
12279
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 {
12284 resultobj = SWIG_From_int((int)(result));
12285 }
12286 return resultobj;
12287 fail:
12288 return NULL;
12289 }
12290
12291
12292 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12293 PyObject *resultobj;
12294 wxJoystick *arg1 = (wxJoystick *) 0 ;
12295 int result;
12296 PyObject * obj0 = 0 ;
12297 char *kwnames[] = {
12298 (char *) "self", NULL
12299 };
12300
12301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12303 if (SWIG_arg_fail(1)) SWIG_fail;
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 result = (int)(arg1)->GetPollingMin();
12307
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 {
12312 resultobj = SWIG_From_int((int)(result));
12313 }
12314 return resultobj;
12315 fail:
12316 return NULL;
12317 }
12318
12319
12320 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12321 PyObject *resultobj;
12322 wxJoystick *arg1 = (wxJoystick *) 0 ;
12323 int result;
12324 PyObject * obj0 = 0 ;
12325 char *kwnames[] = {
12326 (char *) "self", NULL
12327 };
12328
12329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12331 if (SWIG_arg_fail(1)) SWIG_fail;
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 result = (int)(arg1)->GetPollingMax();
12335
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 {
12340 resultobj = SWIG_From_int((int)(result));
12341 }
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12349 PyObject *resultobj;
12350 wxJoystick *arg1 = (wxJoystick *) 0 ;
12351 int result;
12352 PyObject * obj0 = 0 ;
12353 char *kwnames[] = {
12354 (char *) "self", NULL
12355 };
12356
12357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12359 if (SWIG_arg_fail(1)) SWIG_fail;
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (int)(arg1)->GetRudderMin();
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 {
12368 resultobj = SWIG_From_int((int)(result));
12369 }
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj;
12378 wxJoystick *arg1 = (wxJoystick *) 0 ;
12379 int result;
12380 PyObject * obj0 = 0 ;
12381 char *kwnames[] = {
12382 (char *) "self", NULL
12383 };
12384
12385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12387 if (SWIG_arg_fail(1)) SWIG_fail;
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 result = (int)(arg1)->GetRudderMax();
12391
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 {
12396 resultobj = SWIG_From_int((int)(result));
12397 }
12398 return resultobj;
12399 fail:
12400 return NULL;
12401 }
12402
12403
12404 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12405 PyObject *resultobj;
12406 wxJoystick *arg1 = (wxJoystick *) 0 ;
12407 int result;
12408 PyObject * obj0 = 0 ;
12409 char *kwnames[] = {
12410 (char *) "self", NULL
12411 };
12412
12413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12415 if (SWIG_arg_fail(1)) SWIG_fail;
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 result = (int)(arg1)->GetUMin();
12419
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 {
12424 resultobj = SWIG_From_int((int)(result));
12425 }
12426 return resultobj;
12427 fail:
12428 return NULL;
12429 }
12430
12431
12432 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12433 PyObject *resultobj;
12434 wxJoystick *arg1 = (wxJoystick *) 0 ;
12435 int result;
12436 PyObject * obj0 = 0 ;
12437 char *kwnames[] = {
12438 (char *) "self", NULL
12439 };
12440
12441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12443 if (SWIG_arg_fail(1)) SWIG_fail;
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 result = (int)(arg1)->GetUMax();
12447
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 {
12452 resultobj = SWIG_From_int((int)(result));
12453 }
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12461 PyObject *resultobj;
12462 wxJoystick *arg1 = (wxJoystick *) 0 ;
12463 int result;
12464 PyObject * obj0 = 0 ;
12465 char *kwnames[] = {
12466 (char *) "self", NULL
12467 };
12468
12469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12471 if (SWIG_arg_fail(1)) SWIG_fail;
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (int)(arg1)->GetVMin();
12475
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 {
12480 resultobj = SWIG_From_int((int)(result));
12481 }
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj;
12490 wxJoystick *arg1 = (wxJoystick *) 0 ;
12491 int result;
12492 PyObject * obj0 = 0 ;
12493 char *kwnames[] = {
12494 (char *) "self", NULL
12495 };
12496
12497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12499 if (SWIG_arg_fail(1)) SWIG_fail;
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (int)(arg1)->GetVMax();
12503
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 {
12508 resultobj = SWIG_From_int((int)(result));
12509 }
12510 return resultobj;
12511 fail:
12512 return NULL;
12513 }
12514
12515
12516 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12517 PyObject *resultobj;
12518 wxJoystick *arg1 = (wxJoystick *) 0 ;
12519 bool result;
12520 PyObject * obj0 = 0 ;
12521 char *kwnames[] = {
12522 (char *) "self", NULL
12523 };
12524
12525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12527 if (SWIG_arg_fail(1)) SWIG_fail;
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 result = (bool)(arg1)->HasRudder();
12531
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 {
12536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12537 }
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj;
12546 wxJoystick *arg1 = (wxJoystick *) 0 ;
12547 bool result;
12548 PyObject * obj0 = 0 ;
12549 char *kwnames[] = {
12550 (char *) "self", NULL
12551 };
12552
12553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12555 if (SWIG_arg_fail(1)) SWIG_fail;
12556 {
12557 PyThreadState* __tstate = wxPyBeginAllowThreads();
12558 result = (bool)(arg1)->HasZ();
12559
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 {
12564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12565 }
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12573 PyObject *resultobj;
12574 wxJoystick *arg1 = (wxJoystick *) 0 ;
12575 bool result;
12576 PyObject * obj0 = 0 ;
12577 char *kwnames[] = {
12578 (char *) "self", NULL
12579 };
12580
12581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12583 if (SWIG_arg_fail(1)) SWIG_fail;
12584 {
12585 PyThreadState* __tstate = wxPyBeginAllowThreads();
12586 result = (bool)(arg1)->HasU();
12587
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 {
12592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12593 }
12594 return resultobj;
12595 fail:
12596 return NULL;
12597 }
12598
12599
12600 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12601 PyObject *resultobj;
12602 wxJoystick *arg1 = (wxJoystick *) 0 ;
12603 bool result;
12604 PyObject * obj0 = 0 ;
12605 char *kwnames[] = {
12606 (char *) "self", NULL
12607 };
12608
12609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12611 if (SWIG_arg_fail(1)) SWIG_fail;
12612 {
12613 PyThreadState* __tstate = wxPyBeginAllowThreads();
12614 result = (bool)(arg1)->HasV();
12615
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 {
12620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12621 }
12622 return resultobj;
12623 fail:
12624 return NULL;
12625 }
12626
12627
12628 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj;
12630 wxJoystick *arg1 = (wxJoystick *) 0 ;
12631 bool result;
12632 PyObject * obj0 = 0 ;
12633 char *kwnames[] = {
12634 (char *) "self", NULL
12635 };
12636
12637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12639 if (SWIG_arg_fail(1)) SWIG_fail;
12640 {
12641 PyThreadState* __tstate = wxPyBeginAllowThreads();
12642 result = (bool)(arg1)->HasPOV();
12643
12644 wxPyEndAllowThreads(__tstate);
12645 if (PyErr_Occurred()) SWIG_fail;
12646 }
12647 {
12648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12649 }
12650 return resultobj;
12651 fail:
12652 return NULL;
12653 }
12654
12655
12656 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12657 PyObject *resultobj;
12658 wxJoystick *arg1 = (wxJoystick *) 0 ;
12659 bool result;
12660 PyObject * obj0 = 0 ;
12661 char *kwnames[] = {
12662 (char *) "self", NULL
12663 };
12664
12665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12667 if (SWIG_arg_fail(1)) SWIG_fail;
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 result = (bool)(arg1)->HasPOV4Dir();
12671
12672 wxPyEndAllowThreads(__tstate);
12673 if (PyErr_Occurred()) SWIG_fail;
12674 }
12675 {
12676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12677 }
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12685 PyObject *resultobj;
12686 wxJoystick *arg1 = (wxJoystick *) 0 ;
12687 bool result;
12688 PyObject * obj0 = 0 ;
12689 char *kwnames[] = {
12690 (char *) "self", NULL
12691 };
12692
12693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12695 if (SWIG_arg_fail(1)) SWIG_fail;
12696 {
12697 PyThreadState* __tstate = wxPyBeginAllowThreads();
12698 result = (bool)(arg1)->HasPOVCTS();
12699
12700 wxPyEndAllowThreads(__tstate);
12701 if (PyErr_Occurred()) SWIG_fail;
12702 }
12703 {
12704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12705 }
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12713 PyObject *resultobj;
12714 wxJoystick *arg1 = (wxJoystick *) 0 ;
12715 wxWindow *arg2 = (wxWindow *) 0 ;
12716 int arg3 = (int) 0 ;
12717 bool result;
12718 PyObject * obj0 = 0 ;
12719 PyObject * obj1 = 0 ;
12720 PyObject * obj2 = 0 ;
12721 char *kwnames[] = {
12722 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12723 };
12724
12725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12727 if (SWIG_arg_fail(1)) SWIG_fail;
12728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12729 if (SWIG_arg_fail(2)) SWIG_fail;
12730 if (obj2) {
12731 {
12732 arg3 = (int)(SWIG_As_int(obj2));
12733 if (SWIG_arg_fail(3)) SWIG_fail;
12734 }
12735 }
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (bool)(arg1)->SetCapture(arg2,arg3);
12739
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12745 }
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12753 PyObject *resultobj;
12754 wxJoystick *arg1 = (wxJoystick *) 0 ;
12755 bool result;
12756 PyObject * obj0 = 0 ;
12757 char *kwnames[] = {
12758 (char *) "self", NULL
12759 };
12760
12761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12763 if (SWIG_arg_fail(1)) SWIG_fail;
12764 {
12765 PyThreadState* __tstate = wxPyBeginAllowThreads();
12766 result = (bool)(arg1)->ReleaseCapture();
12767
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 {
12772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12773 }
12774 return resultobj;
12775 fail:
12776 return NULL;
12777 }
12778
12779
12780 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12781 PyObject *obj;
12782 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12783 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12784 Py_INCREF(obj);
12785 return Py_BuildValue((char *)"");
12786 }
12787 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12788 PyObject *resultobj;
12789 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12790 int arg2 = (int) 0 ;
12791 int arg3 = (int) wxJOYSTICK1 ;
12792 int arg4 = (int) 0 ;
12793 wxJoystickEvent *result;
12794 PyObject * obj0 = 0 ;
12795 PyObject * obj1 = 0 ;
12796 PyObject * obj2 = 0 ;
12797 PyObject * obj3 = 0 ;
12798 char *kwnames[] = {
12799 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12800 };
12801
12802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12803 if (obj0) {
12804 {
12805 arg1 = (wxEventType)(SWIG_As_int(obj0));
12806 if (SWIG_arg_fail(1)) SWIG_fail;
12807 }
12808 }
12809 if (obj1) {
12810 {
12811 arg2 = (int)(SWIG_As_int(obj1));
12812 if (SWIG_arg_fail(2)) SWIG_fail;
12813 }
12814 }
12815 if (obj2) {
12816 {
12817 arg3 = (int)(SWIG_As_int(obj2));
12818 if (SWIG_arg_fail(3)) SWIG_fail;
12819 }
12820 }
12821 if (obj3) {
12822 {
12823 arg4 = (int)(SWIG_As_int(obj3));
12824 if (SWIG_arg_fail(4)) SWIG_fail;
12825 }
12826 }
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12830
12831 wxPyEndAllowThreads(__tstate);
12832 if (PyErr_Occurred()) SWIG_fail;
12833 }
12834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12835 return resultobj;
12836 fail:
12837 return NULL;
12838 }
12839
12840
12841 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12842 PyObject *resultobj;
12843 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12844 wxPoint result;
12845 PyObject * obj0 = 0 ;
12846 char *kwnames[] = {
12847 (char *) "self", NULL
12848 };
12849
12850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12852 if (SWIG_arg_fail(1)) SWIG_fail;
12853 {
12854 PyThreadState* __tstate = wxPyBeginAllowThreads();
12855 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12856
12857 wxPyEndAllowThreads(__tstate);
12858 if (PyErr_Occurred()) SWIG_fail;
12859 }
12860 {
12861 wxPoint * resultptr;
12862 resultptr = new wxPoint((wxPoint &)(result));
12863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12864 }
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12874 int result;
12875 PyObject * obj0 = 0 ;
12876 char *kwnames[] = {
12877 (char *) "self", NULL
12878 };
12879
12880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12882 if (SWIG_arg_fail(1)) SWIG_fail;
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12886
12887 wxPyEndAllowThreads(__tstate);
12888 if (PyErr_Occurred()) SWIG_fail;
12889 }
12890 {
12891 resultobj = SWIG_From_int((int)(result));
12892 }
12893 return resultobj;
12894 fail:
12895 return NULL;
12896 }
12897
12898
12899 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12900 PyObject *resultobj;
12901 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12902 int result;
12903 PyObject * obj0 = 0 ;
12904 char *kwnames[] = {
12905 (char *) "self", NULL
12906 };
12907
12908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12910 if (SWIG_arg_fail(1)) SWIG_fail;
12911 {
12912 PyThreadState* __tstate = wxPyBeginAllowThreads();
12913 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12914
12915 wxPyEndAllowThreads(__tstate);
12916 if (PyErr_Occurred()) SWIG_fail;
12917 }
12918 {
12919 resultobj = SWIG_From_int((int)(result));
12920 }
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj;
12929 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12930 int result;
12931 PyObject * obj0 = 0 ;
12932 char *kwnames[] = {
12933 (char *) "self", NULL
12934 };
12935
12936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12938 if (SWIG_arg_fail(1)) SWIG_fail;
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12942
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 resultobj = SWIG_From_int((int)(result));
12948 }
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj;
12957 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12958 int result;
12959 PyObject * obj0 = 0 ;
12960 char *kwnames[] = {
12961 (char *) "self", NULL
12962 };
12963
12964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12966 if (SWIG_arg_fail(1)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 resultobj = SWIG_From_int((int)(result));
12976 }
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj;
12985 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12986 int arg2 ;
12987 PyObject * obj0 = 0 ;
12988 PyObject * obj1 = 0 ;
12989 char *kwnames[] = {
12990 (char *) "self",(char *) "stick", NULL
12991 };
12992
12993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12995 if (SWIG_arg_fail(1)) SWIG_fail;
12996 {
12997 arg2 = (int)(SWIG_As_int(obj1));
12998 if (SWIG_arg_fail(2)) SWIG_fail;
12999 }
13000 {
13001 PyThreadState* __tstate = wxPyBeginAllowThreads();
13002 (arg1)->SetJoystick(arg2);
13003
13004 wxPyEndAllowThreads(__tstate);
13005 if (PyErr_Occurred()) SWIG_fail;
13006 }
13007 Py_INCREF(Py_None); resultobj = Py_None;
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13015 PyObject *resultobj;
13016 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13017 int arg2 ;
13018 PyObject * obj0 = 0 ;
13019 PyObject * obj1 = 0 ;
13020 char *kwnames[] = {
13021 (char *) "self",(char *) "state", NULL
13022 };
13023
13024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13026 if (SWIG_arg_fail(1)) SWIG_fail;
13027 {
13028 arg2 = (int)(SWIG_As_int(obj1));
13029 if (SWIG_arg_fail(2)) SWIG_fail;
13030 }
13031 {
13032 PyThreadState* __tstate = wxPyBeginAllowThreads();
13033 (arg1)->SetButtonState(arg2);
13034
13035 wxPyEndAllowThreads(__tstate);
13036 if (PyErr_Occurred()) SWIG_fail;
13037 }
13038 Py_INCREF(Py_None); resultobj = Py_None;
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13046 PyObject *resultobj;
13047 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13048 int arg2 ;
13049 PyObject * obj0 = 0 ;
13050 PyObject * obj1 = 0 ;
13051 char *kwnames[] = {
13052 (char *) "self",(char *) "change", NULL
13053 };
13054
13055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13057 if (SWIG_arg_fail(1)) SWIG_fail;
13058 {
13059 arg2 = (int)(SWIG_As_int(obj1));
13060 if (SWIG_arg_fail(2)) SWIG_fail;
13061 }
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 (arg1)->SetButtonChange(arg2);
13065
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 Py_INCREF(Py_None); resultobj = Py_None;
13070 return resultobj;
13071 fail:
13072 return NULL;
13073 }
13074
13075
13076 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13077 PyObject *resultobj;
13078 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13079 wxPoint *arg2 = 0 ;
13080 wxPoint temp2 ;
13081 PyObject * obj0 = 0 ;
13082 PyObject * obj1 = 0 ;
13083 char *kwnames[] = {
13084 (char *) "self",(char *) "pos", NULL
13085 };
13086
13087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13089 if (SWIG_arg_fail(1)) SWIG_fail;
13090 {
13091 arg2 = &temp2;
13092 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13093 }
13094 {
13095 PyThreadState* __tstate = wxPyBeginAllowThreads();
13096 (arg1)->SetPosition((wxPoint const &)*arg2);
13097
13098 wxPyEndAllowThreads(__tstate);
13099 if (PyErr_Occurred()) SWIG_fail;
13100 }
13101 Py_INCREF(Py_None); resultobj = Py_None;
13102 return resultobj;
13103 fail:
13104 return NULL;
13105 }
13106
13107
13108 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13109 PyObject *resultobj;
13110 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13111 int arg2 ;
13112 PyObject * obj0 = 0 ;
13113 PyObject * obj1 = 0 ;
13114 char *kwnames[] = {
13115 (char *) "self",(char *) "zPos", NULL
13116 };
13117
13118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13120 if (SWIG_arg_fail(1)) SWIG_fail;
13121 {
13122 arg2 = (int)(SWIG_As_int(obj1));
13123 if (SWIG_arg_fail(2)) SWIG_fail;
13124 }
13125 {
13126 PyThreadState* __tstate = wxPyBeginAllowThreads();
13127 (arg1)->SetZPosition(arg2);
13128
13129 wxPyEndAllowThreads(__tstate);
13130 if (PyErr_Occurred()) SWIG_fail;
13131 }
13132 Py_INCREF(Py_None); resultobj = Py_None;
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13142 bool result;
13143 PyObject * obj0 = 0 ;
13144 char *kwnames[] = {
13145 (char *) "self", NULL
13146 };
13147
13148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) 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 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13154
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 {
13159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13160 }
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj;
13169 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13170 bool result;
13171 PyObject * obj0 = 0 ;
13172 char *kwnames[] = {
13173 (char *) "self", NULL
13174 };
13175
13176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13178 if (SWIG_arg_fail(1)) SWIG_fail;
13179 {
13180 PyThreadState* __tstate = wxPyBeginAllowThreads();
13181 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13182
13183 wxPyEndAllowThreads(__tstate);
13184 if (PyErr_Occurred()) SWIG_fail;
13185 }
13186 {
13187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13188 }
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj;
13197 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13198 bool result;
13199 PyObject * obj0 = 0 ;
13200 char *kwnames[] = {
13201 (char *) "self", NULL
13202 };
13203
13204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13206 if (SWIG_arg_fail(1)) SWIG_fail;
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13210
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 {
13215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13216 }
13217 return resultobj;
13218 fail:
13219 return NULL;
13220 }
13221
13222
13223 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13224 PyObject *resultobj;
13225 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13226 int arg2 = (int) wxJOY_BUTTON_ANY ;
13227 bool result;
13228 PyObject * obj0 = 0 ;
13229 PyObject * obj1 = 0 ;
13230 char *kwnames[] = {
13231 (char *) "self",(char *) "but", NULL
13232 };
13233
13234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13236 if (SWIG_arg_fail(1)) SWIG_fail;
13237 if (obj1) {
13238 {
13239 arg2 = (int)(SWIG_As_int(obj1));
13240 if (SWIG_arg_fail(2)) SWIG_fail;
13241 }
13242 }
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13246
13247 wxPyEndAllowThreads(__tstate);
13248 if (PyErr_Occurred()) SWIG_fail;
13249 }
13250 {
13251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13252 }
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13260 PyObject *resultobj;
13261 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13262 int arg2 = (int) wxJOY_BUTTON_ANY ;
13263 bool result;
13264 PyObject * obj0 = 0 ;
13265 PyObject * obj1 = 0 ;
13266 char *kwnames[] = {
13267 (char *) "self",(char *) "but", NULL
13268 };
13269
13270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13272 if (SWIG_arg_fail(1)) SWIG_fail;
13273 if (obj1) {
13274 {
13275 arg2 = (int)(SWIG_As_int(obj1));
13276 if (SWIG_arg_fail(2)) SWIG_fail;
13277 }
13278 }
13279 {
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13282
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 {
13287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13288 }
13289 return resultobj;
13290 fail:
13291 return NULL;
13292 }
13293
13294
13295 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13296 PyObject *resultobj;
13297 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13298 int arg2 = (int) wxJOY_BUTTON_ANY ;
13299 bool result;
13300 PyObject * obj0 = 0 ;
13301 PyObject * obj1 = 0 ;
13302 char *kwnames[] = {
13303 (char *) "self",(char *) "but", NULL
13304 };
13305
13306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13308 if (SWIG_arg_fail(1)) SWIG_fail;
13309 if (obj1) {
13310 {
13311 arg2 = (int)(SWIG_As_int(obj1));
13312 if (SWIG_arg_fail(2)) SWIG_fail;
13313 }
13314 }
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13318
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 {
13323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13324 }
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13332 PyObject *obj;
13333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13334 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13335 Py_INCREF(obj);
13336 return Py_BuildValue((char *)"");
13337 }
13338 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13339 PyObject *resultobj;
13340 wxString const &arg1_defvalue = wxPyEmptyString ;
13341 wxString *arg1 = (wxString *) &arg1_defvalue ;
13342 wxSound *result;
13343 bool temp1 = false ;
13344 PyObject * obj0 = 0 ;
13345 char *kwnames[] = {
13346 (char *) "fileName", NULL
13347 };
13348
13349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13350 if (obj0) {
13351 {
13352 arg1 = wxString_in_helper(obj0);
13353 if (arg1 == NULL) SWIG_fail;
13354 temp1 = true;
13355 }
13356 }
13357 {
13358 if (!wxPyCheckForApp()) SWIG_fail;
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13361
13362 wxPyEndAllowThreads(__tstate);
13363 if (PyErr_Occurred()) SWIG_fail;
13364 }
13365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13366 {
13367 if (temp1)
13368 delete arg1;
13369 }
13370 return resultobj;
13371 fail:
13372 {
13373 if (temp1)
13374 delete arg1;
13375 }
13376 return NULL;
13377 }
13378
13379
13380 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13381 PyObject *resultobj;
13382 PyObject *arg1 = (PyObject *) 0 ;
13383 wxSound *result;
13384 PyObject * obj0 = 0 ;
13385 char *kwnames[] = {
13386 (char *) "data", NULL
13387 };
13388
13389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13390 arg1 = obj0;
13391 {
13392 if (!wxPyCheckForApp()) SWIG_fail;
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 result = (wxSound *)new_wxSound(arg1);
13395
13396 wxPyEndAllowThreads(__tstate);
13397 if (PyErr_Occurred()) SWIG_fail;
13398 }
13399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13400 return resultobj;
13401 fail:
13402 return NULL;
13403 }
13404
13405
13406 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13407 PyObject *resultobj;
13408 wxSound *arg1 = (wxSound *) 0 ;
13409 PyObject * obj0 = 0 ;
13410 char *kwnames[] = {
13411 (char *) "self", NULL
13412 };
13413
13414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13416 if (SWIG_arg_fail(1)) SWIG_fail;
13417 {
13418 PyThreadState* __tstate = wxPyBeginAllowThreads();
13419 delete arg1;
13420
13421 wxPyEndAllowThreads(__tstate);
13422 if (PyErr_Occurred()) SWIG_fail;
13423 }
13424 Py_INCREF(Py_None); resultobj = Py_None;
13425 return resultobj;
13426 fail:
13427 return NULL;
13428 }
13429
13430
13431 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13432 PyObject *resultobj;
13433 wxSound *arg1 = (wxSound *) 0 ;
13434 wxString *arg2 = 0 ;
13435 bool result;
13436 bool temp2 = false ;
13437 PyObject * obj0 = 0 ;
13438 PyObject * obj1 = 0 ;
13439 char *kwnames[] = {
13440 (char *) "self",(char *) "fileName", NULL
13441 };
13442
13443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13445 if (SWIG_arg_fail(1)) SWIG_fail;
13446 {
13447 arg2 = wxString_in_helper(obj1);
13448 if (arg2 == NULL) SWIG_fail;
13449 temp2 = true;
13450 }
13451 {
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 result = (bool)(arg1)->Create((wxString const &)*arg2);
13454
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 {
13459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13460 }
13461 {
13462 if (temp2)
13463 delete arg2;
13464 }
13465 return resultobj;
13466 fail:
13467 {
13468 if (temp2)
13469 delete arg2;
13470 }
13471 return NULL;
13472 }
13473
13474
13475 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13476 PyObject *resultobj;
13477 wxSound *arg1 = (wxSound *) 0 ;
13478 PyObject *arg2 = (PyObject *) 0 ;
13479 bool result;
13480 PyObject * obj0 = 0 ;
13481 PyObject * obj1 = 0 ;
13482 char *kwnames[] = {
13483 (char *) "self",(char *) "data", NULL
13484 };
13485
13486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13488 if (SWIG_arg_fail(1)) SWIG_fail;
13489 arg2 = obj1;
13490 {
13491 PyThreadState* __tstate = wxPyBeginAllowThreads();
13492 result = (bool)wxSound_CreateFromData(arg1,arg2);
13493
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 {
13498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13499 }
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj;
13508 wxSound *arg1 = (wxSound *) 0 ;
13509 bool result;
13510 PyObject * obj0 = 0 ;
13511 char *kwnames[] = {
13512 (char *) "self", NULL
13513 };
13514
13515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13517 if (SWIG_arg_fail(1)) SWIG_fail;
13518 {
13519 PyThreadState* __tstate = wxPyBeginAllowThreads();
13520 result = (bool)(arg1)->IsOk();
13521
13522 wxPyEndAllowThreads(__tstate);
13523 if (PyErr_Occurred()) SWIG_fail;
13524 }
13525 {
13526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13527 }
13528 return resultobj;
13529 fail:
13530 return NULL;
13531 }
13532
13533
13534 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13535 PyObject *resultobj;
13536 wxSound *arg1 = (wxSound *) 0 ;
13537 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13538 bool result;
13539 PyObject * obj0 = 0 ;
13540 PyObject * obj1 = 0 ;
13541 char *kwnames[] = {
13542 (char *) "self",(char *) "flags", NULL
13543 };
13544
13545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13547 if (SWIG_arg_fail(1)) SWIG_fail;
13548 if (obj1) {
13549 {
13550 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13551 if (SWIG_arg_fail(2)) SWIG_fail;
13552 }
13553 }
13554 {
13555 if (!wxPyCheckForApp()) SWIG_fail;
13556 PyThreadState* __tstate = wxPyBeginAllowThreads();
13557 result = (bool)((wxSound const *)arg1)->Play(arg2);
13558
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 {
13563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13564 }
13565 return resultobj;
13566 fail:
13567 return NULL;
13568 }
13569
13570
13571 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj;
13573 wxString *arg1 = 0 ;
13574 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13575 bool result;
13576 bool temp1 = false ;
13577 PyObject * obj0 = 0 ;
13578 PyObject * obj1 = 0 ;
13579 char *kwnames[] = {
13580 (char *) "filename",(char *) "flags", NULL
13581 };
13582
13583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13584 {
13585 arg1 = wxString_in_helper(obj0);
13586 if (arg1 == NULL) SWIG_fail;
13587 temp1 = true;
13588 }
13589 if (obj1) {
13590 {
13591 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13592 if (SWIG_arg_fail(2)) SWIG_fail;
13593 }
13594 }
13595 {
13596 if (!wxPyCheckForApp()) SWIG_fail;
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13599
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 {
13604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13605 }
13606 {
13607 if (temp1)
13608 delete arg1;
13609 }
13610 return resultobj;
13611 fail:
13612 {
13613 if (temp1)
13614 delete arg1;
13615 }
13616 return NULL;
13617 }
13618
13619
13620 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13621 PyObject *resultobj;
13622 char *kwnames[] = {
13623 NULL
13624 };
13625
13626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13627 {
13628 if (!wxPyCheckForApp()) SWIG_fail;
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 wxSound::Stop();
13631
13632 wxPyEndAllowThreads(__tstate);
13633 if (PyErr_Occurred()) SWIG_fail;
13634 }
13635 Py_INCREF(Py_None); resultobj = Py_None;
13636 return resultobj;
13637 fail:
13638 return NULL;
13639 }
13640
13641
13642 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13643 PyObject *obj;
13644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13645 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13646 Py_INCREF(obj);
13647 return Py_BuildValue((char *)"");
13648 }
13649 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj;
13651 wxString *arg1 = 0 ;
13652 wxString *arg2 = 0 ;
13653 wxString *arg3 = 0 ;
13654 wxString *arg4 = 0 ;
13655 wxFileTypeInfo *result;
13656 bool temp1 = false ;
13657 bool temp2 = false ;
13658 bool temp3 = false ;
13659 bool temp4 = false ;
13660 PyObject * obj0 = 0 ;
13661 PyObject * obj1 = 0 ;
13662 PyObject * obj2 = 0 ;
13663 PyObject * obj3 = 0 ;
13664 char *kwnames[] = {
13665 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13666 };
13667
13668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13669 {
13670 arg1 = wxString_in_helper(obj0);
13671 if (arg1 == NULL) SWIG_fail;
13672 temp1 = true;
13673 }
13674 {
13675 arg2 = wxString_in_helper(obj1);
13676 if (arg2 == NULL) SWIG_fail;
13677 temp2 = true;
13678 }
13679 {
13680 arg3 = wxString_in_helper(obj2);
13681 if (arg3 == NULL) SWIG_fail;
13682 temp3 = true;
13683 }
13684 {
13685 arg4 = wxString_in_helper(obj3);
13686 if (arg4 == NULL) SWIG_fail;
13687 temp4 = true;
13688 }
13689 {
13690 PyThreadState* __tstate = wxPyBeginAllowThreads();
13691 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13692
13693 wxPyEndAllowThreads(__tstate);
13694 if (PyErr_Occurred()) SWIG_fail;
13695 }
13696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13697 {
13698 if (temp1)
13699 delete arg1;
13700 }
13701 {
13702 if (temp2)
13703 delete arg2;
13704 }
13705 {
13706 if (temp3)
13707 delete arg3;
13708 }
13709 {
13710 if (temp4)
13711 delete arg4;
13712 }
13713 return resultobj;
13714 fail:
13715 {
13716 if (temp1)
13717 delete arg1;
13718 }
13719 {
13720 if (temp2)
13721 delete arg2;
13722 }
13723 {
13724 if (temp3)
13725 delete arg3;
13726 }
13727 {
13728 if (temp4)
13729 delete arg4;
13730 }
13731 return NULL;
13732 }
13733
13734
13735 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13736 PyObject *resultobj;
13737 wxArrayString *arg1 = 0 ;
13738 wxFileTypeInfo *result;
13739 bool temp1 = false ;
13740 PyObject * obj0 = 0 ;
13741 char *kwnames[] = {
13742 (char *) "sArray", NULL
13743 };
13744
13745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13746 {
13747 if (! PySequence_Check(obj0)) {
13748 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13749 SWIG_fail;
13750 }
13751 arg1 = new wxArrayString;
13752 temp1 = true;
13753 int i, len=PySequence_Length(obj0);
13754 for (i=0; i<len; i++) {
13755 PyObject* item = PySequence_GetItem(obj0, i);
13756 #if wxUSE_UNICODE
13757 PyObject* str = PyObject_Unicode(item);
13758 #else
13759 PyObject* str = PyObject_Str(item);
13760 #endif
13761 if (PyErr_Occurred()) SWIG_fail;
13762 arg1->Add(Py2wxString(str));
13763 Py_DECREF(item);
13764 Py_DECREF(str);
13765 }
13766 }
13767 {
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13775 {
13776 if (temp1) delete arg1;
13777 }
13778 return resultobj;
13779 fail:
13780 {
13781 if (temp1) delete arg1;
13782 }
13783 return NULL;
13784 }
13785
13786
13787 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13788 PyObject *resultobj;
13789 wxFileTypeInfo *result;
13790 char *kwnames[] = {
13791 NULL
13792 };
13793
13794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13795 {
13796 PyThreadState* __tstate = wxPyBeginAllowThreads();
13797 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13798
13799 wxPyEndAllowThreads(__tstate);
13800 if (PyErr_Occurred()) SWIG_fail;
13801 }
13802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13803 return resultobj;
13804 fail:
13805 return NULL;
13806 }
13807
13808
13809 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13810 PyObject *resultobj;
13811 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13812 bool result;
13813 PyObject * obj0 = 0 ;
13814 char *kwnames[] = {
13815 (char *) "self", NULL
13816 };
13817
13818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13820 if (SWIG_arg_fail(1)) SWIG_fail;
13821 {
13822 PyThreadState* __tstate = wxPyBeginAllowThreads();
13823 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13824
13825 wxPyEndAllowThreads(__tstate);
13826 if (PyErr_Occurred()) SWIG_fail;
13827 }
13828 {
13829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13830 }
13831 return resultobj;
13832 fail:
13833 return NULL;
13834 }
13835
13836
13837 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13838 PyObject *resultobj;
13839 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13840 wxString *arg2 = 0 ;
13841 int arg3 = (int) 0 ;
13842 bool temp2 = false ;
13843 PyObject * obj0 = 0 ;
13844 PyObject * obj1 = 0 ;
13845 PyObject * obj2 = 0 ;
13846 char *kwnames[] = {
13847 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13848 };
13849
13850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13852 if (SWIG_arg_fail(1)) SWIG_fail;
13853 {
13854 arg2 = wxString_in_helper(obj1);
13855 if (arg2 == NULL) SWIG_fail;
13856 temp2 = true;
13857 }
13858 if (obj2) {
13859 {
13860 arg3 = (int)(SWIG_As_int(obj2));
13861 if (SWIG_arg_fail(3)) SWIG_fail;
13862 }
13863 }
13864 {
13865 PyThreadState* __tstate = wxPyBeginAllowThreads();
13866 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13867
13868 wxPyEndAllowThreads(__tstate);
13869 if (PyErr_Occurred()) SWIG_fail;
13870 }
13871 Py_INCREF(Py_None); resultobj = Py_None;
13872 {
13873 if (temp2)
13874 delete arg2;
13875 }
13876 return resultobj;
13877 fail:
13878 {
13879 if (temp2)
13880 delete arg2;
13881 }
13882 return NULL;
13883 }
13884
13885
13886 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13887 PyObject *resultobj;
13888 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13889 wxString *arg2 = 0 ;
13890 bool temp2 = false ;
13891 PyObject * obj0 = 0 ;
13892 PyObject * obj1 = 0 ;
13893 char *kwnames[] = {
13894 (char *) "self",(char *) "shortDesc", NULL
13895 };
13896
13897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(1)) SWIG_fail;
13900 {
13901 arg2 = wxString_in_helper(obj1);
13902 if (arg2 == NULL) SWIG_fail;
13903 temp2 = true;
13904 }
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 (arg1)->SetShortDesc((wxString const &)*arg2);
13908
13909 wxPyEndAllowThreads(__tstate);
13910 if (PyErr_Occurred()) SWIG_fail;
13911 }
13912 Py_INCREF(Py_None); resultobj = Py_None;
13913 {
13914 if (temp2)
13915 delete arg2;
13916 }
13917 return resultobj;
13918 fail:
13919 {
13920 if (temp2)
13921 delete arg2;
13922 }
13923 return NULL;
13924 }
13925
13926
13927 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13928 PyObject *resultobj;
13929 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13930 wxString *result;
13931 PyObject * obj0 = 0 ;
13932 char *kwnames[] = {
13933 (char *) "self", NULL
13934 };
13935
13936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13938 if (SWIG_arg_fail(1)) SWIG_fail;
13939 {
13940 PyThreadState* __tstate = wxPyBeginAllowThreads();
13941 {
13942 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13943 result = (wxString *) &_result_ref;
13944 }
13945
13946 wxPyEndAllowThreads(__tstate);
13947 if (PyErr_Occurred()) SWIG_fail;
13948 }
13949 {
13950 #if wxUSE_UNICODE
13951 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13952 #else
13953 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13954 #endif
13955 }
13956 return resultobj;
13957 fail:
13958 return NULL;
13959 }
13960
13961
13962 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13963 PyObject *resultobj;
13964 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13965 wxString *result;
13966 PyObject * obj0 = 0 ;
13967 char *kwnames[] = {
13968 (char *) "self", NULL
13969 };
13970
13971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13973 if (SWIG_arg_fail(1)) SWIG_fail;
13974 {
13975 PyThreadState* __tstate = wxPyBeginAllowThreads();
13976 {
13977 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13978 result = (wxString *) &_result_ref;
13979 }
13980
13981 wxPyEndAllowThreads(__tstate);
13982 if (PyErr_Occurred()) SWIG_fail;
13983 }
13984 {
13985 #if wxUSE_UNICODE
13986 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13987 #else
13988 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13989 #endif
13990 }
13991 return resultobj;
13992 fail:
13993 return NULL;
13994 }
13995
13996
13997 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13998 PyObject *resultobj;
13999 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14000 wxString *result;
14001 PyObject * obj0 = 0 ;
14002 char *kwnames[] = {
14003 (char *) "self", NULL
14004 };
14005
14006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14008 if (SWIG_arg_fail(1)) SWIG_fail;
14009 {
14010 PyThreadState* __tstate = wxPyBeginAllowThreads();
14011 {
14012 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14013 result = (wxString *) &_result_ref;
14014 }
14015
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 {
14020 #if wxUSE_UNICODE
14021 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14022 #else
14023 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14024 #endif
14025 }
14026 return resultobj;
14027 fail:
14028 return NULL;
14029 }
14030
14031
14032 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14033 PyObject *resultobj;
14034 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14035 wxString *result;
14036 PyObject * obj0 = 0 ;
14037 char *kwnames[] = {
14038 (char *) "self", NULL
14039 };
14040
14041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14043 if (SWIG_arg_fail(1)) SWIG_fail;
14044 {
14045 PyThreadState* __tstate = wxPyBeginAllowThreads();
14046 {
14047 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14048 result = (wxString *) &_result_ref;
14049 }
14050
14051 wxPyEndAllowThreads(__tstate);
14052 if (PyErr_Occurred()) SWIG_fail;
14053 }
14054 {
14055 #if wxUSE_UNICODE
14056 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14057 #else
14058 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14059 #endif
14060 }
14061 return resultobj;
14062 fail:
14063 return NULL;
14064 }
14065
14066
14067 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14068 PyObject *resultobj;
14069 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14070 wxString *result;
14071 PyObject * obj0 = 0 ;
14072 char *kwnames[] = {
14073 (char *) "self", NULL
14074 };
14075
14076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14078 if (SWIG_arg_fail(1)) SWIG_fail;
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 {
14082 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14083 result = (wxString *) &_result_ref;
14084 }
14085
14086 wxPyEndAllowThreads(__tstate);
14087 if (PyErr_Occurred()) SWIG_fail;
14088 }
14089 {
14090 #if wxUSE_UNICODE
14091 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14092 #else
14093 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14094 #endif
14095 }
14096 return resultobj;
14097 fail:
14098 return NULL;
14099 }
14100
14101
14102 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14103 PyObject *resultobj;
14104 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14105 wxArrayString *result;
14106 PyObject * obj0 = 0 ;
14107 char *kwnames[] = {
14108 (char *) "self", NULL
14109 };
14110
14111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14113 if (SWIG_arg_fail(1)) SWIG_fail;
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 {
14117 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14118 result = (wxArrayString *) &_result_ref;
14119 }
14120
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 {
14125 resultobj = wxArrayString2PyList_helper(*result);
14126 }
14127 return resultobj;
14128 fail:
14129 return NULL;
14130 }
14131
14132
14133 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14134 PyObject *resultobj;
14135 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14136 int result;
14137 PyObject * obj0 = 0 ;
14138 char *kwnames[] = {
14139 (char *) "self", NULL
14140 };
14141
14142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14144 if (SWIG_arg_fail(1)) SWIG_fail;
14145 {
14146 PyThreadState* __tstate = wxPyBeginAllowThreads();
14147 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14148
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 {
14153 resultobj = SWIG_From_int((int)(result));
14154 }
14155 return resultobj;
14156 fail:
14157 return NULL;
14158 }
14159
14160
14161 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj;
14163 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14164 wxString *result;
14165 PyObject * obj0 = 0 ;
14166 char *kwnames[] = {
14167 (char *) "self", NULL
14168 };
14169
14170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14172 if (SWIG_arg_fail(1)) SWIG_fail;
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 {
14176 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14177 result = (wxString *) &_result_ref;
14178 }
14179
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 {
14184 #if wxUSE_UNICODE
14185 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14186 #else
14187 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14188 #endif
14189 }
14190 return resultobj;
14191 fail:
14192 return NULL;
14193 }
14194
14195
14196 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14197 PyObject *resultobj;
14198 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14199 int result;
14200 PyObject * obj0 = 0 ;
14201 char *kwnames[] = {
14202 (char *) "self", NULL
14203 };
14204
14205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14207 if (SWIG_arg_fail(1)) SWIG_fail;
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14211
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 {
14216 resultobj = SWIG_From_int((int)(result));
14217 }
14218 return resultobj;
14219 fail:
14220 return NULL;
14221 }
14222
14223
14224 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14225 PyObject *obj;
14226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14227 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14228 Py_INCREF(obj);
14229 return Py_BuildValue((char *)"");
14230 }
14231 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14232 PyObject *resultobj;
14233 wxFileTypeInfo *arg1 = 0 ;
14234 wxFileType *result;
14235 PyObject * obj0 = 0 ;
14236 char *kwnames[] = {
14237 (char *) "ftInfo", NULL
14238 };
14239
14240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14241 {
14242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14243 if (SWIG_arg_fail(1)) SWIG_fail;
14244 if (arg1 == NULL) {
14245 SWIG_null_ref("wxFileTypeInfo");
14246 }
14247 if (SWIG_arg_fail(1)) SWIG_fail;
14248 }
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14252
14253 wxPyEndAllowThreads(__tstate);
14254 if (PyErr_Occurred()) SWIG_fail;
14255 }
14256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14257 return resultobj;
14258 fail:
14259 return NULL;
14260 }
14261
14262
14263 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14264 PyObject *resultobj;
14265 wxFileType *arg1 = (wxFileType *) 0 ;
14266 PyObject * obj0 = 0 ;
14267 char *kwnames[] = {
14268 (char *) "self", NULL
14269 };
14270
14271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14273 if (SWIG_arg_fail(1)) SWIG_fail;
14274 {
14275 PyThreadState* __tstate = wxPyBeginAllowThreads();
14276 delete arg1;
14277
14278 wxPyEndAllowThreads(__tstate);
14279 if (PyErr_Occurred()) SWIG_fail;
14280 }
14281 Py_INCREF(Py_None); resultobj = Py_None;
14282 return resultobj;
14283 fail:
14284 return NULL;
14285 }
14286
14287
14288 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14289 PyObject *resultobj;
14290 wxFileType *arg1 = (wxFileType *) 0 ;
14291 PyObject *result;
14292 PyObject * obj0 = 0 ;
14293 char *kwnames[] = {
14294 (char *) "self", NULL
14295 };
14296
14297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14299 if (SWIG_arg_fail(1)) SWIG_fail;
14300 {
14301 PyThreadState* __tstate = wxPyBeginAllowThreads();
14302 result = (PyObject *)wxFileType_GetMimeType(arg1);
14303
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 resultobj = result;
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14315 PyObject *resultobj;
14316 wxFileType *arg1 = (wxFileType *) 0 ;
14317 PyObject *result;
14318 PyObject * obj0 = 0 ;
14319 char *kwnames[] = {
14320 (char *) "self", NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14325 if (SWIG_arg_fail(1)) SWIG_fail;
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14329
14330 wxPyEndAllowThreads(__tstate);
14331 if (PyErr_Occurred()) SWIG_fail;
14332 }
14333 resultobj = result;
14334 return resultobj;
14335 fail:
14336 return NULL;
14337 }
14338
14339
14340 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj;
14342 wxFileType *arg1 = (wxFileType *) 0 ;
14343 PyObject *result;
14344 PyObject * obj0 = 0 ;
14345 char *kwnames[] = {
14346 (char *) "self", NULL
14347 };
14348
14349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14351 if (SWIG_arg_fail(1)) SWIG_fail;
14352 {
14353 PyThreadState* __tstate = wxPyBeginAllowThreads();
14354 result = (PyObject *)wxFileType_GetExtensions(arg1);
14355
14356 wxPyEndAllowThreads(__tstate);
14357 if (PyErr_Occurred()) SWIG_fail;
14358 }
14359 resultobj = result;
14360 return resultobj;
14361 fail:
14362 return NULL;
14363 }
14364
14365
14366 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14367 PyObject *resultobj;
14368 wxFileType *arg1 = (wxFileType *) 0 ;
14369 wxIcon *result;
14370 PyObject * obj0 = 0 ;
14371 char *kwnames[] = {
14372 (char *) "self", NULL
14373 };
14374
14375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14377 if (SWIG_arg_fail(1)) SWIG_fail;
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (wxIcon *)wxFileType_GetIcon(arg1);
14381
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14386 return resultobj;
14387 fail:
14388 return NULL;
14389 }
14390
14391
14392 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14393 PyObject *resultobj;
14394 wxFileType *arg1 = (wxFileType *) 0 ;
14395 PyObject *result;
14396 PyObject * obj0 = 0 ;
14397 char *kwnames[] = {
14398 (char *) "self", NULL
14399 };
14400
14401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14403 if (SWIG_arg_fail(1)) SWIG_fail;
14404 {
14405 PyThreadState* __tstate = wxPyBeginAllowThreads();
14406 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14407
14408 wxPyEndAllowThreads(__tstate);
14409 if (PyErr_Occurred()) SWIG_fail;
14410 }
14411 resultobj = result;
14412 return resultobj;
14413 fail:
14414 return NULL;
14415 }
14416
14417
14418 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14419 PyObject *resultobj;
14420 wxFileType *arg1 = (wxFileType *) 0 ;
14421 PyObject *result;
14422 PyObject * obj0 = 0 ;
14423 char *kwnames[] = {
14424 (char *) "self", NULL
14425 };
14426
14427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14429 if (SWIG_arg_fail(1)) SWIG_fail;
14430 {
14431 PyThreadState* __tstate = wxPyBeginAllowThreads();
14432 result = (PyObject *)wxFileType_GetDescription(arg1);
14433
14434 wxPyEndAllowThreads(__tstate);
14435 if (PyErr_Occurred()) SWIG_fail;
14436 }
14437 resultobj = result;
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14445 PyObject *resultobj;
14446 wxFileType *arg1 = (wxFileType *) 0 ;
14447 wxString *arg2 = 0 ;
14448 wxString const &arg3_defvalue = wxPyEmptyString ;
14449 wxString *arg3 = (wxString *) &arg3_defvalue ;
14450 PyObject *result;
14451 bool temp2 = false ;
14452 bool temp3 = false ;
14453 PyObject * obj0 = 0 ;
14454 PyObject * obj1 = 0 ;
14455 PyObject * obj2 = 0 ;
14456 char *kwnames[] = {
14457 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14458 };
14459
14460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14462 if (SWIG_arg_fail(1)) SWIG_fail;
14463 {
14464 arg2 = wxString_in_helper(obj1);
14465 if (arg2 == NULL) SWIG_fail;
14466 temp2 = true;
14467 }
14468 if (obj2) {
14469 {
14470 arg3 = wxString_in_helper(obj2);
14471 if (arg3 == NULL) SWIG_fail;
14472 temp3 = true;
14473 }
14474 }
14475 {
14476 PyThreadState* __tstate = wxPyBeginAllowThreads();
14477 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14478
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 resultobj = result;
14483 {
14484 if (temp2)
14485 delete arg2;
14486 }
14487 {
14488 if (temp3)
14489 delete arg3;
14490 }
14491 return resultobj;
14492 fail:
14493 {
14494 if (temp2)
14495 delete arg2;
14496 }
14497 {
14498 if (temp3)
14499 delete arg3;
14500 }
14501 return NULL;
14502 }
14503
14504
14505 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14506 PyObject *resultobj;
14507 wxFileType *arg1 = (wxFileType *) 0 ;
14508 wxString *arg2 = 0 ;
14509 wxString const &arg3_defvalue = wxPyEmptyString ;
14510 wxString *arg3 = (wxString *) &arg3_defvalue ;
14511 PyObject *result;
14512 bool temp2 = false ;
14513 bool temp3 = false ;
14514 PyObject * obj0 = 0 ;
14515 PyObject * obj1 = 0 ;
14516 PyObject * obj2 = 0 ;
14517 char *kwnames[] = {
14518 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14519 };
14520
14521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14523 if (SWIG_arg_fail(1)) SWIG_fail;
14524 {
14525 arg2 = wxString_in_helper(obj1);
14526 if (arg2 == NULL) SWIG_fail;
14527 temp2 = true;
14528 }
14529 if (obj2) {
14530 {
14531 arg3 = wxString_in_helper(obj2);
14532 if (arg3 == NULL) SWIG_fail;
14533 temp3 = true;
14534 }
14535 }
14536 {
14537 PyThreadState* __tstate = wxPyBeginAllowThreads();
14538 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14539
14540 wxPyEndAllowThreads(__tstate);
14541 if (PyErr_Occurred()) SWIG_fail;
14542 }
14543 resultobj = result;
14544 {
14545 if (temp2)
14546 delete arg2;
14547 }
14548 {
14549 if (temp3)
14550 delete arg3;
14551 }
14552 return resultobj;
14553 fail:
14554 {
14555 if (temp2)
14556 delete arg2;
14557 }
14558 {
14559 if (temp3)
14560 delete arg3;
14561 }
14562 return NULL;
14563 }
14564
14565
14566 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14567 PyObject *resultobj;
14568 wxFileType *arg1 = (wxFileType *) 0 ;
14569 wxString *arg2 = 0 ;
14570 wxString const &arg3_defvalue = wxPyEmptyString ;
14571 wxString *arg3 = (wxString *) &arg3_defvalue ;
14572 PyObject *result;
14573 bool temp2 = false ;
14574 bool temp3 = false ;
14575 PyObject * obj0 = 0 ;
14576 PyObject * obj1 = 0 ;
14577 PyObject * obj2 = 0 ;
14578 char *kwnames[] = {
14579 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14580 };
14581
14582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14584 if (SWIG_arg_fail(1)) SWIG_fail;
14585 {
14586 arg2 = wxString_in_helper(obj1);
14587 if (arg2 == NULL) SWIG_fail;
14588 temp2 = true;
14589 }
14590 if (obj2) {
14591 {
14592 arg3 = wxString_in_helper(obj2);
14593 if (arg3 == NULL) SWIG_fail;
14594 temp3 = true;
14595 }
14596 }
14597 {
14598 PyThreadState* __tstate = wxPyBeginAllowThreads();
14599 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14600
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 resultobj = result;
14605 {
14606 if (temp2)
14607 delete arg2;
14608 }
14609 {
14610 if (temp3)
14611 delete arg3;
14612 }
14613 return resultobj;
14614 fail:
14615 {
14616 if (temp2)
14617 delete arg2;
14618 }
14619 {
14620 if (temp3)
14621 delete arg3;
14622 }
14623 return NULL;
14624 }
14625
14626
14627 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14628 PyObject *resultobj;
14629 wxFileType *arg1 = (wxFileType *) 0 ;
14630 wxString *arg2 = 0 ;
14631 wxString *arg3 = 0 ;
14632 bool arg4 = (bool) true ;
14633 bool result;
14634 bool temp2 = false ;
14635 bool temp3 = false ;
14636 PyObject * obj0 = 0 ;
14637 PyObject * obj1 = 0 ;
14638 PyObject * obj2 = 0 ;
14639 PyObject * obj3 = 0 ;
14640 char *kwnames[] = {
14641 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14642 };
14643
14644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14646 if (SWIG_arg_fail(1)) SWIG_fail;
14647 {
14648 arg2 = wxString_in_helper(obj1);
14649 if (arg2 == NULL) SWIG_fail;
14650 temp2 = true;
14651 }
14652 {
14653 arg3 = wxString_in_helper(obj2);
14654 if (arg3 == NULL) SWIG_fail;
14655 temp3 = true;
14656 }
14657 if (obj3) {
14658 {
14659 arg4 = (bool)(SWIG_As_bool(obj3));
14660 if (SWIG_arg_fail(4)) SWIG_fail;
14661 }
14662 }
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14666
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 {
14671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
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 (temp2)
14685 delete arg2;
14686 }
14687 {
14688 if (temp3)
14689 delete arg3;
14690 }
14691 return NULL;
14692 }
14693
14694
14695 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14696 PyObject *resultobj;
14697 wxFileType *arg1 = (wxFileType *) 0 ;
14698 wxString const &arg2_defvalue = wxPyEmptyString ;
14699 wxString *arg2 = (wxString *) &arg2_defvalue ;
14700 int arg3 = (int) 0 ;
14701 bool result;
14702 bool temp2 = false ;
14703 PyObject * obj0 = 0 ;
14704 PyObject * obj1 = 0 ;
14705 PyObject * obj2 = 0 ;
14706 char *kwnames[] = {
14707 (char *) "self",(char *) "cmd",(char *) "index", NULL
14708 };
14709
14710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14712 if (SWIG_arg_fail(1)) SWIG_fail;
14713 if (obj1) {
14714 {
14715 arg2 = wxString_in_helper(obj1);
14716 if (arg2 == NULL) SWIG_fail;
14717 temp2 = true;
14718 }
14719 }
14720 if (obj2) {
14721 {
14722 arg3 = (int)(SWIG_As_int(obj2));
14723 if (SWIG_arg_fail(3)) SWIG_fail;
14724 }
14725 }
14726 {
14727 PyThreadState* __tstate = wxPyBeginAllowThreads();
14728 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14729
14730 wxPyEndAllowThreads(__tstate);
14731 if (PyErr_Occurred()) SWIG_fail;
14732 }
14733 {
14734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14735 }
14736 {
14737 if (temp2)
14738 delete arg2;
14739 }
14740 return resultobj;
14741 fail:
14742 {
14743 if (temp2)
14744 delete arg2;
14745 }
14746 return NULL;
14747 }
14748
14749
14750 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14751 PyObject *resultobj;
14752 wxFileType *arg1 = (wxFileType *) 0 ;
14753 bool result;
14754 PyObject * obj0 = 0 ;
14755 char *kwnames[] = {
14756 (char *) "self", NULL
14757 };
14758
14759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14761 if (SWIG_arg_fail(1)) SWIG_fail;
14762 {
14763 PyThreadState* __tstate = wxPyBeginAllowThreads();
14764 result = (bool)(arg1)->Unassociate();
14765
14766 wxPyEndAllowThreads(__tstate);
14767 if (PyErr_Occurred()) SWIG_fail;
14768 }
14769 {
14770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14771 }
14772 return resultobj;
14773 fail:
14774 return NULL;
14775 }
14776
14777
14778 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14779 PyObject *resultobj;
14780 wxString *arg1 = 0 ;
14781 wxString *arg2 = 0 ;
14782 wxString const &arg3_defvalue = wxPyEmptyString ;
14783 wxString *arg3 = (wxString *) &arg3_defvalue ;
14784 wxString result;
14785 bool temp1 = false ;
14786 bool temp2 = false ;
14787 bool temp3 = false ;
14788 PyObject * obj0 = 0 ;
14789 PyObject * obj1 = 0 ;
14790 PyObject * obj2 = 0 ;
14791 char *kwnames[] = {
14792 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14793 };
14794
14795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14796 {
14797 arg1 = wxString_in_helper(obj0);
14798 if (arg1 == NULL) SWIG_fail;
14799 temp1 = true;
14800 }
14801 {
14802 arg2 = wxString_in_helper(obj1);
14803 if (arg2 == NULL) SWIG_fail;
14804 temp2 = true;
14805 }
14806 if (obj2) {
14807 {
14808 arg3 = wxString_in_helper(obj2);
14809 if (arg3 == NULL) SWIG_fail;
14810 temp3 = true;
14811 }
14812 }
14813 {
14814 PyThreadState* __tstate = wxPyBeginAllowThreads();
14815 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14816
14817 wxPyEndAllowThreads(__tstate);
14818 if (PyErr_Occurred()) SWIG_fail;
14819 }
14820 {
14821 #if wxUSE_UNICODE
14822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14823 #else
14824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14825 #endif
14826 }
14827 {
14828 if (temp1)
14829 delete arg1;
14830 }
14831 {
14832 if (temp2)
14833 delete arg2;
14834 }
14835 {
14836 if (temp3)
14837 delete arg3;
14838 }
14839 return resultobj;
14840 fail:
14841 {
14842 if (temp1)
14843 delete arg1;
14844 }
14845 {
14846 if (temp2)
14847 delete arg2;
14848 }
14849 {
14850 if (temp3)
14851 delete arg3;
14852 }
14853 return NULL;
14854 }
14855
14856
14857 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14858 PyObject *obj;
14859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14860 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14861 Py_INCREF(obj);
14862 return Py_BuildValue((char *)"");
14863 }
14864 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14865 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14866 return 1;
14867 }
14868
14869
14870 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14871 PyObject *pyobj;
14872
14873 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14874 return pyobj;
14875 }
14876
14877
14878 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj;
14880 wxString *arg1 = 0 ;
14881 wxString *arg2 = 0 ;
14882 bool result;
14883 bool temp1 = false ;
14884 bool temp2 = false ;
14885 PyObject * obj0 = 0 ;
14886 PyObject * obj1 = 0 ;
14887 char *kwnames[] = {
14888 (char *) "mimeType",(char *) "wildcard", NULL
14889 };
14890
14891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14892 {
14893 arg1 = wxString_in_helper(obj0);
14894 if (arg1 == NULL) SWIG_fail;
14895 temp1 = true;
14896 }
14897 {
14898 arg2 = wxString_in_helper(obj1);
14899 if (arg2 == NULL) SWIG_fail;
14900 temp2 = true;
14901 }
14902 {
14903 PyThreadState* __tstate = wxPyBeginAllowThreads();
14904 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14905
14906 wxPyEndAllowThreads(__tstate);
14907 if (PyErr_Occurred()) SWIG_fail;
14908 }
14909 {
14910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14911 }
14912 {
14913 if (temp1)
14914 delete arg1;
14915 }
14916 {
14917 if (temp2)
14918 delete arg2;
14919 }
14920 return resultobj;
14921 fail:
14922 {
14923 if (temp1)
14924 delete arg1;
14925 }
14926 {
14927 if (temp2)
14928 delete arg2;
14929 }
14930 return NULL;
14931 }
14932
14933
14934 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14935 PyObject *resultobj;
14936 wxMimeTypesManager *result;
14937 char *kwnames[] = {
14938 NULL
14939 };
14940
14941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14945
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj;
14958 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14959 int arg2 = (int) wxMAILCAP_ALL ;
14960 wxString const &arg3_defvalue = wxPyEmptyString ;
14961 wxString *arg3 = (wxString *) &arg3_defvalue ;
14962 bool temp3 = false ;
14963 PyObject * obj0 = 0 ;
14964 PyObject * obj1 = 0 ;
14965 PyObject * obj2 = 0 ;
14966 char *kwnames[] = {
14967 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14968 };
14969
14970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14972 if (SWIG_arg_fail(1)) SWIG_fail;
14973 if (obj1) {
14974 {
14975 arg2 = (int)(SWIG_As_int(obj1));
14976 if (SWIG_arg_fail(2)) SWIG_fail;
14977 }
14978 }
14979 if (obj2) {
14980 {
14981 arg3 = wxString_in_helper(obj2);
14982 if (arg3 == NULL) SWIG_fail;
14983 temp3 = true;
14984 }
14985 }
14986 {
14987 PyThreadState* __tstate = wxPyBeginAllowThreads();
14988 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14989
14990 wxPyEndAllowThreads(__tstate);
14991 if (PyErr_Occurred()) SWIG_fail;
14992 }
14993 Py_INCREF(Py_None); resultobj = Py_None;
14994 {
14995 if (temp3)
14996 delete arg3;
14997 }
14998 return resultobj;
14999 fail:
15000 {
15001 if (temp3)
15002 delete arg3;
15003 }
15004 return NULL;
15005 }
15006
15007
15008 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15009 PyObject *resultobj;
15010 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15011 PyObject * obj0 = 0 ;
15012 char *kwnames[] = {
15013 (char *) "self", NULL
15014 };
15015
15016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15018 if (SWIG_arg_fail(1)) SWIG_fail;
15019 {
15020 PyThreadState* __tstate = wxPyBeginAllowThreads();
15021 (arg1)->ClearData();
15022
15023 wxPyEndAllowThreads(__tstate);
15024 if (PyErr_Occurred()) SWIG_fail;
15025 }
15026 Py_INCREF(Py_None); resultobj = Py_None;
15027 return resultobj;
15028 fail:
15029 return NULL;
15030 }
15031
15032
15033 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj;
15035 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15036 wxString *arg2 = 0 ;
15037 wxFileType *result;
15038 bool temp2 = false ;
15039 PyObject * obj0 = 0 ;
15040 PyObject * obj1 = 0 ;
15041 char *kwnames[] = {
15042 (char *) "self",(char *) "ext", NULL
15043 };
15044
15045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15047 if (SWIG_arg_fail(1)) SWIG_fail;
15048 {
15049 arg2 = wxString_in_helper(obj1);
15050 if (arg2 == NULL) SWIG_fail;
15051 temp2 = true;
15052 }
15053 {
15054 PyThreadState* __tstate = wxPyBeginAllowThreads();
15055 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15056
15057 wxPyEndAllowThreads(__tstate);
15058 if (PyErr_Occurred()) SWIG_fail;
15059 }
15060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15061 {
15062 if (temp2)
15063 delete arg2;
15064 }
15065 return resultobj;
15066 fail:
15067 {
15068 if (temp2)
15069 delete arg2;
15070 }
15071 return NULL;
15072 }
15073
15074
15075 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15076 PyObject *resultobj;
15077 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15078 wxString *arg2 = 0 ;
15079 wxFileType *result;
15080 bool temp2 = false ;
15081 PyObject * obj0 = 0 ;
15082 PyObject * obj1 = 0 ;
15083 char *kwnames[] = {
15084 (char *) "self",(char *) "mimeType", NULL
15085 };
15086
15087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15089 if (SWIG_arg_fail(1)) SWIG_fail;
15090 {
15091 arg2 = wxString_in_helper(obj1);
15092 if (arg2 == NULL) SWIG_fail;
15093 temp2 = true;
15094 }
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15098
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15103 {
15104 if (temp2)
15105 delete arg2;
15106 }
15107 return resultobj;
15108 fail:
15109 {
15110 if (temp2)
15111 delete arg2;
15112 }
15113 return NULL;
15114 }
15115
15116
15117 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15118 PyObject *resultobj;
15119 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15120 wxString *arg2 = 0 ;
15121 bool arg3 = (bool) false ;
15122 bool result;
15123 bool temp2 = false ;
15124 PyObject * obj0 = 0 ;
15125 PyObject * obj1 = 0 ;
15126 PyObject * obj2 = 0 ;
15127 char *kwnames[] = {
15128 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15129 };
15130
15131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15133 if (SWIG_arg_fail(1)) SWIG_fail;
15134 {
15135 arg2 = wxString_in_helper(obj1);
15136 if (arg2 == NULL) SWIG_fail;
15137 temp2 = true;
15138 }
15139 if (obj2) {
15140 {
15141 arg3 = (bool)(SWIG_As_bool(obj2));
15142 if (SWIG_arg_fail(3)) SWIG_fail;
15143 }
15144 }
15145 {
15146 PyThreadState* __tstate = wxPyBeginAllowThreads();
15147 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15148
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 {
15153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15154 }
15155 {
15156 if (temp2)
15157 delete arg2;
15158 }
15159 return resultobj;
15160 fail:
15161 {
15162 if (temp2)
15163 delete arg2;
15164 }
15165 return NULL;
15166 }
15167
15168
15169 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15170 PyObject *resultobj;
15171 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15172 wxString *arg2 = 0 ;
15173 bool result;
15174 bool temp2 = false ;
15175 PyObject * obj0 = 0 ;
15176 PyObject * obj1 = 0 ;
15177 char *kwnames[] = {
15178 (char *) "self",(char *) "filename", NULL
15179 };
15180
15181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15183 if (SWIG_arg_fail(1)) SWIG_fail;
15184 {
15185 arg2 = wxString_in_helper(obj1);
15186 if (arg2 == NULL) SWIG_fail;
15187 temp2 = true;
15188 }
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15192
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 {
15197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15198 }
15199 {
15200 if (temp2)
15201 delete arg2;
15202 }
15203 return resultobj;
15204 fail:
15205 {
15206 if (temp2)
15207 delete arg2;
15208 }
15209 return NULL;
15210 }
15211
15212
15213 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15214 PyObject *resultobj;
15215 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15216 PyObject *result;
15217 PyObject * obj0 = 0 ;
15218 char *kwnames[] = {
15219 (char *) "self", NULL
15220 };
15221
15222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15224 if (SWIG_arg_fail(1)) SWIG_fail;
15225 {
15226 PyThreadState* __tstate = wxPyBeginAllowThreads();
15227 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15228
15229 wxPyEndAllowThreads(__tstate);
15230 if (PyErr_Occurred()) SWIG_fail;
15231 }
15232 resultobj = result;
15233 return resultobj;
15234 fail:
15235 return NULL;
15236 }
15237
15238
15239 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15240 PyObject *resultobj;
15241 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15242 wxFileTypeInfo *arg2 = 0 ;
15243 PyObject * obj0 = 0 ;
15244 PyObject * obj1 = 0 ;
15245 char *kwnames[] = {
15246 (char *) "self",(char *) "ft", NULL
15247 };
15248
15249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15251 if (SWIG_arg_fail(1)) SWIG_fail;
15252 {
15253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15254 if (SWIG_arg_fail(2)) SWIG_fail;
15255 if (arg2 == NULL) {
15256 SWIG_null_ref("wxFileTypeInfo");
15257 }
15258 if (SWIG_arg_fail(2)) SWIG_fail;
15259 }
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15263
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 Py_INCREF(Py_None); resultobj = Py_None;
15268 return resultobj;
15269 fail:
15270 return NULL;
15271 }
15272
15273
15274 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15275 PyObject *resultobj;
15276 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15277 wxFileTypeInfo *arg2 = 0 ;
15278 wxFileType *result;
15279 PyObject * obj0 = 0 ;
15280 PyObject * obj1 = 0 ;
15281 char *kwnames[] = {
15282 (char *) "self",(char *) "ftInfo", NULL
15283 };
15284
15285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15287 if (SWIG_arg_fail(1)) SWIG_fail;
15288 {
15289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15290 if (SWIG_arg_fail(2)) SWIG_fail;
15291 if (arg2 == NULL) {
15292 SWIG_null_ref("wxFileTypeInfo");
15293 }
15294 if (SWIG_arg_fail(2)) SWIG_fail;
15295 }
15296 {
15297 PyThreadState* __tstate = wxPyBeginAllowThreads();
15298 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15299
15300 wxPyEndAllowThreads(__tstate);
15301 if (PyErr_Occurred()) SWIG_fail;
15302 }
15303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15304 return resultobj;
15305 fail:
15306 return NULL;
15307 }
15308
15309
15310 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15311 PyObject *resultobj;
15312 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15313 wxFileType *arg2 = (wxFileType *) 0 ;
15314 bool result;
15315 PyObject * obj0 = 0 ;
15316 PyObject * obj1 = 0 ;
15317 char *kwnames[] = {
15318 (char *) "self",(char *) "ft", NULL
15319 };
15320
15321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15323 if (SWIG_arg_fail(1)) SWIG_fail;
15324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15325 if (SWIG_arg_fail(2)) SWIG_fail;
15326 {
15327 PyThreadState* __tstate = wxPyBeginAllowThreads();
15328 result = (bool)(arg1)->Unassociate(arg2);
15329
15330 wxPyEndAllowThreads(__tstate);
15331 if (PyErr_Occurred()) SWIG_fail;
15332 }
15333 {
15334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15335 }
15336 return resultobj;
15337 fail:
15338 return NULL;
15339 }
15340
15341
15342 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15343 PyObject *resultobj;
15344 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15345 PyObject * obj0 = 0 ;
15346 char *kwnames[] = {
15347 (char *) "self", NULL
15348 };
15349
15350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15352 if (SWIG_arg_fail(1)) SWIG_fail;
15353 {
15354 PyThreadState* __tstate = wxPyBeginAllowThreads();
15355 delete arg1;
15356
15357 wxPyEndAllowThreads(__tstate);
15358 if (PyErr_Occurred()) SWIG_fail;
15359 }
15360 Py_INCREF(Py_None); resultobj = Py_None;
15361 return resultobj;
15362 fail:
15363 return NULL;
15364 }
15365
15366
15367 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15368 PyObject *obj;
15369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15370 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15371 Py_INCREF(obj);
15372 return Py_BuildValue((char *)"");
15373 }
15374 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15375 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15376 return 1;
15377 }
15378
15379
15380 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15381 PyObject *pyobj;
15382
15383 {
15384 #if wxUSE_UNICODE
15385 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15386 #else
15387 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15388 #endif
15389 }
15390 return pyobj;
15391 }
15392
15393
15394 static int _wrap_ART_MENU_set(PyObject *) {
15395 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15396 return 1;
15397 }
15398
15399
15400 static PyObject *_wrap_ART_MENU_get(void) {
15401 PyObject *pyobj;
15402
15403 {
15404 #if wxUSE_UNICODE
15405 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15406 #else
15407 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15408 #endif
15409 }
15410 return pyobj;
15411 }
15412
15413
15414 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15415 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15416 return 1;
15417 }
15418
15419
15420 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15421 PyObject *pyobj;
15422
15423 {
15424 #if wxUSE_UNICODE
15425 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15426 #else
15427 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15428 #endif
15429 }
15430 return pyobj;
15431 }
15432
15433
15434 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15435 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15436 return 1;
15437 }
15438
15439
15440 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15441 PyObject *pyobj;
15442
15443 {
15444 #if wxUSE_UNICODE
15445 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15446 #else
15447 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15448 #endif
15449 }
15450 return pyobj;
15451 }
15452
15453
15454 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15455 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15456 return 1;
15457 }
15458
15459
15460 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15461 PyObject *pyobj;
15462
15463 {
15464 #if wxUSE_UNICODE
15465 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15466 #else
15467 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15468 #endif
15469 }
15470 return pyobj;
15471 }
15472
15473
15474 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15475 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15476 return 1;
15477 }
15478
15479
15480 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15481 PyObject *pyobj;
15482
15483 {
15484 #if wxUSE_UNICODE
15485 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15486 #else
15487 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15488 #endif
15489 }
15490 return pyobj;
15491 }
15492
15493
15494 static int _wrap_ART_BUTTON_set(PyObject *) {
15495 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15496 return 1;
15497 }
15498
15499
15500 static PyObject *_wrap_ART_BUTTON_get(void) {
15501 PyObject *pyobj;
15502
15503 {
15504 #if wxUSE_UNICODE
15505 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15506 #else
15507 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15508 #endif
15509 }
15510 return pyobj;
15511 }
15512
15513
15514 static int _wrap_ART_OTHER_set(PyObject *) {
15515 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15516 return 1;
15517 }
15518
15519
15520 static PyObject *_wrap_ART_OTHER_get(void) {
15521 PyObject *pyobj;
15522
15523 {
15524 #if wxUSE_UNICODE
15525 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15526 #else
15527 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15528 #endif
15529 }
15530 return pyobj;
15531 }
15532
15533
15534 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15535 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15536 return 1;
15537 }
15538
15539
15540 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15541 PyObject *pyobj;
15542
15543 {
15544 #if wxUSE_UNICODE
15545 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15546 #else
15547 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15548 #endif
15549 }
15550 return pyobj;
15551 }
15552
15553
15554 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15555 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15556 return 1;
15557 }
15558
15559
15560 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15561 PyObject *pyobj;
15562
15563 {
15564 #if wxUSE_UNICODE
15565 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15566 #else
15567 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15568 #endif
15569 }
15570 return pyobj;
15571 }
15572
15573
15574 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15575 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15576 return 1;
15577 }
15578
15579
15580 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15581 PyObject *pyobj;
15582
15583 {
15584 #if wxUSE_UNICODE
15585 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15586 #else
15587 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15588 #endif
15589 }
15590 return pyobj;
15591 }
15592
15593
15594 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15595 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15596 return 1;
15597 }
15598
15599
15600 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15601 PyObject *pyobj;
15602
15603 {
15604 #if wxUSE_UNICODE
15605 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15606 #else
15607 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15608 #endif
15609 }
15610 return pyobj;
15611 }
15612
15613
15614 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15615 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15616 return 1;
15617 }
15618
15619
15620 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15621 PyObject *pyobj;
15622
15623 {
15624 #if wxUSE_UNICODE
15625 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15626 #else
15627 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15628 #endif
15629 }
15630 return pyobj;
15631 }
15632
15633
15634 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15635 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15636 return 1;
15637 }
15638
15639
15640 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15641 PyObject *pyobj;
15642
15643 {
15644 #if wxUSE_UNICODE
15645 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15646 #else
15647 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15648 #endif
15649 }
15650 return pyobj;
15651 }
15652
15653
15654 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15655 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15656 return 1;
15657 }
15658
15659
15660 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15661 PyObject *pyobj;
15662
15663 {
15664 #if wxUSE_UNICODE
15665 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15666 #else
15667 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15668 #endif
15669 }
15670 return pyobj;
15671 }
15672
15673
15674 static int _wrap_ART_GO_BACK_set(PyObject *) {
15675 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15676 return 1;
15677 }
15678
15679
15680 static PyObject *_wrap_ART_GO_BACK_get(void) {
15681 PyObject *pyobj;
15682
15683 {
15684 #if wxUSE_UNICODE
15685 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15686 #else
15687 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15688 #endif
15689 }
15690 return pyobj;
15691 }
15692
15693
15694 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15695 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15696 return 1;
15697 }
15698
15699
15700 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15701 PyObject *pyobj;
15702
15703 {
15704 #if wxUSE_UNICODE
15705 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15706 #else
15707 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15708 #endif
15709 }
15710 return pyobj;
15711 }
15712
15713
15714 static int _wrap_ART_GO_UP_set(PyObject *) {
15715 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15716 return 1;
15717 }
15718
15719
15720 static PyObject *_wrap_ART_GO_UP_get(void) {
15721 PyObject *pyobj;
15722
15723 {
15724 #if wxUSE_UNICODE
15725 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15726 #else
15727 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15728 #endif
15729 }
15730 return pyobj;
15731 }
15732
15733
15734 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15735 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15736 return 1;
15737 }
15738
15739
15740 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15741 PyObject *pyobj;
15742
15743 {
15744 #if wxUSE_UNICODE
15745 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15746 #else
15747 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15748 #endif
15749 }
15750 return pyobj;
15751 }
15752
15753
15754 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15755 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15756 return 1;
15757 }
15758
15759
15760 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15761 PyObject *pyobj;
15762
15763 {
15764 #if wxUSE_UNICODE
15765 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15766 #else
15767 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15768 #endif
15769 }
15770 return pyobj;
15771 }
15772
15773
15774 static int _wrap_ART_GO_HOME_set(PyObject *) {
15775 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15776 return 1;
15777 }
15778
15779
15780 static PyObject *_wrap_ART_GO_HOME_get(void) {
15781 PyObject *pyobj;
15782
15783 {
15784 #if wxUSE_UNICODE
15785 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15786 #else
15787 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15788 #endif
15789 }
15790 return pyobj;
15791 }
15792
15793
15794 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15795 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15796 return 1;
15797 }
15798
15799
15800 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15801 PyObject *pyobj;
15802
15803 {
15804 #if wxUSE_UNICODE
15805 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15806 #else
15807 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15808 #endif
15809 }
15810 return pyobj;
15811 }
15812
15813
15814 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15815 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15816 return 1;
15817 }
15818
15819
15820 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15821 PyObject *pyobj;
15822
15823 {
15824 #if wxUSE_UNICODE
15825 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15826 #else
15827 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15828 #endif
15829 }
15830 return pyobj;
15831 }
15832
15833
15834 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15835 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15836 return 1;
15837 }
15838
15839
15840 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15841 PyObject *pyobj;
15842
15843 {
15844 #if wxUSE_UNICODE
15845 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15846 #else
15847 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15848 #endif
15849 }
15850 return pyobj;
15851 }
15852
15853
15854 static int _wrap_ART_PRINT_set(PyObject *) {
15855 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15856 return 1;
15857 }
15858
15859
15860 static PyObject *_wrap_ART_PRINT_get(void) {
15861 PyObject *pyobj;
15862
15863 {
15864 #if wxUSE_UNICODE
15865 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15866 #else
15867 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15868 #endif
15869 }
15870 return pyobj;
15871 }
15872
15873
15874 static int _wrap_ART_HELP_set(PyObject *) {
15875 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15876 return 1;
15877 }
15878
15879
15880 static PyObject *_wrap_ART_HELP_get(void) {
15881 PyObject *pyobj;
15882
15883 {
15884 #if wxUSE_UNICODE
15885 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15886 #else
15887 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15888 #endif
15889 }
15890 return pyobj;
15891 }
15892
15893
15894 static int _wrap_ART_TIP_set(PyObject *) {
15895 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15896 return 1;
15897 }
15898
15899
15900 static PyObject *_wrap_ART_TIP_get(void) {
15901 PyObject *pyobj;
15902
15903 {
15904 #if wxUSE_UNICODE
15905 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15906 #else
15907 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15908 #endif
15909 }
15910 return pyobj;
15911 }
15912
15913
15914 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15915 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15916 return 1;
15917 }
15918
15919
15920 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15921 PyObject *pyobj;
15922
15923 {
15924 #if wxUSE_UNICODE
15925 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15926 #else
15927 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15928 #endif
15929 }
15930 return pyobj;
15931 }
15932
15933
15934 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15935 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15936 return 1;
15937 }
15938
15939
15940 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15941 PyObject *pyobj;
15942
15943 {
15944 #if wxUSE_UNICODE
15945 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15946 #else
15947 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15948 #endif
15949 }
15950 return pyobj;
15951 }
15952
15953
15954 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15955 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15956 return 1;
15957 }
15958
15959
15960 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15961 PyObject *pyobj;
15962
15963 {
15964 #if wxUSE_UNICODE
15965 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15966 #else
15967 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15968 #endif
15969 }
15970 return pyobj;
15971 }
15972
15973
15974 static int _wrap_ART_HARDDISK_set(PyObject *) {
15975 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15976 return 1;
15977 }
15978
15979
15980 static PyObject *_wrap_ART_HARDDISK_get(void) {
15981 PyObject *pyobj;
15982
15983 {
15984 #if wxUSE_UNICODE
15985 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15986 #else
15987 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15988 #endif
15989 }
15990 return pyobj;
15991 }
15992
15993
15994 static int _wrap_ART_FLOPPY_set(PyObject *) {
15995 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15996 return 1;
15997 }
15998
15999
16000 static PyObject *_wrap_ART_FLOPPY_get(void) {
16001 PyObject *pyobj;
16002
16003 {
16004 #if wxUSE_UNICODE
16005 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16006 #else
16007 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16008 #endif
16009 }
16010 return pyobj;
16011 }
16012
16013
16014 static int _wrap_ART_CDROM_set(PyObject *) {
16015 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16016 return 1;
16017 }
16018
16019
16020 static PyObject *_wrap_ART_CDROM_get(void) {
16021 PyObject *pyobj;
16022
16023 {
16024 #if wxUSE_UNICODE
16025 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16026 #else
16027 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16028 #endif
16029 }
16030 return pyobj;
16031 }
16032
16033
16034 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16035 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16036 return 1;
16037 }
16038
16039
16040 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16041 PyObject *pyobj;
16042
16043 {
16044 #if wxUSE_UNICODE
16045 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16046 #else
16047 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16048 #endif
16049 }
16050 return pyobj;
16051 }
16052
16053
16054 static int _wrap_ART_FOLDER_set(PyObject *) {
16055 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16056 return 1;
16057 }
16058
16059
16060 static PyObject *_wrap_ART_FOLDER_get(void) {
16061 PyObject *pyobj;
16062
16063 {
16064 #if wxUSE_UNICODE
16065 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16066 #else
16067 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16068 #endif
16069 }
16070 return pyobj;
16071 }
16072
16073
16074 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16075 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16076 return 1;
16077 }
16078
16079
16080 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16081 PyObject *pyobj;
16082
16083 {
16084 #if wxUSE_UNICODE
16085 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16086 #else
16087 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16088 #endif
16089 }
16090 return pyobj;
16091 }
16092
16093
16094 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16095 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16096 return 1;
16097 }
16098
16099
16100 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16101 PyObject *pyobj;
16102
16103 {
16104 #if wxUSE_UNICODE
16105 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16106 #else
16107 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16108 #endif
16109 }
16110 return pyobj;
16111 }
16112
16113
16114 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16115 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16116 return 1;
16117 }
16118
16119
16120 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16121 PyObject *pyobj;
16122
16123 {
16124 #if wxUSE_UNICODE
16125 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16126 #else
16127 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16128 #endif
16129 }
16130 return pyobj;
16131 }
16132
16133
16134 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16135 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16136 return 1;
16137 }
16138
16139
16140 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16141 PyObject *pyobj;
16142
16143 {
16144 #if wxUSE_UNICODE
16145 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16146 #else
16147 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16148 #endif
16149 }
16150 return pyobj;
16151 }
16152
16153
16154 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16155 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16156 return 1;
16157 }
16158
16159
16160 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16161 PyObject *pyobj;
16162
16163 {
16164 #if wxUSE_UNICODE
16165 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16166 #else
16167 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16168 #endif
16169 }
16170 return pyobj;
16171 }
16172
16173
16174 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16175 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16176 return 1;
16177 }
16178
16179
16180 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16181 PyObject *pyobj;
16182
16183 {
16184 #if wxUSE_UNICODE
16185 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16186 #else
16187 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16188 #endif
16189 }
16190 return pyobj;
16191 }
16192
16193
16194 static int _wrap_ART_ERROR_set(PyObject *) {
16195 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16196 return 1;
16197 }
16198
16199
16200 static PyObject *_wrap_ART_ERROR_get(void) {
16201 PyObject *pyobj;
16202
16203 {
16204 #if wxUSE_UNICODE
16205 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16206 #else
16207 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16208 #endif
16209 }
16210 return pyobj;
16211 }
16212
16213
16214 static int _wrap_ART_QUESTION_set(PyObject *) {
16215 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16216 return 1;
16217 }
16218
16219
16220 static PyObject *_wrap_ART_QUESTION_get(void) {
16221 PyObject *pyobj;
16222
16223 {
16224 #if wxUSE_UNICODE
16225 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16226 #else
16227 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16228 #endif
16229 }
16230 return pyobj;
16231 }
16232
16233
16234 static int _wrap_ART_WARNING_set(PyObject *) {
16235 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16236 return 1;
16237 }
16238
16239
16240 static PyObject *_wrap_ART_WARNING_get(void) {
16241 PyObject *pyobj;
16242
16243 {
16244 #if wxUSE_UNICODE
16245 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16246 #else
16247 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16248 #endif
16249 }
16250 return pyobj;
16251 }
16252
16253
16254 static int _wrap_ART_INFORMATION_set(PyObject *) {
16255 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16256 return 1;
16257 }
16258
16259
16260 static PyObject *_wrap_ART_INFORMATION_get(void) {
16261 PyObject *pyobj;
16262
16263 {
16264 #if wxUSE_UNICODE
16265 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16266 #else
16267 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16268 #endif
16269 }
16270 return pyobj;
16271 }
16272
16273
16274 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16275 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16276 return 1;
16277 }
16278
16279
16280 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16281 PyObject *pyobj;
16282
16283 {
16284 #if wxUSE_UNICODE
16285 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16286 #else
16287 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16288 #endif
16289 }
16290 return pyobj;
16291 }
16292
16293
16294 static int _wrap_ART_COPY_set(PyObject *) {
16295 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16296 return 1;
16297 }
16298
16299
16300 static PyObject *_wrap_ART_COPY_get(void) {
16301 PyObject *pyobj;
16302
16303 {
16304 #if wxUSE_UNICODE
16305 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16306 #else
16307 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16308 #endif
16309 }
16310 return pyobj;
16311 }
16312
16313
16314 static int _wrap_ART_CUT_set(PyObject *) {
16315 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16316 return 1;
16317 }
16318
16319
16320 static PyObject *_wrap_ART_CUT_get(void) {
16321 PyObject *pyobj;
16322
16323 {
16324 #if wxUSE_UNICODE
16325 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16326 #else
16327 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16328 #endif
16329 }
16330 return pyobj;
16331 }
16332
16333
16334 static int _wrap_ART_PASTE_set(PyObject *) {
16335 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16336 return 1;
16337 }
16338
16339
16340 static PyObject *_wrap_ART_PASTE_get(void) {
16341 PyObject *pyobj;
16342
16343 {
16344 #if wxUSE_UNICODE
16345 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16346 #else
16347 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16348 #endif
16349 }
16350 return pyobj;
16351 }
16352
16353
16354 static int _wrap_ART_DELETE_set(PyObject *) {
16355 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16356 return 1;
16357 }
16358
16359
16360 static PyObject *_wrap_ART_DELETE_get(void) {
16361 PyObject *pyobj;
16362
16363 {
16364 #if wxUSE_UNICODE
16365 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16366 #else
16367 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16368 #endif
16369 }
16370 return pyobj;
16371 }
16372
16373
16374 static int _wrap_ART_UNDO_set(PyObject *) {
16375 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16376 return 1;
16377 }
16378
16379
16380 static PyObject *_wrap_ART_UNDO_get(void) {
16381 PyObject *pyobj;
16382
16383 {
16384 #if wxUSE_UNICODE
16385 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16386 #else
16387 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16388 #endif
16389 }
16390 return pyobj;
16391 }
16392
16393
16394 static int _wrap_ART_REDO_set(PyObject *) {
16395 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16396 return 1;
16397 }
16398
16399
16400 static PyObject *_wrap_ART_REDO_get(void) {
16401 PyObject *pyobj;
16402
16403 {
16404 #if wxUSE_UNICODE
16405 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16406 #else
16407 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16408 #endif
16409 }
16410 return pyobj;
16411 }
16412
16413
16414 static int _wrap_ART_QUIT_set(PyObject *) {
16415 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16416 return 1;
16417 }
16418
16419
16420 static PyObject *_wrap_ART_QUIT_get(void) {
16421 PyObject *pyobj;
16422
16423 {
16424 #if wxUSE_UNICODE
16425 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16426 #else
16427 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16428 #endif
16429 }
16430 return pyobj;
16431 }
16432
16433
16434 static int _wrap_ART_FIND_set(PyObject *) {
16435 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16436 return 1;
16437 }
16438
16439
16440 static PyObject *_wrap_ART_FIND_get(void) {
16441 PyObject *pyobj;
16442
16443 {
16444 #if wxUSE_UNICODE
16445 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16446 #else
16447 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16448 #endif
16449 }
16450 return pyobj;
16451 }
16452
16453
16454 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16455 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16456 return 1;
16457 }
16458
16459
16460 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16461 PyObject *pyobj;
16462
16463 {
16464 #if wxUSE_UNICODE
16465 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16466 #else
16467 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16468 #endif
16469 }
16470 return pyobj;
16471 }
16472
16473
16474 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16475 PyObject *resultobj;
16476 wxPyArtProvider *result;
16477 char *kwnames[] = {
16478 NULL
16479 };
16480
16481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16482 {
16483 if (!wxPyCheckForApp()) SWIG_fail;
16484 PyThreadState* __tstate = wxPyBeginAllowThreads();
16485 result = (wxPyArtProvider *)new wxPyArtProvider();
16486
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16491 return resultobj;
16492 fail:
16493 return NULL;
16494 }
16495
16496
16497 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16498 PyObject *resultobj;
16499 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16500 PyObject *arg2 = (PyObject *) 0 ;
16501 PyObject *arg3 = (PyObject *) 0 ;
16502 PyObject * obj0 = 0 ;
16503 PyObject * obj1 = 0 ;
16504 PyObject * obj2 = 0 ;
16505 char *kwnames[] = {
16506 (char *) "self",(char *) "self",(char *) "_class", NULL
16507 };
16508
16509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16511 if (SWIG_arg_fail(1)) SWIG_fail;
16512 arg2 = obj1;
16513 arg3 = obj2;
16514 {
16515 PyThreadState* __tstate = wxPyBeginAllowThreads();
16516 (arg1)->_setCallbackInfo(arg2,arg3);
16517
16518 wxPyEndAllowThreads(__tstate);
16519 if (PyErr_Occurred()) SWIG_fail;
16520 }
16521 Py_INCREF(Py_None); resultobj = Py_None;
16522 return resultobj;
16523 fail:
16524 return NULL;
16525 }
16526
16527
16528 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16529 PyObject *resultobj;
16530 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16531 PyObject * obj0 = 0 ;
16532 char *kwnames[] = {
16533 (char *) "provider", NULL
16534 };
16535
16536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16538 if (SWIG_arg_fail(1)) SWIG_fail;
16539 {
16540 PyThreadState* __tstate = wxPyBeginAllowThreads();
16541 wxPyArtProvider::PushProvider(arg1);
16542
16543 wxPyEndAllowThreads(__tstate);
16544 if (PyErr_Occurred()) SWIG_fail;
16545 }
16546 Py_INCREF(Py_None); resultobj = Py_None;
16547 return resultobj;
16548 fail:
16549 return NULL;
16550 }
16551
16552
16553 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16554 PyObject *resultobj;
16555 bool result;
16556 char *kwnames[] = {
16557 NULL
16558 };
16559
16560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16561 {
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 result = (bool)wxPyArtProvider::PopProvider();
16564
16565 wxPyEndAllowThreads(__tstate);
16566 if (PyErr_Occurred()) SWIG_fail;
16567 }
16568 {
16569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16570 }
16571 return resultobj;
16572 fail:
16573 return NULL;
16574 }
16575
16576
16577 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16578 PyObject *resultobj;
16579 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16580 bool result;
16581 PyObject * obj0 = 0 ;
16582 char *kwnames[] = {
16583 (char *) "provider", NULL
16584 };
16585
16586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16588 if (SWIG_arg_fail(1)) SWIG_fail;
16589 {
16590 PyThreadState* __tstate = wxPyBeginAllowThreads();
16591 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16592
16593 wxPyEndAllowThreads(__tstate);
16594 if (PyErr_Occurred()) SWIG_fail;
16595 }
16596 {
16597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16598 }
16599 return resultobj;
16600 fail:
16601 return NULL;
16602 }
16603
16604
16605 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16606 PyObject *resultobj;
16607 wxString *arg1 = 0 ;
16608 wxString const &arg2_defvalue = wxPyART_OTHER ;
16609 wxString *arg2 = (wxString *) &arg2_defvalue ;
16610 wxSize const &arg3_defvalue = wxDefaultSize ;
16611 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16612 wxBitmap result;
16613 bool temp1 = false ;
16614 bool temp2 = false ;
16615 wxSize temp3 ;
16616 PyObject * obj0 = 0 ;
16617 PyObject * obj1 = 0 ;
16618 PyObject * obj2 = 0 ;
16619 char *kwnames[] = {
16620 (char *) "id",(char *) "client",(char *) "size", NULL
16621 };
16622
16623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16624 {
16625 arg1 = wxString_in_helper(obj0);
16626 if (arg1 == NULL) SWIG_fail;
16627 temp1 = true;
16628 }
16629 if (obj1) {
16630 {
16631 arg2 = wxString_in_helper(obj1);
16632 if (arg2 == NULL) SWIG_fail;
16633 temp2 = true;
16634 }
16635 }
16636 if (obj2) {
16637 {
16638 arg3 = &temp3;
16639 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16640 }
16641 }
16642 {
16643 if (!wxPyCheckForApp()) SWIG_fail;
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16646
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 {
16651 wxBitmap * resultptr;
16652 resultptr = new wxBitmap((wxBitmap &)(result));
16653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16654 }
16655 {
16656 if (temp1)
16657 delete arg1;
16658 }
16659 {
16660 if (temp2)
16661 delete arg2;
16662 }
16663 return resultobj;
16664 fail:
16665 {
16666 if (temp1)
16667 delete arg1;
16668 }
16669 {
16670 if (temp2)
16671 delete arg2;
16672 }
16673 return NULL;
16674 }
16675
16676
16677 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16678 PyObject *resultobj;
16679 wxString *arg1 = 0 ;
16680 wxString const &arg2_defvalue = wxPyART_OTHER ;
16681 wxString *arg2 = (wxString *) &arg2_defvalue ;
16682 wxSize const &arg3_defvalue = wxDefaultSize ;
16683 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16684 wxIcon result;
16685 bool temp1 = false ;
16686 bool temp2 = false ;
16687 wxSize temp3 ;
16688 PyObject * obj0 = 0 ;
16689 PyObject * obj1 = 0 ;
16690 PyObject * obj2 = 0 ;
16691 char *kwnames[] = {
16692 (char *) "id",(char *) "client",(char *) "size", NULL
16693 };
16694
16695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16696 {
16697 arg1 = wxString_in_helper(obj0);
16698 if (arg1 == NULL) SWIG_fail;
16699 temp1 = true;
16700 }
16701 if (obj1) {
16702 {
16703 arg2 = wxString_in_helper(obj1);
16704 if (arg2 == NULL) SWIG_fail;
16705 temp2 = true;
16706 }
16707 }
16708 if (obj2) {
16709 {
16710 arg3 = &temp3;
16711 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16712 }
16713 }
16714 {
16715 if (!wxPyCheckForApp()) SWIG_fail;
16716 PyThreadState* __tstate = wxPyBeginAllowThreads();
16717 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16718
16719 wxPyEndAllowThreads(__tstate);
16720 if (PyErr_Occurred()) SWIG_fail;
16721 }
16722 {
16723 wxIcon * resultptr;
16724 resultptr = new wxIcon((wxIcon &)(result));
16725 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16726 }
16727 {
16728 if (temp1)
16729 delete arg1;
16730 }
16731 {
16732 if (temp2)
16733 delete arg2;
16734 }
16735 return resultobj;
16736 fail:
16737 {
16738 if (temp1)
16739 delete arg1;
16740 }
16741 {
16742 if (temp2)
16743 delete arg2;
16744 }
16745 return NULL;
16746 }
16747
16748
16749 static PyObject *_wrap_ArtProvider_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj;
16751 wxString *arg1 = 0 ;
16752 bool arg2 = (bool) false ;
16753 wxSize result;
16754 bool temp1 = false ;
16755 PyObject * obj0 = 0 ;
16756 PyObject * obj1 = 0 ;
16757 char *kwnames[] = {
16758 (char *) "client",(char *) "platform_dependent", NULL
16759 };
16760
16761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSize",kwnames,&obj0,&obj1)) goto fail;
16762 {
16763 arg1 = wxString_in_helper(obj0);
16764 if (arg1 == NULL) SWIG_fail;
16765 temp1 = true;
16766 }
16767 if (obj1) {
16768 {
16769 arg2 = (bool)(SWIG_As_bool(obj1));
16770 if (SWIG_arg_fail(2)) SWIG_fail;
16771 }
16772 }
16773 {
16774 PyThreadState* __tstate = wxPyBeginAllowThreads();
16775 result = wxPyArtProvider::GetSize((wxString const &)*arg1,arg2);
16776
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 {
16781 wxSize * resultptr;
16782 resultptr = new wxSize((wxSize &)(result));
16783 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16784 }
16785 {
16786 if (temp1)
16787 delete arg1;
16788 }
16789 return resultobj;
16790 fail:
16791 {
16792 if (temp1)
16793 delete arg1;
16794 }
16795 return NULL;
16796 }
16797
16798
16799 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16800 PyObject *resultobj;
16801 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16802 PyObject * obj0 = 0 ;
16803 char *kwnames[] = {
16804 (char *) "self", NULL
16805 };
16806
16807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16809 if (SWIG_arg_fail(1)) SWIG_fail;
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 wxPyArtProvider_Destroy(arg1);
16813
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 Py_INCREF(Py_None); resultobj = Py_None;
16818 return resultobj;
16819 fail:
16820 return NULL;
16821 }
16822
16823
16824 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16825 PyObject *obj;
16826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16827 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16828 Py_INCREF(obj);
16829 return Py_BuildValue((char *)"");
16830 }
16831 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16832 PyObject *resultobj;
16833 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16834 PyObject * obj0 = 0 ;
16835 char *kwnames[] = {
16836 (char *) "self", NULL
16837 };
16838
16839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16841 if (SWIG_arg_fail(1)) SWIG_fail;
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 delete arg1;
16845
16846 wxPyEndAllowThreads(__tstate);
16847 if (PyErr_Occurred()) SWIG_fail;
16848 }
16849 Py_INCREF(Py_None); resultobj = Py_None;
16850 return resultobj;
16851 fail:
16852 return NULL;
16853 }
16854
16855
16856 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16857 PyObject *resultobj;
16858 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16859 wxConfigBase *result;
16860 PyObject * obj0 = 0 ;
16861 char *kwnames[] = {
16862 (char *) "config", NULL
16863 };
16864
16865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16867 if (SWIG_arg_fail(1)) SWIG_fail;
16868 {
16869 PyThreadState* __tstate = wxPyBeginAllowThreads();
16870 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16871
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16883 PyObject *resultobj;
16884 bool arg1 = (bool) true ;
16885 wxConfigBase *result;
16886 PyObject * obj0 = 0 ;
16887 char *kwnames[] = {
16888 (char *) "createOnDemand", NULL
16889 };
16890
16891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16892 if (obj0) {
16893 {
16894 arg1 = (bool)(SWIG_As_bool(obj0));
16895 if (SWIG_arg_fail(1)) SWIG_fail;
16896 }
16897 }
16898 {
16899 PyThreadState* __tstate = wxPyBeginAllowThreads();
16900 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16901
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16906 return resultobj;
16907 fail:
16908 return NULL;
16909 }
16910
16911
16912 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16913 PyObject *resultobj;
16914 wxConfigBase *result;
16915 char *kwnames[] = {
16916 NULL
16917 };
16918
16919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16920 {
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = (wxConfigBase *)wxConfigBase::Create();
16923
16924 wxPyEndAllowThreads(__tstate);
16925 if (PyErr_Occurred()) SWIG_fail;
16926 }
16927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16928 return resultobj;
16929 fail:
16930 return NULL;
16931 }
16932
16933
16934 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16935 PyObject *resultobj;
16936 char *kwnames[] = {
16937 NULL
16938 };
16939
16940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16941 {
16942 PyThreadState* __tstate = wxPyBeginAllowThreads();
16943 wxConfigBase::DontCreateOnDemand();
16944
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 Py_INCREF(Py_None); resultobj = Py_None;
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj;
16957 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16958 wxString *arg2 = 0 ;
16959 bool temp2 = false ;
16960 PyObject * obj0 = 0 ;
16961 PyObject * obj1 = 0 ;
16962 char *kwnames[] = {
16963 (char *) "self",(char *) "path", NULL
16964 };
16965
16966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16968 if (SWIG_arg_fail(1)) SWIG_fail;
16969 {
16970 arg2 = wxString_in_helper(obj1);
16971 if (arg2 == NULL) SWIG_fail;
16972 temp2 = true;
16973 }
16974 {
16975 PyThreadState* __tstate = wxPyBeginAllowThreads();
16976 (arg1)->SetPath((wxString const &)*arg2);
16977
16978 wxPyEndAllowThreads(__tstate);
16979 if (PyErr_Occurred()) SWIG_fail;
16980 }
16981 Py_INCREF(Py_None); resultobj = Py_None;
16982 {
16983 if (temp2)
16984 delete arg2;
16985 }
16986 return resultobj;
16987 fail:
16988 {
16989 if (temp2)
16990 delete arg2;
16991 }
16992 return NULL;
16993 }
16994
16995
16996 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16997 PyObject *resultobj;
16998 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16999 wxString *result;
17000 PyObject * obj0 = 0 ;
17001 char *kwnames[] = {
17002 (char *) "self", NULL
17003 };
17004
17005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17007 if (SWIG_arg_fail(1)) SWIG_fail;
17008 {
17009 PyThreadState* __tstate = wxPyBeginAllowThreads();
17010 {
17011 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17012 result = (wxString *) &_result_ref;
17013 }
17014
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 {
17019 #if wxUSE_UNICODE
17020 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17021 #else
17022 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17023 #endif
17024 }
17025 return resultobj;
17026 fail:
17027 return NULL;
17028 }
17029
17030
17031 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17032 PyObject *resultobj;
17033 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17034 PyObject *result;
17035 PyObject * obj0 = 0 ;
17036 char *kwnames[] = {
17037 (char *) "self", NULL
17038 };
17039
17040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17042 if (SWIG_arg_fail(1)) SWIG_fail;
17043 {
17044 PyThreadState* __tstate = wxPyBeginAllowThreads();
17045 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17046
17047 wxPyEndAllowThreads(__tstate);
17048 if (PyErr_Occurred()) SWIG_fail;
17049 }
17050 resultobj = result;
17051 return resultobj;
17052 fail:
17053 return NULL;
17054 }
17055
17056
17057 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj;
17059 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17060 long arg2 ;
17061 PyObject *result;
17062 PyObject * obj0 = 0 ;
17063 PyObject * obj1 = 0 ;
17064 char *kwnames[] = {
17065 (char *) "self",(char *) "index", NULL
17066 };
17067
17068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17070 if (SWIG_arg_fail(1)) SWIG_fail;
17071 {
17072 arg2 = (long)(SWIG_As_long(obj1));
17073 if (SWIG_arg_fail(2)) SWIG_fail;
17074 }
17075 {
17076 PyThreadState* __tstate = wxPyBeginAllowThreads();
17077 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17078
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 resultobj = result;
17083 return resultobj;
17084 fail:
17085 return NULL;
17086 }
17087
17088
17089 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17090 PyObject *resultobj;
17091 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17092 PyObject *result;
17093 PyObject * obj0 = 0 ;
17094 char *kwnames[] = {
17095 (char *) "self", NULL
17096 };
17097
17098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
17103 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17104
17105 wxPyEndAllowThreads(__tstate);
17106 if (PyErr_Occurred()) SWIG_fail;
17107 }
17108 resultobj = result;
17109 return resultobj;
17110 fail:
17111 return NULL;
17112 }
17113
17114
17115 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17116 PyObject *resultobj;
17117 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17118 long arg2 ;
17119 PyObject *result;
17120 PyObject * obj0 = 0 ;
17121 PyObject * obj1 = 0 ;
17122 char *kwnames[] = {
17123 (char *) "self",(char *) "index", NULL
17124 };
17125
17126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17128 if (SWIG_arg_fail(1)) SWIG_fail;
17129 {
17130 arg2 = (long)(SWIG_As_long(obj1));
17131 if (SWIG_arg_fail(2)) SWIG_fail;
17132 }
17133 {
17134 PyThreadState* __tstate = wxPyBeginAllowThreads();
17135 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17136
17137 wxPyEndAllowThreads(__tstate);
17138 if (PyErr_Occurred()) SWIG_fail;
17139 }
17140 resultobj = result;
17141 return resultobj;
17142 fail:
17143 return NULL;
17144 }
17145
17146
17147 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17148 PyObject *resultobj;
17149 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17150 bool arg2 = (bool) false ;
17151 size_t result;
17152 PyObject * obj0 = 0 ;
17153 PyObject * obj1 = 0 ;
17154 char *kwnames[] = {
17155 (char *) "self",(char *) "recursive", NULL
17156 };
17157
17158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17160 if (SWIG_arg_fail(1)) SWIG_fail;
17161 if (obj1) {
17162 {
17163 arg2 = (bool)(SWIG_As_bool(obj1));
17164 if (SWIG_arg_fail(2)) SWIG_fail;
17165 }
17166 }
17167 {
17168 PyThreadState* __tstate = wxPyBeginAllowThreads();
17169 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17170
17171 wxPyEndAllowThreads(__tstate);
17172 if (PyErr_Occurred()) SWIG_fail;
17173 }
17174 {
17175 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17176 }
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17184 PyObject *resultobj;
17185 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17186 bool arg2 = (bool) false ;
17187 size_t result;
17188 PyObject * obj0 = 0 ;
17189 PyObject * obj1 = 0 ;
17190 char *kwnames[] = {
17191 (char *) "self",(char *) "recursive", NULL
17192 };
17193
17194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17196 if (SWIG_arg_fail(1)) SWIG_fail;
17197 if (obj1) {
17198 {
17199 arg2 = (bool)(SWIG_As_bool(obj1));
17200 if (SWIG_arg_fail(2)) SWIG_fail;
17201 }
17202 }
17203 {
17204 PyThreadState* __tstate = wxPyBeginAllowThreads();
17205 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17206
17207 wxPyEndAllowThreads(__tstate);
17208 if (PyErr_Occurred()) SWIG_fail;
17209 }
17210 {
17211 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17212 }
17213 return resultobj;
17214 fail:
17215 return NULL;
17216 }
17217
17218
17219 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17220 PyObject *resultobj;
17221 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17222 wxString *arg2 = 0 ;
17223 bool result;
17224 bool temp2 = false ;
17225 PyObject * obj0 = 0 ;
17226 PyObject * obj1 = 0 ;
17227 char *kwnames[] = {
17228 (char *) "self",(char *) "name", NULL
17229 };
17230
17231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17233 if (SWIG_arg_fail(1)) SWIG_fail;
17234 {
17235 arg2 = wxString_in_helper(obj1);
17236 if (arg2 == NULL) SWIG_fail;
17237 temp2 = true;
17238 }
17239 {
17240 PyThreadState* __tstate = wxPyBeginAllowThreads();
17241 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17242
17243 wxPyEndAllowThreads(__tstate);
17244 if (PyErr_Occurred()) SWIG_fail;
17245 }
17246 {
17247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17248 }
17249 {
17250 if (temp2)
17251 delete arg2;
17252 }
17253 return resultobj;
17254 fail:
17255 {
17256 if (temp2)
17257 delete arg2;
17258 }
17259 return NULL;
17260 }
17261
17262
17263 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17264 PyObject *resultobj;
17265 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17266 wxString *arg2 = 0 ;
17267 bool result;
17268 bool temp2 = false ;
17269 PyObject * obj0 = 0 ;
17270 PyObject * obj1 = 0 ;
17271 char *kwnames[] = {
17272 (char *) "self",(char *) "name", NULL
17273 };
17274
17275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17277 if (SWIG_arg_fail(1)) SWIG_fail;
17278 {
17279 arg2 = wxString_in_helper(obj1);
17280 if (arg2 == NULL) SWIG_fail;
17281 temp2 = true;
17282 }
17283 {
17284 PyThreadState* __tstate = wxPyBeginAllowThreads();
17285 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17286
17287 wxPyEndAllowThreads(__tstate);
17288 if (PyErr_Occurred()) SWIG_fail;
17289 }
17290 {
17291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17292 }
17293 {
17294 if (temp2)
17295 delete arg2;
17296 }
17297 return resultobj;
17298 fail:
17299 {
17300 if (temp2)
17301 delete arg2;
17302 }
17303 return NULL;
17304 }
17305
17306
17307 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj;
17309 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17310 wxString *arg2 = 0 ;
17311 bool result;
17312 bool temp2 = false ;
17313 PyObject * obj0 = 0 ;
17314 PyObject * obj1 = 0 ;
17315 char *kwnames[] = {
17316 (char *) "self",(char *) "name", NULL
17317 };
17318
17319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17321 if (SWIG_arg_fail(1)) SWIG_fail;
17322 {
17323 arg2 = wxString_in_helper(obj1);
17324 if (arg2 == NULL) SWIG_fail;
17325 temp2 = true;
17326 }
17327 {
17328 PyThreadState* __tstate = wxPyBeginAllowThreads();
17329 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17330
17331 wxPyEndAllowThreads(__tstate);
17332 if (PyErr_Occurred()) SWIG_fail;
17333 }
17334 {
17335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17336 }
17337 {
17338 if (temp2)
17339 delete arg2;
17340 }
17341 return resultobj;
17342 fail:
17343 {
17344 if (temp2)
17345 delete arg2;
17346 }
17347 return NULL;
17348 }
17349
17350
17351 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17352 PyObject *resultobj;
17353 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17354 wxString *arg2 = 0 ;
17355 wxConfigBase::EntryType result;
17356 bool temp2 = false ;
17357 PyObject * obj0 = 0 ;
17358 PyObject * obj1 = 0 ;
17359 char *kwnames[] = {
17360 (char *) "self",(char *) "name", NULL
17361 };
17362
17363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17365 if (SWIG_arg_fail(1)) SWIG_fail;
17366 {
17367 arg2 = wxString_in_helper(obj1);
17368 if (arg2 == NULL) SWIG_fail;
17369 temp2 = true;
17370 }
17371 {
17372 PyThreadState* __tstate = wxPyBeginAllowThreads();
17373 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17374
17375 wxPyEndAllowThreads(__tstate);
17376 if (PyErr_Occurred()) SWIG_fail;
17377 }
17378 resultobj = SWIG_From_int((result));
17379 {
17380 if (temp2)
17381 delete arg2;
17382 }
17383 return resultobj;
17384 fail:
17385 {
17386 if (temp2)
17387 delete arg2;
17388 }
17389 return NULL;
17390 }
17391
17392
17393 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17394 PyObject *resultobj;
17395 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17396 wxString *arg2 = 0 ;
17397 wxString const &arg3_defvalue = wxPyEmptyString ;
17398 wxString *arg3 = (wxString *) &arg3_defvalue ;
17399 wxString result;
17400 bool temp2 = false ;
17401 bool temp3 = false ;
17402 PyObject * obj0 = 0 ;
17403 PyObject * obj1 = 0 ;
17404 PyObject * obj2 = 0 ;
17405 char *kwnames[] = {
17406 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17407 };
17408
17409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) 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 {
17413 arg2 = wxString_in_helper(obj1);
17414 if (arg2 == NULL) SWIG_fail;
17415 temp2 = true;
17416 }
17417 if (obj2) {
17418 {
17419 arg3 = wxString_in_helper(obj2);
17420 if (arg3 == NULL) SWIG_fail;
17421 temp3 = true;
17422 }
17423 }
17424 {
17425 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17427
17428 wxPyEndAllowThreads(__tstate);
17429 if (PyErr_Occurred()) SWIG_fail;
17430 }
17431 {
17432 #if wxUSE_UNICODE
17433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17434 #else
17435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17436 #endif
17437 }
17438 {
17439 if (temp2)
17440 delete arg2;
17441 }
17442 {
17443 if (temp3)
17444 delete arg3;
17445 }
17446 return resultobj;
17447 fail:
17448 {
17449 if (temp2)
17450 delete arg2;
17451 }
17452 {
17453 if (temp3)
17454 delete arg3;
17455 }
17456 return NULL;
17457 }
17458
17459
17460 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17461 PyObject *resultobj;
17462 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17463 wxString *arg2 = 0 ;
17464 long arg3 = (long) 0 ;
17465 long result;
17466 bool temp2 = false ;
17467 PyObject * obj0 = 0 ;
17468 PyObject * obj1 = 0 ;
17469 PyObject * obj2 = 0 ;
17470 char *kwnames[] = {
17471 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17472 };
17473
17474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17476 if (SWIG_arg_fail(1)) SWIG_fail;
17477 {
17478 arg2 = wxString_in_helper(obj1);
17479 if (arg2 == NULL) SWIG_fail;
17480 temp2 = true;
17481 }
17482 if (obj2) {
17483 {
17484 arg3 = (long)(SWIG_As_long(obj2));
17485 if (SWIG_arg_fail(3)) SWIG_fail;
17486 }
17487 }
17488 {
17489 PyThreadState* __tstate = wxPyBeginAllowThreads();
17490 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17491
17492 wxPyEndAllowThreads(__tstate);
17493 if (PyErr_Occurred()) SWIG_fail;
17494 }
17495 {
17496 resultobj = SWIG_From_long((long)(result));
17497 }
17498 {
17499 if (temp2)
17500 delete arg2;
17501 }
17502 return resultobj;
17503 fail:
17504 {
17505 if (temp2)
17506 delete arg2;
17507 }
17508 return NULL;
17509 }
17510
17511
17512 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17513 PyObject *resultobj;
17514 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17515 wxString *arg2 = 0 ;
17516 double arg3 = (double) 0.0 ;
17517 double result;
17518 bool temp2 = false ;
17519 PyObject * obj0 = 0 ;
17520 PyObject * obj1 = 0 ;
17521 PyObject * obj2 = 0 ;
17522 char *kwnames[] = {
17523 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17524 };
17525
17526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17528 if (SWIG_arg_fail(1)) SWIG_fail;
17529 {
17530 arg2 = wxString_in_helper(obj1);
17531 if (arg2 == NULL) SWIG_fail;
17532 temp2 = true;
17533 }
17534 if (obj2) {
17535 {
17536 arg3 = (double)(SWIG_As_double(obj2));
17537 if (SWIG_arg_fail(3)) SWIG_fail;
17538 }
17539 }
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17543
17544 wxPyEndAllowThreads(__tstate);
17545 if (PyErr_Occurred()) SWIG_fail;
17546 }
17547 {
17548 resultobj = SWIG_From_double((double)(result));
17549 }
17550 {
17551 if (temp2)
17552 delete arg2;
17553 }
17554 return resultobj;
17555 fail:
17556 {
17557 if (temp2)
17558 delete arg2;
17559 }
17560 return NULL;
17561 }
17562
17563
17564 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj;
17566 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17567 wxString *arg2 = 0 ;
17568 bool arg3 = (bool) false ;
17569 bool result;
17570 bool temp2 = false ;
17571 PyObject * obj0 = 0 ;
17572 PyObject * obj1 = 0 ;
17573 PyObject * obj2 = 0 ;
17574 char *kwnames[] = {
17575 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17576 };
17577
17578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17580 if (SWIG_arg_fail(1)) SWIG_fail;
17581 {
17582 arg2 = wxString_in_helper(obj1);
17583 if (arg2 == NULL) SWIG_fail;
17584 temp2 = true;
17585 }
17586 if (obj2) {
17587 {
17588 arg3 = (bool)(SWIG_As_bool(obj2));
17589 if (SWIG_arg_fail(3)) SWIG_fail;
17590 }
17591 }
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17595
17596 wxPyEndAllowThreads(__tstate);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 }
17599 {
17600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17601 }
17602 {
17603 if (temp2)
17604 delete arg2;
17605 }
17606 return resultobj;
17607 fail:
17608 {
17609 if (temp2)
17610 delete arg2;
17611 }
17612 return NULL;
17613 }
17614
17615
17616 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17617 PyObject *resultobj;
17618 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17619 wxString *arg2 = 0 ;
17620 wxString *arg3 = 0 ;
17621 bool result;
17622 bool temp2 = false ;
17623 bool temp3 = false ;
17624 PyObject * obj0 = 0 ;
17625 PyObject * obj1 = 0 ;
17626 PyObject * obj2 = 0 ;
17627 char *kwnames[] = {
17628 (char *) "self",(char *) "key",(char *) "value", NULL
17629 };
17630
17631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17633 if (SWIG_arg_fail(1)) SWIG_fail;
17634 {
17635 arg2 = wxString_in_helper(obj1);
17636 if (arg2 == NULL) SWIG_fail;
17637 temp2 = true;
17638 }
17639 {
17640 arg3 = wxString_in_helper(obj2);
17641 if (arg3 == NULL) SWIG_fail;
17642 temp3 = true;
17643 }
17644 {
17645 PyThreadState* __tstate = wxPyBeginAllowThreads();
17646 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17647
17648 wxPyEndAllowThreads(__tstate);
17649 if (PyErr_Occurred()) SWIG_fail;
17650 }
17651 {
17652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17653 }
17654 {
17655 if (temp2)
17656 delete arg2;
17657 }
17658 {
17659 if (temp3)
17660 delete arg3;
17661 }
17662 return resultobj;
17663 fail:
17664 {
17665 if (temp2)
17666 delete arg2;
17667 }
17668 {
17669 if (temp3)
17670 delete arg3;
17671 }
17672 return NULL;
17673 }
17674
17675
17676 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17677 PyObject *resultobj;
17678 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17679 wxString *arg2 = 0 ;
17680 long arg3 ;
17681 bool result;
17682 bool temp2 = false ;
17683 PyObject * obj0 = 0 ;
17684 PyObject * obj1 = 0 ;
17685 PyObject * obj2 = 0 ;
17686 char *kwnames[] = {
17687 (char *) "self",(char *) "key",(char *) "value", NULL
17688 };
17689
17690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17692 if (SWIG_arg_fail(1)) SWIG_fail;
17693 {
17694 arg2 = wxString_in_helper(obj1);
17695 if (arg2 == NULL) SWIG_fail;
17696 temp2 = true;
17697 }
17698 {
17699 arg3 = (long)(SWIG_As_long(obj2));
17700 if (SWIG_arg_fail(3)) SWIG_fail;
17701 }
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17705
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 {
17710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17711 }
17712 {
17713 if (temp2)
17714 delete arg2;
17715 }
17716 return resultobj;
17717 fail:
17718 {
17719 if (temp2)
17720 delete arg2;
17721 }
17722 return NULL;
17723 }
17724
17725
17726 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17727 PyObject *resultobj;
17728 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17729 wxString *arg2 = 0 ;
17730 double arg3 ;
17731 bool result;
17732 bool temp2 = false ;
17733 PyObject * obj0 = 0 ;
17734 PyObject * obj1 = 0 ;
17735 PyObject * obj2 = 0 ;
17736 char *kwnames[] = {
17737 (char *) "self",(char *) "key",(char *) "value", NULL
17738 };
17739
17740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17742 if (SWIG_arg_fail(1)) SWIG_fail;
17743 {
17744 arg2 = wxString_in_helper(obj1);
17745 if (arg2 == NULL) SWIG_fail;
17746 temp2 = true;
17747 }
17748 {
17749 arg3 = (double)(SWIG_As_double(obj2));
17750 if (SWIG_arg_fail(3)) SWIG_fail;
17751 }
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17755
17756 wxPyEndAllowThreads(__tstate);
17757 if (PyErr_Occurred()) SWIG_fail;
17758 }
17759 {
17760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17761 }
17762 {
17763 if (temp2)
17764 delete arg2;
17765 }
17766 return resultobj;
17767 fail:
17768 {
17769 if (temp2)
17770 delete arg2;
17771 }
17772 return NULL;
17773 }
17774
17775
17776 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17777 PyObject *resultobj;
17778 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17779 wxString *arg2 = 0 ;
17780 bool arg3 ;
17781 bool result;
17782 bool temp2 = false ;
17783 PyObject * obj0 = 0 ;
17784 PyObject * obj1 = 0 ;
17785 PyObject * obj2 = 0 ;
17786 char *kwnames[] = {
17787 (char *) "self",(char *) "key",(char *) "value", NULL
17788 };
17789
17790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17792 if (SWIG_arg_fail(1)) SWIG_fail;
17793 {
17794 arg2 = wxString_in_helper(obj1);
17795 if (arg2 == NULL) SWIG_fail;
17796 temp2 = true;
17797 }
17798 {
17799 arg3 = (bool)(SWIG_As_bool(obj2));
17800 if (SWIG_arg_fail(3)) SWIG_fail;
17801 }
17802 {
17803 PyThreadState* __tstate = wxPyBeginAllowThreads();
17804 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17805
17806 wxPyEndAllowThreads(__tstate);
17807 if (PyErr_Occurred()) SWIG_fail;
17808 }
17809 {
17810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17811 }
17812 {
17813 if (temp2)
17814 delete arg2;
17815 }
17816 return resultobj;
17817 fail:
17818 {
17819 if (temp2)
17820 delete arg2;
17821 }
17822 return NULL;
17823 }
17824
17825
17826 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17827 PyObject *resultobj;
17828 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17829 bool arg2 = (bool) false ;
17830 bool result;
17831 PyObject * obj0 = 0 ;
17832 PyObject * obj1 = 0 ;
17833 char *kwnames[] = {
17834 (char *) "self",(char *) "currentOnly", NULL
17835 };
17836
17837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17839 if (SWIG_arg_fail(1)) SWIG_fail;
17840 if (obj1) {
17841 {
17842 arg2 = (bool)(SWIG_As_bool(obj1));
17843 if (SWIG_arg_fail(2)) SWIG_fail;
17844 }
17845 }
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = (bool)(arg1)->Flush(arg2);
17849
17850 wxPyEndAllowThreads(__tstate);
17851 if (PyErr_Occurred()) SWIG_fail;
17852 }
17853 {
17854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17855 }
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17863 PyObject *resultobj;
17864 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17865 wxString *arg2 = 0 ;
17866 wxString *arg3 = 0 ;
17867 bool result;
17868 bool temp2 = false ;
17869 bool temp3 = false ;
17870 PyObject * obj0 = 0 ;
17871 PyObject * obj1 = 0 ;
17872 PyObject * obj2 = 0 ;
17873 char *kwnames[] = {
17874 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17875 };
17876
17877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17879 if (SWIG_arg_fail(1)) SWIG_fail;
17880 {
17881 arg2 = wxString_in_helper(obj1);
17882 if (arg2 == NULL) SWIG_fail;
17883 temp2 = true;
17884 }
17885 {
17886 arg3 = wxString_in_helper(obj2);
17887 if (arg3 == NULL) SWIG_fail;
17888 temp3 = true;
17889 }
17890 {
17891 PyThreadState* __tstate = wxPyBeginAllowThreads();
17892 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17893
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 {
17898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17899 }
17900 {
17901 if (temp2)
17902 delete arg2;
17903 }
17904 {
17905 if (temp3)
17906 delete arg3;
17907 }
17908 return resultobj;
17909 fail:
17910 {
17911 if (temp2)
17912 delete arg2;
17913 }
17914 {
17915 if (temp3)
17916 delete arg3;
17917 }
17918 return NULL;
17919 }
17920
17921
17922 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17923 PyObject *resultobj;
17924 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17925 wxString *arg2 = 0 ;
17926 wxString *arg3 = 0 ;
17927 bool result;
17928 bool temp2 = false ;
17929 bool temp3 = false ;
17930 PyObject * obj0 = 0 ;
17931 PyObject * obj1 = 0 ;
17932 PyObject * obj2 = 0 ;
17933 char *kwnames[] = {
17934 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17935 };
17936
17937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17939 if (SWIG_arg_fail(1)) SWIG_fail;
17940 {
17941 arg2 = wxString_in_helper(obj1);
17942 if (arg2 == NULL) SWIG_fail;
17943 temp2 = true;
17944 }
17945 {
17946 arg3 = wxString_in_helper(obj2);
17947 if (arg3 == NULL) SWIG_fail;
17948 temp3 = true;
17949 }
17950 {
17951 PyThreadState* __tstate = wxPyBeginAllowThreads();
17952 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17953
17954 wxPyEndAllowThreads(__tstate);
17955 if (PyErr_Occurred()) SWIG_fail;
17956 }
17957 {
17958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17959 }
17960 {
17961 if (temp2)
17962 delete arg2;
17963 }
17964 {
17965 if (temp3)
17966 delete arg3;
17967 }
17968 return resultobj;
17969 fail:
17970 {
17971 if (temp2)
17972 delete arg2;
17973 }
17974 {
17975 if (temp3)
17976 delete arg3;
17977 }
17978 return NULL;
17979 }
17980
17981
17982 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17983 PyObject *resultobj;
17984 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17985 wxString *arg2 = 0 ;
17986 bool arg3 = (bool) true ;
17987 bool result;
17988 bool temp2 = false ;
17989 PyObject * obj0 = 0 ;
17990 PyObject * obj1 = 0 ;
17991 PyObject * obj2 = 0 ;
17992 char *kwnames[] = {
17993 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17994 };
17995
17996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17998 if (SWIG_arg_fail(1)) SWIG_fail;
17999 {
18000 arg2 = wxString_in_helper(obj1);
18001 if (arg2 == NULL) SWIG_fail;
18002 temp2 = true;
18003 }
18004 if (obj2) {
18005 {
18006 arg3 = (bool)(SWIG_As_bool(obj2));
18007 if (SWIG_arg_fail(3)) SWIG_fail;
18008 }
18009 }
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18013
18014 wxPyEndAllowThreads(__tstate);
18015 if (PyErr_Occurred()) SWIG_fail;
18016 }
18017 {
18018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18019 }
18020 {
18021 if (temp2)
18022 delete arg2;
18023 }
18024 return resultobj;
18025 fail:
18026 {
18027 if (temp2)
18028 delete arg2;
18029 }
18030 return NULL;
18031 }
18032
18033
18034 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18035 PyObject *resultobj;
18036 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18037 wxString *arg2 = 0 ;
18038 bool result;
18039 bool temp2 = false ;
18040 PyObject * obj0 = 0 ;
18041 PyObject * obj1 = 0 ;
18042 char *kwnames[] = {
18043 (char *) "self",(char *) "key", NULL
18044 };
18045
18046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18048 if (SWIG_arg_fail(1)) SWIG_fail;
18049 {
18050 arg2 = wxString_in_helper(obj1);
18051 if (arg2 == NULL) SWIG_fail;
18052 temp2 = true;
18053 }
18054 {
18055 PyThreadState* __tstate = wxPyBeginAllowThreads();
18056 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18057
18058 wxPyEndAllowThreads(__tstate);
18059 if (PyErr_Occurred()) SWIG_fail;
18060 }
18061 {
18062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18063 }
18064 {
18065 if (temp2)
18066 delete arg2;
18067 }
18068 return resultobj;
18069 fail:
18070 {
18071 if (temp2)
18072 delete arg2;
18073 }
18074 return NULL;
18075 }
18076
18077
18078 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18079 PyObject *resultobj;
18080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18081 bool result;
18082 PyObject * obj0 = 0 ;
18083 char *kwnames[] = {
18084 (char *) "self", NULL
18085 };
18086
18087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18089 if (SWIG_arg_fail(1)) SWIG_fail;
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 result = (bool)(arg1)->DeleteAll();
18093
18094 wxPyEndAllowThreads(__tstate);
18095 if (PyErr_Occurred()) SWIG_fail;
18096 }
18097 {
18098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18099 }
18100 return resultobj;
18101 fail:
18102 return NULL;
18103 }
18104
18105
18106 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18107 PyObject *resultobj;
18108 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18109 bool arg2 = (bool) true ;
18110 PyObject * obj0 = 0 ;
18111 PyObject * obj1 = 0 ;
18112 char *kwnames[] = {
18113 (char *) "self",(char *) "doIt", NULL
18114 };
18115
18116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18118 if (SWIG_arg_fail(1)) SWIG_fail;
18119 if (obj1) {
18120 {
18121 arg2 = (bool)(SWIG_As_bool(obj1));
18122 if (SWIG_arg_fail(2)) SWIG_fail;
18123 }
18124 }
18125 {
18126 PyThreadState* __tstate = wxPyBeginAllowThreads();
18127 (arg1)->SetExpandEnvVars(arg2);
18128
18129 wxPyEndAllowThreads(__tstate);
18130 if (PyErr_Occurred()) SWIG_fail;
18131 }
18132 Py_INCREF(Py_None); resultobj = Py_None;
18133 return resultobj;
18134 fail:
18135 return NULL;
18136 }
18137
18138
18139 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18140 PyObject *resultobj;
18141 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18142 bool result;
18143 PyObject * obj0 = 0 ;
18144 char *kwnames[] = {
18145 (char *) "self", NULL
18146 };
18147
18148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18150 if (SWIG_arg_fail(1)) SWIG_fail;
18151 {
18152 PyThreadState* __tstate = wxPyBeginAllowThreads();
18153 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18154
18155 wxPyEndAllowThreads(__tstate);
18156 if (PyErr_Occurred()) SWIG_fail;
18157 }
18158 {
18159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18160 }
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18168 PyObject *resultobj;
18169 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18170 bool arg2 = (bool) true ;
18171 PyObject * obj0 = 0 ;
18172 PyObject * obj1 = 0 ;
18173 char *kwnames[] = {
18174 (char *) "self",(char *) "doIt", NULL
18175 };
18176
18177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18179 if (SWIG_arg_fail(1)) SWIG_fail;
18180 if (obj1) {
18181 {
18182 arg2 = (bool)(SWIG_As_bool(obj1));
18183 if (SWIG_arg_fail(2)) SWIG_fail;
18184 }
18185 }
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 (arg1)->SetRecordDefaults(arg2);
18189
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 Py_INCREF(Py_None); resultobj = Py_None;
18194 return resultobj;
18195 fail:
18196 return NULL;
18197 }
18198
18199
18200 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18201 PyObject *resultobj;
18202 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18203 bool result;
18204 PyObject * obj0 = 0 ;
18205 char *kwnames[] = {
18206 (char *) "self", NULL
18207 };
18208
18209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18211 if (SWIG_arg_fail(1)) SWIG_fail;
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18215
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 {
18220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18221 }
18222 return resultobj;
18223 fail:
18224 return NULL;
18225 }
18226
18227
18228 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18229 PyObject *resultobj;
18230 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18231 wxString *arg2 = 0 ;
18232 wxString result;
18233 bool temp2 = false ;
18234 PyObject * obj0 = 0 ;
18235 PyObject * obj1 = 0 ;
18236 char *kwnames[] = {
18237 (char *) "self",(char *) "str", NULL
18238 };
18239
18240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(1)) SWIG_fail;
18243 {
18244 arg2 = wxString_in_helper(obj1);
18245 if (arg2 == NULL) SWIG_fail;
18246 temp2 = true;
18247 }
18248 {
18249 PyThreadState* __tstate = wxPyBeginAllowThreads();
18250 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18251
18252 wxPyEndAllowThreads(__tstate);
18253 if (PyErr_Occurred()) SWIG_fail;
18254 }
18255 {
18256 #if wxUSE_UNICODE
18257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18258 #else
18259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18260 #endif
18261 }
18262 {
18263 if (temp2)
18264 delete arg2;
18265 }
18266 return resultobj;
18267 fail:
18268 {
18269 if (temp2)
18270 delete arg2;
18271 }
18272 return NULL;
18273 }
18274
18275
18276 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18277 PyObject *resultobj;
18278 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18279 wxString result;
18280 PyObject * obj0 = 0 ;
18281 char *kwnames[] = {
18282 (char *) "self", NULL
18283 };
18284
18285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18287 if (SWIG_arg_fail(1)) SWIG_fail;
18288 {
18289 PyThreadState* __tstate = wxPyBeginAllowThreads();
18290 result = ((wxConfigBase const *)arg1)->GetAppName();
18291
18292 wxPyEndAllowThreads(__tstate);
18293 if (PyErr_Occurred()) SWIG_fail;
18294 }
18295 {
18296 #if wxUSE_UNICODE
18297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18298 #else
18299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18300 #endif
18301 }
18302 return resultobj;
18303 fail:
18304 return NULL;
18305 }
18306
18307
18308 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18309 PyObject *resultobj;
18310 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18311 wxString result;
18312 PyObject * obj0 = 0 ;
18313 char *kwnames[] = {
18314 (char *) "self", NULL
18315 };
18316
18317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18319 if (SWIG_arg_fail(1)) SWIG_fail;
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 result = ((wxConfigBase const *)arg1)->GetVendorName();
18323
18324 wxPyEndAllowThreads(__tstate);
18325 if (PyErr_Occurred()) SWIG_fail;
18326 }
18327 {
18328 #if wxUSE_UNICODE
18329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18330 #else
18331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18332 #endif
18333 }
18334 return resultobj;
18335 fail:
18336 return NULL;
18337 }
18338
18339
18340 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18341 PyObject *resultobj;
18342 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18343 wxString *arg2 = 0 ;
18344 bool temp2 = false ;
18345 PyObject * obj0 = 0 ;
18346 PyObject * obj1 = 0 ;
18347 char *kwnames[] = {
18348 (char *) "self",(char *) "appName", NULL
18349 };
18350
18351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18353 if (SWIG_arg_fail(1)) SWIG_fail;
18354 {
18355 arg2 = wxString_in_helper(obj1);
18356 if (arg2 == NULL) SWIG_fail;
18357 temp2 = true;
18358 }
18359 {
18360 PyThreadState* __tstate = wxPyBeginAllowThreads();
18361 (arg1)->SetAppName((wxString const &)*arg2);
18362
18363 wxPyEndAllowThreads(__tstate);
18364 if (PyErr_Occurred()) SWIG_fail;
18365 }
18366 Py_INCREF(Py_None); resultobj = Py_None;
18367 {
18368 if (temp2)
18369 delete arg2;
18370 }
18371 return resultobj;
18372 fail:
18373 {
18374 if (temp2)
18375 delete arg2;
18376 }
18377 return NULL;
18378 }
18379
18380
18381 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18382 PyObject *resultobj;
18383 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18384 wxString *arg2 = 0 ;
18385 bool temp2 = false ;
18386 PyObject * obj0 = 0 ;
18387 PyObject * obj1 = 0 ;
18388 char *kwnames[] = {
18389 (char *) "self",(char *) "vendorName", NULL
18390 };
18391
18392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18394 if (SWIG_arg_fail(1)) SWIG_fail;
18395 {
18396 arg2 = wxString_in_helper(obj1);
18397 if (arg2 == NULL) SWIG_fail;
18398 temp2 = true;
18399 }
18400 {
18401 PyThreadState* __tstate = wxPyBeginAllowThreads();
18402 (arg1)->SetVendorName((wxString const &)*arg2);
18403
18404 wxPyEndAllowThreads(__tstate);
18405 if (PyErr_Occurred()) SWIG_fail;
18406 }
18407 Py_INCREF(Py_None); resultobj = Py_None;
18408 {
18409 if (temp2)
18410 delete arg2;
18411 }
18412 return resultobj;
18413 fail:
18414 {
18415 if (temp2)
18416 delete arg2;
18417 }
18418 return NULL;
18419 }
18420
18421
18422 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18423 PyObject *resultobj;
18424 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18425 long arg2 ;
18426 PyObject * obj0 = 0 ;
18427 PyObject * obj1 = 0 ;
18428 char *kwnames[] = {
18429 (char *) "self",(char *) "style", NULL
18430 };
18431
18432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18434 if (SWIG_arg_fail(1)) SWIG_fail;
18435 {
18436 arg2 = (long)(SWIG_As_long(obj1));
18437 if (SWIG_arg_fail(2)) SWIG_fail;
18438 }
18439 {
18440 PyThreadState* __tstate = wxPyBeginAllowThreads();
18441 (arg1)->SetStyle(arg2);
18442
18443 wxPyEndAllowThreads(__tstate);
18444 if (PyErr_Occurred()) SWIG_fail;
18445 }
18446 Py_INCREF(Py_None); resultobj = Py_None;
18447 return resultobj;
18448 fail:
18449 return NULL;
18450 }
18451
18452
18453 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18454 PyObject *resultobj;
18455 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18456 long result;
18457 PyObject * obj0 = 0 ;
18458 char *kwnames[] = {
18459 (char *) "self", NULL
18460 };
18461
18462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18464 if (SWIG_arg_fail(1)) SWIG_fail;
18465 {
18466 PyThreadState* __tstate = wxPyBeginAllowThreads();
18467 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18468
18469 wxPyEndAllowThreads(__tstate);
18470 if (PyErr_Occurred()) SWIG_fail;
18471 }
18472 {
18473 resultobj = SWIG_From_long((long)(result));
18474 }
18475 return resultobj;
18476 fail:
18477 return NULL;
18478 }
18479
18480
18481 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18482 PyObject *obj;
18483 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18484 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18485 Py_INCREF(obj);
18486 return Py_BuildValue((char *)"");
18487 }
18488 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18489 PyObject *resultobj;
18490 wxString const &arg1_defvalue = wxPyEmptyString ;
18491 wxString *arg1 = (wxString *) &arg1_defvalue ;
18492 wxString const &arg2_defvalue = wxPyEmptyString ;
18493 wxString *arg2 = (wxString *) &arg2_defvalue ;
18494 wxString const &arg3_defvalue = wxPyEmptyString ;
18495 wxString *arg3 = (wxString *) &arg3_defvalue ;
18496 wxString const &arg4_defvalue = wxPyEmptyString ;
18497 wxString *arg4 = (wxString *) &arg4_defvalue ;
18498 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18499 wxConfig *result;
18500 bool temp1 = false ;
18501 bool temp2 = false ;
18502 bool temp3 = false ;
18503 bool temp4 = false ;
18504 PyObject * obj0 = 0 ;
18505 PyObject * obj1 = 0 ;
18506 PyObject * obj2 = 0 ;
18507 PyObject * obj3 = 0 ;
18508 PyObject * obj4 = 0 ;
18509 char *kwnames[] = {
18510 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18511 };
18512
18513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18514 if (obj0) {
18515 {
18516 arg1 = wxString_in_helper(obj0);
18517 if (arg1 == NULL) SWIG_fail;
18518 temp1 = true;
18519 }
18520 }
18521 if (obj1) {
18522 {
18523 arg2 = wxString_in_helper(obj1);
18524 if (arg2 == NULL) SWIG_fail;
18525 temp2 = true;
18526 }
18527 }
18528 if (obj2) {
18529 {
18530 arg3 = wxString_in_helper(obj2);
18531 if (arg3 == NULL) SWIG_fail;
18532 temp3 = true;
18533 }
18534 }
18535 if (obj3) {
18536 {
18537 arg4 = wxString_in_helper(obj3);
18538 if (arg4 == NULL) SWIG_fail;
18539 temp4 = true;
18540 }
18541 }
18542 if (obj4) {
18543 {
18544 arg5 = (long)(SWIG_As_long(obj4));
18545 if (SWIG_arg_fail(5)) SWIG_fail;
18546 }
18547 }
18548 {
18549 PyThreadState* __tstate = wxPyBeginAllowThreads();
18550 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18551
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18556 {
18557 if (temp1)
18558 delete arg1;
18559 }
18560 {
18561 if (temp2)
18562 delete arg2;
18563 }
18564 {
18565 if (temp3)
18566 delete arg3;
18567 }
18568 {
18569 if (temp4)
18570 delete arg4;
18571 }
18572 return resultobj;
18573 fail:
18574 {
18575 if (temp1)
18576 delete arg1;
18577 }
18578 {
18579 if (temp2)
18580 delete arg2;
18581 }
18582 {
18583 if (temp3)
18584 delete arg3;
18585 }
18586 {
18587 if (temp4)
18588 delete arg4;
18589 }
18590 return NULL;
18591 }
18592
18593
18594 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18595 PyObject *resultobj;
18596 wxConfig *arg1 = (wxConfig *) 0 ;
18597 PyObject * obj0 = 0 ;
18598 char *kwnames[] = {
18599 (char *) "self", NULL
18600 };
18601
18602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18604 if (SWIG_arg_fail(1)) SWIG_fail;
18605 {
18606 PyThreadState* __tstate = wxPyBeginAllowThreads();
18607 delete arg1;
18608
18609 wxPyEndAllowThreads(__tstate);
18610 if (PyErr_Occurred()) SWIG_fail;
18611 }
18612 Py_INCREF(Py_None); resultobj = Py_None;
18613 return resultobj;
18614 fail:
18615 return NULL;
18616 }
18617
18618
18619 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18620 PyObject *obj;
18621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18622 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18623 Py_INCREF(obj);
18624 return Py_BuildValue((char *)"");
18625 }
18626 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18627 PyObject *resultobj;
18628 wxString const &arg1_defvalue = wxPyEmptyString ;
18629 wxString *arg1 = (wxString *) &arg1_defvalue ;
18630 wxString const &arg2_defvalue = wxPyEmptyString ;
18631 wxString *arg2 = (wxString *) &arg2_defvalue ;
18632 wxString const &arg3_defvalue = wxPyEmptyString ;
18633 wxString *arg3 = (wxString *) &arg3_defvalue ;
18634 wxString const &arg4_defvalue = wxPyEmptyString ;
18635 wxString *arg4 = (wxString *) &arg4_defvalue ;
18636 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18637 wxFileConfig *result;
18638 bool temp1 = false ;
18639 bool temp2 = false ;
18640 bool temp3 = false ;
18641 bool temp4 = false ;
18642 PyObject * obj0 = 0 ;
18643 PyObject * obj1 = 0 ;
18644 PyObject * obj2 = 0 ;
18645 PyObject * obj3 = 0 ;
18646 PyObject * obj4 = 0 ;
18647 char *kwnames[] = {
18648 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18649 };
18650
18651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18652 if (obj0) {
18653 {
18654 arg1 = wxString_in_helper(obj0);
18655 if (arg1 == NULL) SWIG_fail;
18656 temp1 = true;
18657 }
18658 }
18659 if (obj1) {
18660 {
18661 arg2 = wxString_in_helper(obj1);
18662 if (arg2 == NULL) SWIG_fail;
18663 temp2 = true;
18664 }
18665 }
18666 if (obj2) {
18667 {
18668 arg3 = wxString_in_helper(obj2);
18669 if (arg3 == NULL) SWIG_fail;
18670 temp3 = true;
18671 }
18672 }
18673 if (obj3) {
18674 {
18675 arg4 = wxString_in_helper(obj3);
18676 if (arg4 == NULL) SWIG_fail;
18677 temp4 = true;
18678 }
18679 }
18680 if (obj4) {
18681 {
18682 arg5 = (long)(SWIG_As_long(obj4));
18683 if (SWIG_arg_fail(5)) SWIG_fail;
18684 }
18685 }
18686 {
18687 PyThreadState* __tstate = wxPyBeginAllowThreads();
18688 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18689
18690 wxPyEndAllowThreads(__tstate);
18691 if (PyErr_Occurred()) SWIG_fail;
18692 }
18693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18694 {
18695 if (temp1)
18696 delete arg1;
18697 }
18698 {
18699 if (temp2)
18700 delete arg2;
18701 }
18702 {
18703 if (temp3)
18704 delete arg3;
18705 }
18706 {
18707 if (temp4)
18708 delete arg4;
18709 }
18710 return resultobj;
18711 fail:
18712 {
18713 if (temp1)
18714 delete arg1;
18715 }
18716 {
18717 if (temp2)
18718 delete arg2;
18719 }
18720 {
18721 if (temp3)
18722 delete arg3;
18723 }
18724 {
18725 if (temp4)
18726 delete arg4;
18727 }
18728 return NULL;
18729 }
18730
18731
18732 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18733 PyObject *resultobj;
18734 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18735 PyObject * obj0 = 0 ;
18736 char *kwnames[] = {
18737 (char *) "self", NULL
18738 };
18739
18740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18742 if (SWIG_arg_fail(1)) SWIG_fail;
18743 {
18744 PyThreadState* __tstate = wxPyBeginAllowThreads();
18745 delete arg1;
18746
18747 wxPyEndAllowThreads(__tstate);
18748 if (PyErr_Occurred()) SWIG_fail;
18749 }
18750 Py_INCREF(Py_None); resultobj = Py_None;
18751 return resultobj;
18752 fail:
18753 return NULL;
18754 }
18755
18756
18757 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18758 PyObject *obj;
18759 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18760 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18761 Py_INCREF(obj);
18762 return Py_BuildValue((char *)"");
18763 }
18764 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18765 PyObject *resultobj;
18766 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18767 wxString *arg2 = 0 ;
18768 wxConfigPathChanger *result;
18769 bool temp2 = false ;
18770 PyObject * obj0 = 0 ;
18771 PyObject * obj1 = 0 ;
18772 char *kwnames[] = {
18773 (char *) "config",(char *) "entry", NULL
18774 };
18775
18776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18778 if (SWIG_arg_fail(1)) SWIG_fail;
18779 {
18780 arg2 = wxString_in_helper(obj1);
18781 if (arg2 == NULL) SWIG_fail;
18782 temp2 = true;
18783 }
18784 {
18785 PyThreadState* __tstate = wxPyBeginAllowThreads();
18786 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18787
18788 wxPyEndAllowThreads(__tstate);
18789 if (PyErr_Occurred()) SWIG_fail;
18790 }
18791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18792 {
18793 if (temp2)
18794 delete arg2;
18795 }
18796 return resultobj;
18797 fail:
18798 {
18799 if (temp2)
18800 delete arg2;
18801 }
18802 return NULL;
18803 }
18804
18805
18806 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj;
18808 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18809 PyObject * obj0 = 0 ;
18810 char *kwnames[] = {
18811 (char *) "self", NULL
18812 };
18813
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18816 if (SWIG_arg_fail(1)) SWIG_fail;
18817 {
18818 PyThreadState* __tstate = wxPyBeginAllowThreads();
18819 delete arg1;
18820
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 Py_INCREF(Py_None); resultobj = Py_None;
18825 return resultobj;
18826 fail:
18827 return NULL;
18828 }
18829
18830
18831 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18832 PyObject *resultobj;
18833 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18834 wxString *result;
18835 PyObject * obj0 = 0 ;
18836 char *kwnames[] = {
18837 (char *) "self", NULL
18838 };
18839
18840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18842 if (SWIG_arg_fail(1)) SWIG_fail;
18843 {
18844 PyThreadState* __tstate = wxPyBeginAllowThreads();
18845 {
18846 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18847 result = (wxString *) &_result_ref;
18848 }
18849
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 {
18854 #if wxUSE_UNICODE
18855 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18856 #else
18857 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18858 #endif
18859 }
18860 return resultobj;
18861 fail:
18862 return NULL;
18863 }
18864
18865
18866 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18867 PyObject *obj;
18868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18869 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18870 Py_INCREF(obj);
18871 return Py_BuildValue((char *)"");
18872 }
18873 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18874 PyObject *resultobj;
18875 wxString *arg1 = 0 ;
18876 wxString result;
18877 bool temp1 = false ;
18878 PyObject * obj0 = 0 ;
18879 char *kwnames[] = {
18880 (char *) "sz", NULL
18881 };
18882
18883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18884 {
18885 arg1 = wxString_in_helper(obj0);
18886 if (arg1 == NULL) SWIG_fail;
18887 temp1 = true;
18888 }
18889 {
18890 PyThreadState* __tstate = wxPyBeginAllowThreads();
18891 result = wxExpandEnvVars((wxString const &)*arg1);
18892
18893 wxPyEndAllowThreads(__tstate);
18894 if (PyErr_Occurred()) SWIG_fail;
18895 }
18896 {
18897 #if wxUSE_UNICODE
18898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18899 #else
18900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18901 #endif
18902 }
18903 {
18904 if (temp1)
18905 delete arg1;
18906 }
18907 return resultobj;
18908 fail:
18909 {
18910 if (temp1)
18911 delete arg1;
18912 }
18913 return NULL;
18914 }
18915
18916
18917 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18918 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18919 return 1;
18920 }
18921
18922
18923 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18924 PyObject *pyobj;
18925
18926 {
18927 #if wxUSE_UNICODE
18928 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18929 #else
18930 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18931 #endif
18932 }
18933 return pyobj;
18934 }
18935
18936
18937 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18938 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18939 return 1;
18940 }
18941
18942
18943 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18944 PyObject *pyobj;
18945
18946 {
18947 #if wxUSE_UNICODE
18948 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18949 #else
18950 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18951 #endif
18952 }
18953 return pyobj;
18954 }
18955
18956
18957 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18958 PyObject *resultobj;
18959 wxDateTime::Country arg1 ;
18960 PyObject * obj0 = 0 ;
18961 char *kwnames[] = {
18962 (char *) "country", NULL
18963 };
18964
18965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18966 {
18967 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18968 if (SWIG_arg_fail(1)) SWIG_fail;
18969 }
18970 {
18971 PyThreadState* __tstate = wxPyBeginAllowThreads();
18972 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18973
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 Py_INCREF(Py_None); resultobj = Py_None;
18978 return resultobj;
18979 fail:
18980 return NULL;
18981 }
18982
18983
18984 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18985 PyObject *resultobj;
18986 wxDateTime::Country result;
18987 char *kwnames[] = {
18988 NULL
18989 };
18990
18991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18992 {
18993 PyThreadState* __tstate = wxPyBeginAllowThreads();
18994 result = (wxDateTime::Country)wxDateTime::GetCountry();
18995
18996 wxPyEndAllowThreads(__tstate);
18997 if (PyErr_Occurred()) SWIG_fail;
18998 }
18999 resultobj = SWIG_From_int((result));
19000 return resultobj;
19001 fail:
19002 return NULL;
19003 }
19004
19005
19006 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19007 PyObject *resultobj;
19008 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19009 bool result;
19010 PyObject * obj0 = 0 ;
19011 char *kwnames[] = {
19012 (char *) "country", NULL
19013 };
19014
19015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19016 if (obj0) {
19017 {
19018 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19019 if (SWIG_arg_fail(1)) SWIG_fail;
19020 }
19021 }
19022 {
19023 PyThreadState* __tstate = wxPyBeginAllowThreads();
19024 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19025
19026 wxPyEndAllowThreads(__tstate);
19027 if (PyErr_Occurred()) SWIG_fail;
19028 }
19029 {
19030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19031 }
19032 return resultobj;
19033 fail:
19034 return NULL;
19035 }
19036
19037
19038 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19039 PyObject *resultobj;
19040 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19041 int result;
19042 PyObject * obj0 = 0 ;
19043 char *kwnames[] = {
19044 (char *) "cal", NULL
19045 };
19046
19047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19048 if (obj0) {
19049 {
19050 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19051 if (SWIG_arg_fail(1)) SWIG_fail;
19052 }
19053 }
19054 {
19055 PyThreadState* __tstate = wxPyBeginAllowThreads();
19056 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19057
19058 wxPyEndAllowThreads(__tstate);
19059 if (PyErr_Occurred()) SWIG_fail;
19060 }
19061 {
19062 resultobj = SWIG_From_int((int)(result));
19063 }
19064 return resultobj;
19065 fail:
19066 return NULL;
19067 }
19068
19069
19070 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19071 PyObject *resultobj;
19072 int arg1 ;
19073 int result;
19074 PyObject * obj0 = 0 ;
19075 char *kwnames[] = {
19076 (char *) "year", NULL
19077 };
19078
19079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19080 {
19081 arg1 = (int)(SWIG_As_int(obj0));
19082 if (SWIG_arg_fail(1)) SWIG_fail;
19083 }
19084 {
19085 PyThreadState* __tstate = wxPyBeginAllowThreads();
19086 result = (int)wxDateTime::ConvertYearToBC(arg1);
19087
19088 wxPyEndAllowThreads(__tstate);
19089 if (PyErr_Occurred()) SWIG_fail;
19090 }
19091 {
19092 resultobj = SWIG_From_int((int)(result));
19093 }
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19101 PyObject *resultobj;
19102 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19103 wxDateTime::Month result;
19104 PyObject * obj0 = 0 ;
19105 char *kwnames[] = {
19106 (char *) "cal", NULL
19107 };
19108
19109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19110 if (obj0) {
19111 {
19112 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19113 if (SWIG_arg_fail(1)) SWIG_fail;
19114 }
19115 }
19116 {
19117 PyThreadState* __tstate = wxPyBeginAllowThreads();
19118 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19119
19120 wxPyEndAllowThreads(__tstate);
19121 if (PyErr_Occurred()) SWIG_fail;
19122 }
19123 resultobj = SWIG_From_int((result));
19124 return resultobj;
19125 fail:
19126 return NULL;
19127 }
19128
19129
19130 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19131 PyObject *resultobj;
19132 int arg1 = (int) wxDateTime::Inv_Year ;
19133 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19134 bool result;
19135 PyObject * obj0 = 0 ;
19136 PyObject * obj1 = 0 ;
19137 char *kwnames[] = {
19138 (char *) "year",(char *) "cal", NULL
19139 };
19140
19141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19142 if (obj0) {
19143 {
19144 arg1 = (int)(SWIG_As_int(obj0));
19145 if (SWIG_arg_fail(1)) SWIG_fail;
19146 }
19147 }
19148 if (obj1) {
19149 {
19150 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19151 if (SWIG_arg_fail(2)) SWIG_fail;
19152 }
19153 }
19154 {
19155 PyThreadState* __tstate = wxPyBeginAllowThreads();
19156 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19157
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 {
19162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19163 }
19164 return resultobj;
19165 fail:
19166 return NULL;
19167 }
19168
19169
19170 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19171 PyObject *resultobj;
19172 int arg1 = (int) wxDateTime::Inv_Year ;
19173 int result;
19174 PyObject * obj0 = 0 ;
19175 char *kwnames[] = {
19176 (char *) "year", NULL
19177 };
19178
19179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19180 if (obj0) {
19181 {
19182 arg1 = (int)(SWIG_As_int(obj0));
19183 if (SWIG_arg_fail(1)) SWIG_fail;
19184 }
19185 }
19186 {
19187 PyThreadState* __tstate = wxPyBeginAllowThreads();
19188 result = (int)wxDateTime::GetCentury(arg1);
19189
19190 wxPyEndAllowThreads(__tstate);
19191 if (PyErr_Occurred()) SWIG_fail;
19192 }
19193 {
19194 resultobj = SWIG_From_int((int)(result));
19195 }
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19203 PyObject *resultobj;
19204 int arg1 ;
19205 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19206 int result;
19207 PyObject * obj0 = 0 ;
19208 PyObject * obj1 = 0 ;
19209 char *kwnames[] = {
19210 (char *) "year",(char *) "cal", NULL
19211 };
19212
19213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19214 {
19215 arg1 = (int)(SWIG_As_int(obj0));
19216 if (SWIG_arg_fail(1)) SWIG_fail;
19217 }
19218 if (obj1) {
19219 {
19220 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19221 if (SWIG_arg_fail(2)) SWIG_fail;
19222 }
19223 }
19224 {
19225 PyThreadState* __tstate = wxPyBeginAllowThreads();
19226 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19227
19228 wxPyEndAllowThreads(__tstate);
19229 if (PyErr_Occurred()) SWIG_fail;
19230 }
19231 {
19232 resultobj = SWIG_From_int((int)(result));
19233 }
19234 return resultobj;
19235 fail:
19236 return NULL;
19237 }
19238
19239
19240 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19241 PyObject *resultobj;
19242 wxDateTime::Month arg1 ;
19243 int arg2 = (int) wxDateTime::Inv_Year ;
19244 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19245 int result;
19246 PyObject * obj0 = 0 ;
19247 PyObject * obj1 = 0 ;
19248 PyObject * obj2 = 0 ;
19249 char *kwnames[] = {
19250 (char *) "month",(char *) "year",(char *) "cal", NULL
19251 };
19252
19253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19254 {
19255 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19256 if (SWIG_arg_fail(1)) SWIG_fail;
19257 }
19258 if (obj1) {
19259 {
19260 arg2 = (int)(SWIG_As_int(obj1));
19261 if (SWIG_arg_fail(2)) SWIG_fail;
19262 }
19263 }
19264 if (obj2) {
19265 {
19266 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19267 if (SWIG_arg_fail(3)) SWIG_fail;
19268 }
19269 }
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19273
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 {
19278 resultobj = SWIG_From_int((int)(result));
19279 }
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19287 PyObject *resultobj;
19288 wxDateTime::Month arg1 ;
19289 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19290 wxString result;
19291 PyObject * obj0 = 0 ;
19292 PyObject * obj1 = 0 ;
19293 char *kwnames[] = {
19294 (char *) "month",(char *) "flags", NULL
19295 };
19296
19297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19298 {
19299 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19300 if (SWIG_arg_fail(1)) SWIG_fail;
19301 }
19302 if (obj1) {
19303 {
19304 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19305 if (SWIG_arg_fail(2)) SWIG_fail;
19306 }
19307 }
19308 {
19309 PyThreadState* __tstate = wxPyBeginAllowThreads();
19310 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19311
19312 wxPyEndAllowThreads(__tstate);
19313 if (PyErr_Occurred()) SWIG_fail;
19314 }
19315 {
19316 #if wxUSE_UNICODE
19317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19318 #else
19319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19320 #endif
19321 }
19322 return resultobj;
19323 fail:
19324 return NULL;
19325 }
19326
19327
19328 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19329 PyObject *resultobj;
19330 wxDateTime::WeekDay arg1 ;
19331 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19332 wxString result;
19333 PyObject * obj0 = 0 ;
19334 PyObject * obj1 = 0 ;
19335 char *kwnames[] = {
19336 (char *) "weekday",(char *) "flags", NULL
19337 };
19338
19339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19340 {
19341 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19342 if (SWIG_arg_fail(1)) SWIG_fail;
19343 }
19344 if (obj1) {
19345 {
19346 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19347 if (SWIG_arg_fail(2)) SWIG_fail;
19348 }
19349 }
19350 {
19351 PyThreadState* __tstate = wxPyBeginAllowThreads();
19352 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19353
19354 wxPyEndAllowThreads(__tstate);
19355 if (PyErr_Occurred()) SWIG_fail;
19356 }
19357 {
19358 #if wxUSE_UNICODE
19359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19360 #else
19361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19362 #endif
19363 }
19364 return resultobj;
19365 fail:
19366 return NULL;
19367 }
19368
19369
19370 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19371 PyObject *resultobj;
19372 PyObject *result;
19373 char *kwnames[] = {
19374 NULL
19375 };
19376
19377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19378 {
19379 PyThreadState* __tstate = wxPyBeginAllowThreads();
19380 result = (PyObject *)DateTime_GetAmPmStrings();
19381
19382 wxPyEndAllowThreads(__tstate);
19383 if (PyErr_Occurred()) SWIG_fail;
19384 }
19385 resultobj = result;
19386 return resultobj;
19387 fail:
19388 return NULL;
19389 }
19390
19391
19392 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19393 PyObject *resultobj;
19394 int arg1 = (int) wxDateTime::Inv_Year ;
19395 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19396 bool result;
19397 PyObject * obj0 = 0 ;
19398 PyObject * obj1 = 0 ;
19399 char *kwnames[] = {
19400 (char *) "year",(char *) "country", NULL
19401 };
19402
19403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19404 if (obj0) {
19405 {
19406 arg1 = (int)(SWIG_As_int(obj0));
19407 if (SWIG_arg_fail(1)) SWIG_fail;
19408 }
19409 }
19410 if (obj1) {
19411 {
19412 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19413 if (SWIG_arg_fail(2)) SWIG_fail;
19414 }
19415 }
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19419
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 {
19424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19425 }
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj;
19434 int arg1 = (int) wxDateTime::Inv_Year ;
19435 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19436 wxDateTime result;
19437 PyObject * obj0 = 0 ;
19438 PyObject * obj1 = 0 ;
19439 char *kwnames[] = {
19440 (char *) "year",(char *) "country", NULL
19441 };
19442
19443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19444 if (obj0) {
19445 {
19446 arg1 = (int)(SWIG_As_int(obj0));
19447 if (SWIG_arg_fail(1)) SWIG_fail;
19448 }
19449 }
19450 if (obj1) {
19451 {
19452 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19453 if (SWIG_arg_fail(2)) SWIG_fail;
19454 }
19455 }
19456 {
19457 PyThreadState* __tstate = wxPyBeginAllowThreads();
19458 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19459
19460 wxPyEndAllowThreads(__tstate);
19461 if (PyErr_Occurred()) SWIG_fail;
19462 }
19463 {
19464 wxDateTime * resultptr;
19465 resultptr = new wxDateTime((wxDateTime &)(result));
19466 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19467 }
19468 return resultobj;
19469 fail:
19470 return NULL;
19471 }
19472
19473
19474 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19475 PyObject *resultobj;
19476 int arg1 = (int) wxDateTime::Inv_Year ;
19477 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19478 wxDateTime result;
19479 PyObject * obj0 = 0 ;
19480 PyObject * obj1 = 0 ;
19481 char *kwnames[] = {
19482 (char *) "year",(char *) "country", NULL
19483 };
19484
19485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19486 if (obj0) {
19487 {
19488 arg1 = (int)(SWIG_As_int(obj0));
19489 if (SWIG_arg_fail(1)) SWIG_fail;
19490 }
19491 }
19492 if (obj1) {
19493 {
19494 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19495 if (SWIG_arg_fail(2)) SWIG_fail;
19496 }
19497 }
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19501
19502 wxPyEndAllowThreads(__tstate);
19503 if (PyErr_Occurred()) SWIG_fail;
19504 }
19505 {
19506 wxDateTime * resultptr;
19507 resultptr = new wxDateTime((wxDateTime &)(result));
19508 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19509 }
19510 return resultobj;
19511 fail:
19512 return NULL;
19513 }
19514
19515
19516 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19517 PyObject *resultobj;
19518 wxDateTime result;
19519 char *kwnames[] = {
19520 NULL
19521 };
19522
19523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19524 {
19525 PyThreadState* __tstate = wxPyBeginAllowThreads();
19526 result = wxDateTime::Now();
19527
19528 wxPyEndAllowThreads(__tstate);
19529 if (PyErr_Occurred()) SWIG_fail;
19530 }
19531 {
19532 wxDateTime * resultptr;
19533 resultptr = new wxDateTime((wxDateTime &)(result));
19534 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19535 }
19536 return resultobj;
19537 fail:
19538 return NULL;
19539 }
19540
19541
19542 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19543 PyObject *resultobj;
19544 wxDateTime result;
19545 char *kwnames[] = {
19546 NULL
19547 };
19548
19549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19550 {
19551 PyThreadState* __tstate = wxPyBeginAllowThreads();
19552 result = wxDateTime::UNow();
19553
19554 wxPyEndAllowThreads(__tstate);
19555 if (PyErr_Occurred()) SWIG_fail;
19556 }
19557 {
19558 wxDateTime * resultptr;
19559 resultptr = new wxDateTime((wxDateTime &)(result));
19560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19561 }
19562 return resultobj;
19563 fail:
19564 return NULL;
19565 }
19566
19567
19568 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19569 PyObject *resultobj;
19570 wxDateTime result;
19571 char *kwnames[] = {
19572 NULL
19573 };
19574
19575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19576 {
19577 PyThreadState* __tstate = wxPyBeginAllowThreads();
19578 result = wxDateTime::Today();
19579
19580 wxPyEndAllowThreads(__tstate);
19581 if (PyErr_Occurred()) SWIG_fail;
19582 }
19583 {
19584 wxDateTime * resultptr;
19585 resultptr = new wxDateTime((wxDateTime &)(result));
19586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19587 }
19588 return resultobj;
19589 fail:
19590 return NULL;
19591 }
19592
19593
19594 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19595 PyObject *resultobj;
19596 wxDateTime *result;
19597 char *kwnames[] = {
19598 NULL
19599 };
19600
19601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 result = (wxDateTime *)new wxDateTime();
19605
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19617 PyObject *resultobj;
19618 time_t arg1 ;
19619 wxDateTime *result;
19620 PyObject * obj0 = 0 ;
19621 char *kwnames[] = {
19622 (char *) "timet", NULL
19623 };
19624
19625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19626 {
19627 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19628 if (SWIG_arg_fail(1)) SWIG_fail;
19629 }
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 result = (wxDateTime *)new wxDateTime(arg1);
19633
19634 wxPyEndAllowThreads(__tstate);
19635 if (PyErr_Occurred()) SWIG_fail;
19636 }
19637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19638 return resultobj;
19639 fail:
19640 return NULL;
19641 }
19642
19643
19644 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19645 PyObject *resultobj;
19646 double arg1 ;
19647 wxDateTime *result;
19648 PyObject * obj0 = 0 ;
19649 char *kwnames[] = {
19650 (char *) "jdn", NULL
19651 };
19652
19653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19654 {
19655 arg1 = (double)(SWIG_As_double(obj0));
19656 if (SWIG_arg_fail(1)) SWIG_fail;
19657 }
19658 {
19659 PyThreadState* __tstate = wxPyBeginAllowThreads();
19660 result = (wxDateTime *)new wxDateTime(arg1);
19661
19662 wxPyEndAllowThreads(__tstate);
19663 if (PyErr_Occurred()) SWIG_fail;
19664 }
19665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19666 return resultobj;
19667 fail:
19668 return NULL;
19669 }
19670
19671
19672 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19673 PyObject *resultobj;
19674 int arg1 ;
19675 int arg2 = (int) 0 ;
19676 int arg3 = (int) 0 ;
19677 int arg4 = (int) 0 ;
19678 wxDateTime *result;
19679 PyObject * obj0 = 0 ;
19680 PyObject * obj1 = 0 ;
19681 PyObject * obj2 = 0 ;
19682 PyObject * obj3 = 0 ;
19683 char *kwnames[] = {
19684 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19685 };
19686
19687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19688 {
19689 arg1 = (int)(SWIG_As_int(obj0));
19690 if (SWIG_arg_fail(1)) SWIG_fail;
19691 }
19692 if (obj1) {
19693 {
19694 arg2 = (int)(SWIG_As_int(obj1));
19695 if (SWIG_arg_fail(2)) SWIG_fail;
19696 }
19697 }
19698 if (obj2) {
19699 {
19700 arg3 = (int)(SWIG_As_int(obj2));
19701 if (SWIG_arg_fail(3)) SWIG_fail;
19702 }
19703 }
19704 if (obj3) {
19705 {
19706 arg4 = (int)(SWIG_As_int(obj3));
19707 if (SWIG_arg_fail(4)) SWIG_fail;
19708 }
19709 }
19710 {
19711 PyThreadState* __tstate = wxPyBeginAllowThreads();
19712 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19713
19714 wxPyEndAllowThreads(__tstate);
19715 if (PyErr_Occurred()) SWIG_fail;
19716 }
19717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19718 return resultobj;
19719 fail:
19720 return NULL;
19721 }
19722
19723
19724 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19725 PyObject *resultobj;
19726 int arg1 ;
19727 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19728 int arg3 = (int) wxDateTime::Inv_Year ;
19729 int arg4 = (int) 0 ;
19730 int arg5 = (int) 0 ;
19731 int arg6 = (int) 0 ;
19732 int arg7 = (int) 0 ;
19733 wxDateTime *result;
19734 PyObject * obj0 = 0 ;
19735 PyObject * obj1 = 0 ;
19736 PyObject * obj2 = 0 ;
19737 PyObject * obj3 = 0 ;
19738 PyObject * obj4 = 0 ;
19739 PyObject * obj5 = 0 ;
19740 PyObject * obj6 = 0 ;
19741 char *kwnames[] = {
19742 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19743 };
19744
19745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19746 {
19747 arg1 = (int)(SWIG_As_int(obj0));
19748 if (SWIG_arg_fail(1)) SWIG_fail;
19749 }
19750 if (obj1) {
19751 {
19752 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19753 if (SWIG_arg_fail(2)) SWIG_fail;
19754 }
19755 }
19756 if (obj2) {
19757 {
19758 arg3 = (int)(SWIG_As_int(obj2));
19759 if (SWIG_arg_fail(3)) SWIG_fail;
19760 }
19761 }
19762 if (obj3) {
19763 {
19764 arg4 = (int)(SWIG_As_int(obj3));
19765 if (SWIG_arg_fail(4)) SWIG_fail;
19766 }
19767 }
19768 if (obj4) {
19769 {
19770 arg5 = (int)(SWIG_As_int(obj4));
19771 if (SWIG_arg_fail(5)) SWIG_fail;
19772 }
19773 }
19774 if (obj5) {
19775 {
19776 arg6 = (int)(SWIG_As_int(obj5));
19777 if (SWIG_arg_fail(6)) SWIG_fail;
19778 }
19779 }
19780 if (obj6) {
19781 {
19782 arg7 = (int)(SWIG_As_int(obj6));
19783 if (SWIG_arg_fail(7)) SWIG_fail;
19784 }
19785 }
19786 {
19787 PyThreadState* __tstate = wxPyBeginAllowThreads();
19788 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19789
19790 wxPyEndAllowThreads(__tstate);
19791 if (PyErr_Occurred()) SWIG_fail;
19792 }
19793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19794 return resultobj;
19795 fail:
19796 return NULL;
19797 }
19798
19799
19800 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19801 PyObject *resultobj;
19802 wxDateTime *arg1 = (wxDateTime *) 0 ;
19803 PyObject * obj0 = 0 ;
19804 char *kwnames[] = {
19805 (char *) "self", NULL
19806 };
19807
19808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19810 if (SWIG_arg_fail(1)) SWIG_fail;
19811 {
19812 PyThreadState* __tstate = wxPyBeginAllowThreads();
19813 delete arg1;
19814
19815 wxPyEndAllowThreads(__tstate);
19816 if (PyErr_Occurred()) SWIG_fail;
19817 }
19818 Py_INCREF(Py_None); resultobj = Py_None;
19819 return resultobj;
19820 fail:
19821 return NULL;
19822 }
19823
19824
19825 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19826 PyObject *resultobj;
19827 wxDateTime *arg1 = (wxDateTime *) 0 ;
19828 wxDateTime *result;
19829 PyObject * obj0 = 0 ;
19830 char *kwnames[] = {
19831 (char *) "self", NULL
19832 };
19833
19834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19836 if (SWIG_arg_fail(1)) SWIG_fail;
19837 {
19838 PyThreadState* __tstate = wxPyBeginAllowThreads();
19839 {
19840 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19841 result = (wxDateTime *) &_result_ref;
19842 }
19843
19844 wxPyEndAllowThreads(__tstate);
19845 if (PyErr_Occurred()) SWIG_fail;
19846 }
19847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19848 return resultobj;
19849 fail:
19850 return NULL;
19851 }
19852
19853
19854 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19855 PyObject *resultobj;
19856 wxDateTime *arg1 = (wxDateTime *) 0 ;
19857 time_t arg2 ;
19858 wxDateTime *result;
19859 PyObject * obj0 = 0 ;
19860 PyObject * obj1 = 0 ;
19861 char *kwnames[] = {
19862 (char *) "self",(char *) "timet", NULL
19863 };
19864
19865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19867 if (SWIG_arg_fail(1)) SWIG_fail;
19868 {
19869 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19870 if (SWIG_arg_fail(2)) SWIG_fail;
19871 }
19872 {
19873 PyThreadState* __tstate = wxPyBeginAllowThreads();
19874 {
19875 wxDateTime &_result_ref = (arg1)->Set(arg2);
19876 result = (wxDateTime *) &_result_ref;
19877 }
19878
19879 wxPyEndAllowThreads(__tstate);
19880 if (PyErr_Occurred()) SWIG_fail;
19881 }
19882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19883 return resultobj;
19884 fail:
19885 return NULL;
19886 }
19887
19888
19889 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19890 PyObject *resultobj;
19891 wxDateTime *arg1 = (wxDateTime *) 0 ;
19892 double arg2 ;
19893 wxDateTime *result;
19894 PyObject * obj0 = 0 ;
19895 PyObject * obj1 = 0 ;
19896 char *kwnames[] = {
19897 (char *) "self",(char *) "jdn", NULL
19898 };
19899
19900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19902 if (SWIG_arg_fail(1)) SWIG_fail;
19903 {
19904 arg2 = (double)(SWIG_As_double(obj1));
19905 if (SWIG_arg_fail(2)) SWIG_fail;
19906 }
19907 {
19908 PyThreadState* __tstate = wxPyBeginAllowThreads();
19909 {
19910 wxDateTime &_result_ref = (arg1)->Set(arg2);
19911 result = (wxDateTime *) &_result_ref;
19912 }
19913
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19925 PyObject *resultobj;
19926 wxDateTime *arg1 = (wxDateTime *) 0 ;
19927 int arg2 ;
19928 int arg3 = (int) 0 ;
19929 int arg4 = (int) 0 ;
19930 int arg5 = (int) 0 ;
19931 wxDateTime *result;
19932 PyObject * obj0 = 0 ;
19933 PyObject * obj1 = 0 ;
19934 PyObject * obj2 = 0 ;
19935 PyObject * obj3 = 0 ;
19936 PyObject * obj4 = 0 ;
19937 char *kwnames[] = {
19938 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19939 };
19940
19941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19943 if (SWIG_arg_fail(1)) SWIG_fail;
19944 {
19945 arg2 = (int)(SWIG_As_int(obj1));
19946 if (SWIG_arg_fail(2)) SWIG_fail;
19947 }
19948 if (obj2) {
19949 {
19950 arg3 = (int)(SWIG_As_int(obj2));
19951 if (SWIG_arg_fail(3)) SWIG_fail;
19952 }
19953 }
19954 if (obj3) {
19955 {
19956 arg4 = (int)(SWIG_As_int(obj3));
19957 if (SWIG_arg_fail(4)) SWIG_fail;
19958 }
19959 }
19960 if (obj4) {
19961 {
19962 arg5 = (int)(SWIG_As_int(obj4));
19963 if (SWIG_arg_fail(5)) SWIG_fail;
19964 }
19965 }
19966 {
19967 PyThreadState* __tstate = wxPyBeginAllowThreads();
19968 {
19969 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19970 result = (wxDateTime *) &_result_ref;
19971 }
19972
19973 wxPyEndAllowThreads(__tstate);
19974 if (PyErr_Occurred()) SWIG_fail;
19975 }
19976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19977 return resultobj;
19978 fail:
19979 return NULL;
19980 }
19981
19982
19983 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19984 PyObject *resultobj;
19985 wxDateTime *arg1 = (wxDateTime *) 0 ;
19986 int arg2 ;
19987 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19988 int arg4 = (int) wxDateTime::Inv_Year ;
19989 int arg5 = (int) 0 ;
19990 int arg6 = (int) 0 ;
19991 int arg7 = (int) 0 ;
19992 int arg8 = (int) 0 ;
19993 wxDateTime *result;
19994 PyObject * obj0 = 0 ;
19995 PyObject * obj1 = 0 ;
19996 PyObject * obj2 = 0 ;
19997 PyObject * obj3 = 0 ;
19998 PyObject * obj4 = 0 ;
19999 PyObject * obj5 = 0 ;
20000 PyObject * obj6 = 0 ;
20001 PyObject * obj7 = 0 ;
20002 char *kwnames[] = {
20003 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20004 };
20005
20006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20008 if (SWIG_arg_fail(1)) SWIG_fail;
20009 {
20010 arg2 = (int)(SWIG_As_int(obj1));
20011 if (SWIG_arg_fail(2)) SWIG_fail;
20012 }
20013 if (obj2) {
20014 {
20015 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20016 if (SWIG_arg_fail(3)) SWIG_fail;
20017 }
20018 }
20019 if (obj3) {
20020 {
20021 arg4 = (int)(SWIG_As_int(obj3));
20022 if (SWIG_arg_fail(4)) SWIG_fail;
20023 }
20024 }
20025 if (obj4) {
20026 {
20027 arg5 = (int)(SWIG_As_int(obj4));
20028 if (SWIG_arg_fail(5)) SWIG_fail;
20029 }
20030 }
20031 if (obj5) {
20032 {
20033 arg6 = (int)(SWIG_As_int(obj5));
20034 if (SWIG_arg_fail(6)) SWIG_fail;
20035 }
20036 }
20037 if (obj6) {
20038 {
20039 arg7 = (int)(SWIG_As_int(obj6));
20040 if (SWIG_arg_fail(7)) SWIG_fail;
20041 }
20042 }
20043 if (obj7) {
20044 {
20045 arg8 = (int)(SWIG_As_int(obj7));
20046 if (SWIG_arg_fail(8)) SWIG_fail;
20047 }
20048 }
20049 {
20050 PyThreadState* __tstate = wxPyBeginAllowThreads();
20051 {
20052 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20053 result = (wxDateTime *) &_result_ref;
20054 }
20055
20056 wxPyEndAllowThreads(__tstate);
20057 if (PyErr_Occurred()) SWIG_fail;
20058 }
20059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20060 return resultobj;
20061 fail:
20062 return NULL;
20063 }
20064
20065
20066 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20067 PyObject *resultobj;
20068 wxDateTime *arg1 = (wxDateTime *) 0 ;
20069 wxDateTime *result;
20070 PyObject * obj0 = 0 ;
20071 char *kwnames[] = {
20072 (char *) "self", NULL
20073 };
20074
20075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20077 if (SWIG_arg_fail(1)) SWIG_fail;
20078 {
20079 PyThreadState* __tstate = wxPyBeginAllowThreads();
20080 {
20081 wxDateTime &_result_ref = (arg1)->ResetTime();
20082 result = (wxDateTime *) &_result_ref;
20083 }
20084
20085 wxPyEndAllowThreads(__tstate);
20086 if (PyErr_Occurred()) SWIG_fail;
20087 }
20088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20089 return resultobj;
20090 fail:
20091 return NULL;
20092 }
20093
20094
20095 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20096 PyObject *resultobj;
20097 wxDateTime *arg1 = (wxDateTime *) 0 ;
20098 int arg2 ;
20099 wxDateTime *result;
20100 PyObject * obj0 = 0 ;
20101 PyObject * obj1 = 0 ;
20102 char *kwnames[] = {
20103 (char *) "self",(char *) "year", NULL
20104 };
20105
20106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 {
20110 arg2 = (int)(SWIG_As_int(obj1));
20111 if (SWIG_arg_fail(2)) SWIG_fail;
20112 }
20113 {
20114 PyThreadState* __tstate = wxPyBeginAllowThreads();
20115 {
20116 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20117 result = (wxDateTime *) &_result_ref;
20118 }
20119
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20124 return resultobj;
20125 fail:
20126 return NULL;
20127 }
20128
20129
20130 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20131 PyObject *resultobj;
20132 wxDateTime *arg1 = (wxDateTime *) 0 ;
20133 wxDateTime::Month arg2 ;
20134 wxDateTime *result;
20135 PyObject * obj0 = 0 ;
20136 PyObject * obj1 = 0 ;
20137 char *kwnames[] = {
20138 (char *) "self",(char *) "month", NULL
20139 };
20140
20141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20143 if (SWIG_arg_fail(1)) SWIG_fail;
20144 {
20145 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20146 if (SWIG_arg_fail(2)) SWIG_fail;
20147 }
20148 {
20149 PyThreadState* __tstate = wxPyBeginAllowThreads();
20150 {
20151 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20152 result = (wxDateTime *) &_result_ref;
20153 }
20154
20155 wxPyEndAllowThreads(__tstate);
20156 if (PyErr_Occurred()) SWIG_fail;
20157 }
20158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20159 return resultobj;
20160 fail:
20161 return NULL;
20162 }
20163
20164
20165 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20166 PyObject *resultobj;
20167 wxDateTime *arg1 = (wxDateTime *) 0 ;
20168 int arg2 ;
20169 wxDateTime *result;
20170 PyObject * obj0 = 0 ;
20171 PyObject * obj1 = 0 ;
20172 char *kwnames[] = {
20173 (char *) "self",(char *) "day", NULL
20174 };
20175
20176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20178 if (SWIG_arg_fail(1)) SWIG_fail;
20179 {
20180 arg2 = (int)(SWIG_As_int(obj1));
20181 if (SWIG_arg_fail(2)) SWIG_fail;
20182 }
20183 {
20184 PyThreadState* __tstate = wxPyBeginAllowThreads();
20185 {
20186 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20187 result = (wxDateTime *) &_result_ref;
20188 }
20189
20190 wxPyEndAllowThreads(__tstate);
20191 if (PyErr_Occurred()) SWIG_fail;
20192 }
20193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20194 return resultobj;
20195 fail:
20196 return NULL;
20197 }
20198
20199
20200 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20201 PyObject *resultobj;
20202 wxDateTime *arg1 = (wxDateTime *) 0 ;
20203 int arg2 ;
20204 wxDateTime *result;
20205 PyObject * obj0 = 0 ;
20206 PyObject * obj1 = 0 ;
20207 char *kwnames[] = {
20208 (char *) "self",(char *) "hour", NULL
20209 };
20210
20211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20213 if (SWIG_arg_fail(1)) SWIG_fail;
20214 {
20215 arg2 = (int)(SWIG_As_int(obj1));
20216 if (SWIG_arg_fail(2)) SWIG_fail;
20217 }
20218 {
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 {
20221 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20222 result = (wxDateTime *) &_result_ref;
20223 }
20224
20225 wxPyEndAllowThreads(__tstate);
20226 if (PyErr_Occurred()) SWIG_fail;
20227 }
20228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20229 return resultobj;
20230 fail:
20231 return NULL;
20232 }
20233
20234
20235 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20236 PyObject *resultobj;
20237 wxDateTime *arg1 = (wxDateTime *) 0 ;
20238 int arg2 ;
20239 wxDateTime *result;
20240 PyObject * obj0 = 0 ;
20241 PyObject * obj1 = 0 ;
20242 char *kwnames[] = {
20243 (char *) "self",(char *) "minute", NULL
20244 };
20245
20246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20248 if (SWIG_arg_fail(1)) SWIG_fail;
20249 {
20250 arg2 = (int)(SWIG_As_int(obj1));
20251 if (SWIG_arg_fail(2)) SWIG_fail;
20252 }
20253 {
20254 PyThreadState* __tstate = wxPyBeginAllowThreads();
20255 {
20256 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20257 result = (wxDateTime *) &_result_ref;
20258 }
20259
20260 wxPyEndAllowThreads(__tstate);
20261 if (PyErr_Occurred()) SWIG_fail;
20262 }
20263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20264 return resultobj;
20265 fail:
20266 return NULL;
20267 }
20268
20269
20270 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20271 PyObject *resultobj;
20272 wxDateTime *arg1 = (wxDateTime *) 0 ;
20273 int arg2 ;
20274 wxDateTime *result;
20275 PyObject * obj0 = 0 ;
20276 PyObject * obj1 = 0 ;
20277 char *kwnames[] = {
20278 (char *) "self",(char *) "second", NULL
20279 };
20280
20281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20283 if (SWIG_arg_fail(1)) SWIG_fail;
20284 {
20285 arg2 = (int)(SWIG_As_int(obj1));
20286 if (SWIG_arg_fail(2)) SWIG_fail;
20287 }
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 {
20291 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20292 result = (wxDateTime *) &_result_ref;
20293 }
20294
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20306 PyObject *resultobj;
20307 wxDateTime *arg1 = (wxDateTime *) 0 ;
20308 int arg2 ;
20309 wxDateTime *result;
20310 PyObject * obj0 = 0 ;
20311 PyObject * obj1 = 0 ;
20312 char *kwnames[] = {
20313 (char *) "self",(char *) "millisecond", NULL
20314 };
20315
20316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20318 if (SWIG_arg_fail(1)) SWIG_fail;
20319 {
20320 arg2 = (int)(SWIG_As_int(obj1));
20321 if (SWIG_arg_fail(2)) SWIG_fail;
20322 }
20323 {
20324 PyThreadState* __tstate = wxPyBeginAllowThreads();
20325 {
20326 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20327 result = (wxDateTime *) &_result_ref;
20328 }
20329
20330 wxPyEndAllowThreads(__tstate);
20331 if (PyErr_Occurred()) SWIG_fail;
20332 }
20333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20334 return resultobj;
20335 fail:
20336 return NULL;
20337 }
20338
20339
20340 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20341 PyObject *resultobj;
20342 wxDateTime *arg1 = (wxDateTime *) 0 ;
20343 wxDateTime::WeekDay arg2 ;
20344 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20345 wxDateTime *result;
20346 PyObject * obj0 = 0 ;
20347 PyObject * obj1 = 0 ;
20348 PyObject * obj2 = 0 ;
20349 char *kwnames[] = {
20350 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20351 };
20352
20353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20355 if (SWIG_arg_fail(1)) SWIG_fail;
20356 {
20357 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20358 if (SWIG_arg_fail(2)) SWIG_fail;
20359 }
20360 if (obj2) {
20361 {
20362 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20363 if (SWIG_arg_fail(3)) SWIG_fail;
20364 }
20365 }
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 {
20369 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20370 result = (wxDateTime *) &_result_ref;
20371 }
20372
20373 wxPyEndAllowThreads(__tstate);
20374 if (PyErr_Occurred()) SWIG_fail;
20375 }
20376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20377 return resultobj;
20378 fail:
20379 return NULL;
20380 }
20381
20382
20383 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20384 PyObject *resultobj;
20385 wxDateTime *arg1 = (wxDateTime *) 0 ;
20386 wxDateTime::WeekDay arg2 ;
20387 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20388 wxDateTime result;
20389 PyObject * obj0 = 0 ;
20390 PyObject * obj1 = 0 ;
20391 PyObject * obj2 = 0 ;
20392 char *kwnames[] = {
20393 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20394 };
20395
20396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20398 if (SWIG_arg_fail(1)) SWIG_fail;
20399 {
20400 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20401 if (SWIG_arg_fail(2)) SWIG_fail;
20402 }
20403 if (obj2) {
20404 {
20405 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20406 if (SWIG_arg_fail(3)) SWIG_fail;
20407 }
20408 }
20409 {
20410 PyThreadState* __tstate = wxPyBeginAllowThreads();
20411 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20412
20413 wxPyEndAllowThreads(__tstate);
20414 if (PyErr_Occurred()) SWIG_fail;
20415 }
20416 {
20417 wxDateTime * resultptr;
20418 resultptr = new wxDateTime((wxDateTime &)(result));
20419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20420 }
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20428 PyObject *resultobj;
20429 wxDateTime *arg1 = (wxDateTime *) 0 ;
20430 wxDateTime::WeekDay arg2 ;
20431 wxDateTime *result;
20432 PyObject * obj0 = 0 ;
20433 PyObject * obj1 = 0 ;
20434 char *kwnames[] = {
20435 (char *) "self",(char *) "weekday", NULL
20436 };
20437
20438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20440 if (SWIG_arg_fail(1)) SWIG_fail;
20441 {
20442 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20443 if (SWIG_arg_fail(2)) SWIG_fail;
20444 }
20445 {
20446 PyThreadState* __tstate = wxPyBeginAllowThreads();
20447 {
20448 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20449 result = (wxDateTime *) &_result_ref;
20450 }
20451
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20456 return resultobj;
20457 fail:
20458 return NULL;
20459 }
20460
20461
20462 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20463 PyObject *resultobj;
20464 wxDateTime *arg1 = (wxDateTime *) 0 ;
20465 wxDateTime::WeekDay arg2 ;
20466 wxDateTime result;
20467 PyObject * obj0 = 0 ;
20468 PyObject * obj1 = 0 ;
20469 char *kwnames[] = {
20470 (char *) "self",(char *) "weekday", NULL
20471 };
20472
20473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20475 if (SWIG_arg_fail(1)) SWIG_fail;
20476 {
20477 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20478 if (SWIG_arg_fail(2)) SWIG_fail;
20479 }
20480 {
20481 PyThreadState* __tstate = wxPyBeginAllowThreads();
20482 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20483
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 {
20488 wxDateTime * resultptr;
20489 resultptr = new wxDateTime((wxDateTime &)(result));
20490 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20491 }
20492 return resultobj;
20493 fail:
20494 return NULL;
20495 }
20496
20497
20498 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20499 PyObject *resultobj;
20500 wxDateTime *arg1 = (wxDateTime *) 0 ;
20501 wxDateTime::WeekDay arg2 ;
20502 wxDateTime *result;
20503 PyObject * obj0 = 0 ;
20504 PyObject * obj1 = 0 ;
20505 char *kwnames[] = {
20506 (char *) "self",(char *) "weekday", NULL
20507 };
20508
20509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20511 if (SWIG_arg_fail(1)) SWIG_fail;
20512 {
20513 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20514 if (SWIG_arg_fail(2)) SWIG_fail;
20515 }
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 {
20519 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20520 result = (wxDateTime *) &_result_ref;
20521 }
20522
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20527 return resultobj;
20528 fail:
20529 return NULL;
20530 }
20531
20532
20533 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20534 PyObject *resultobj;
20535 wxDateTime *arg1 = (wxDateTime *) 0 ;
20536 wxDateTime::WeekDay arg2 ;
20537 wxDateTime result;
20538 PyObject * obj0 = 0 ;
20539 PyObject * obj1 = 0 ;
20540 char *kwnames[] = {
20541 (char *) "self",(char *) "weekday", NULL
20542 };
20543
20544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20546 if (SWIG_arg_fail(1)) SWIG_fail;
20547 {
20548 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20549 if (SWIG_arg_fail(2)) SWIG_fail;
20550 }
20551 {
20552 PyThreadState* __tstate = wxPyBeginAllowThreads();
20553 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20554
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 {
20559 wxDateTime * resultptr;
20560 resultptr = new wxDateTime((wxDateTime &)(result));
20561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20562 }
20563 return resultobj;
20564 fail:
20565 return NULL;
20566 }
20567
20568
20569 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20570 PyObject *resultobj;
20571 wxDateTime *arg1 = (wxDateTime *) 0 ;
20572 wxDateTime::WeekDay arg2 ;
20573 int arg3 = (int) 1 ;
20574 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20575 int arg5 = (int) wxDateTime::Inv_Year ;
20576 bool result;
20577 PyObject * obj0 = 0 ;
20578 PyObject * obj1 = 0 ;
20579 PyObject * obj2 = 0 ;
20580 PyObject * obj3 = 0 ;
20581 PyObject * obj4 = 0 ;
20582 char *kwnames[] = {
20583 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20584 };
20585
20586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20588 if (SWIG_arg_fail(1)) SWIG_fail;
20589 {
20590 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20591 if (SWIG_arg_fail(2)) SWIG_fail;
20592 }
20593 if (obj2) {
20594 {
20595 arg3 = (int)(SWIG_As_int(obj2));
20596 if (SWIG_arg_fail(3)) SWIG_fail;
20597 }
20598 }
20599 if (obj3) {
20600 {
20601 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20602 if (SWIG_arg_fail(4)) SWIG_fail;
20603 }
20604 }
20605 if (obj4) {
20606 {
20607 arg5 = (int)(SWIG_As_int(obj4));
20608 if (SWIG_arg_fail(5)) SWIG_fail;
20609 }
20610 }
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20614
20615 wxPyEndAllowThreads(__tstate);
20616 if (PyErr_Occurred()) SWIG_fail;
20617 }
20618 {
20619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20620 }
20621 return resultobj;
20622 fail:
20623 return NULL;
20624 }
20625
20626
20627 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20628 PyObject *resultobj;
20629 wxDateTime *arg1 = (wxDateTime *) 0 ;
20630 wxDateTime::WeekDay arg2 ;
20631 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20632 int arg4 = (int) wxDateTime::Inv_Year ;
20633 bool result;
20634 PyObject * obj0 = 0 ;
20635 PyObject * obj1 = 0 ;
20636 PyObject * obj2 = 0 ;
20637 PyObject * obj3 = 0 ;
20638 char *kwnames[] = {
20639 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20640 };
20641
20642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20644 if (SWIG_arg_fail(1)) SWIG_fail;
20645 {
20646 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20647 if (SWIG_arg_fail(2)) SWIG_fail;
20648 }
20649 if (obj2) {
20650 {
20651 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20652 if (SWIG_arg_fail(3)) SWIG_fail;
20653 }
20654 }
20655 if (obj3) {
20656 {
20657 arg4 = (int)(SWIG_As_int(obj3));
20658 if (SWIG_arg_fail(4)) SWIG_fail;
20659 }
20660 }
20661 {
20662 PyThreadState* __tstate = wxPyBeginAllowThreads();
20663 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20664
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 {
20669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20670 }
20671 return resultobj;
20672 fail:
20673 return NULL;
20674 }
20675
20676
20677 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20678 PyObject *resultobj;
20679 wxDateTime *arg1 = (wxDateTime *) 0 ;
20680 wxDateTime::WeekDay arg2 ;
20681 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20682 int arg4 = (int) wxDateTime::Inv_Year ;
20683 wxDateTime result;
20684 PyObject * obj0 = 0 ;
20685 PyObject * obj1 = 0 ;
20686 PyObject * obj2 = 0 ;
20687 PyObject * obj3 = 0 ;
20688 char *kwnames[] = {
20689 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20690 };
20691
20692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20694 if (SWIG_arg_fail(1)) SWIG_fail;
20695 {
20696 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20697 if (SWIG_arg_fail(2)) SWIG_fail;
20698 }
20699 if (obj2) {
20700 {
20701 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20702 if (SWIG_arg_fail(3)) SWIG_fail;
20703 }
20704 }
20705 if (obj3) {
20706 {
20707 arg4 = (int)(SWIG_As_int(obj3));
20708 if (SWIG_arg_fail(4)) SWIG_fail;
20709 }
20710 }
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20714
20715 wxPyEndAllowThreads(__tstate);
20716 if (PyErr_Occurred()) SWIG_fail;
20717 }
20718 {
20719 wxDateTime * resultptr;
20720 resultptr = new wxDateTime((wxDateTime &)(result));
20721 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20722 }
20723 return resultobj;
20724 fail:
20725 return NULL;
20726 }
20727
20728
20729 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20730 PyObject *resultobj;
20731 wxDateTime *arg1 = (wxDateTime *) 0 ;
20732 int arg2 ;
20733 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20734 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20735 bool result;
20736 PyObject * obj0 = 0 ;
20737 PyObject * obj1 = 0 ;
20738 PyObject * obj2 = 0 ;
20739 PyObject * obj3 = 0 ;
20740 char *kwnames[] = {
20741 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20742 };
20743
20744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20746 if (SWIG_arg_fail(1)) SWIG_fail;
20747 {
20748 arg2 = (int)(SWIG_As_int(obj1));
20749 if (SWIG_arg_fail(2)) SWIG_fail;
20750 }
20751 if (obj2) {
20752 {
20753 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20754 if (SWIG_arg_fail(3)) SWIG_fail;
20755 }
20756 }
20757 if (obj3) {
20758 {
20759 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20760 if (SWIG_arg_fail(4)) SWIG_fail;
20761 }
20762 }
20763 {
20764 PyThreadState* __tstate = wxPyBeginAllowThreads();
20765 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20766
20767 wxPyEndAllowThreads(__tstate);
20768 if (PyErr_Occurred()) SWIG_fail;
20769 }
20770 {
20771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20772 }
20773 return resultobj;
20774 fail:
20775 return NULL;
20776 }
20777
20778
20779 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20780 PyObject *resultobj;
20781 wxDateTime *arg1 = (wxDateTime *) 0 ;
20782 int arg2 ;
20783 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20784 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20785 wxDateTime result;
20786 PyObject * obj0 = 0 ;
20787 PyObject * obj1 = 0 ;
20788 PyObject * obj2 = 0 ;
20789 PyObject * obj3 = 0 ;
20790 char *kwnames[] = {
20791 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20792 };
20793
20794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20796 if (SWIG_arg_fail(1)) SWIG_fail;
20797 {
20798 arg2 = (int)(SWIG_As_int(obj1));
20799 if (SWIG_arg_fail(2)) SWIG_fail;
20800 }
20801 if (obj2) {
20802 {
20803 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20804 if (SWIG_arg_fail(3)) SWIG_fail;
20805 }
20806 }
20807 if (obj3) {
20808 {
20809 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20810 if (SWIG_arg_fail(4)) SWIG_fail;
20811 }
20812 }
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20816
20817 wxPyEndAllowThreads(__tstate);
20818 if (PyErr_Occurred()) SWIG_fail;
20819 }
20820 {
20821 wxDateTime * resultptr;
20822 resultptr = new wxDateTime((wxDateTime &)(result));
20823 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20824 }
20825 return resultobj;
20826 fail:
20827 return NULL;
20828 }
20829
20830
20831 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20832 PyObject *resultobj;
20833 int arg1 ;
20834 int arg2 ;
20835 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20836 wxDateTime result;
20837 PyObject * obj0 = 0 ;
20838 PyObject * obj1 = 0 ;
20839 PyObject * obj2 = 0 ;
20840 char *kwnames[] = {
20841 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20842 };
20843
20844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20845 {
20846 arg1 = (int)(SWIG_As_int(obj0));
20847 if (SWIG_arg_fail(1)) SWIG_fail;
20848 }
20849 {
20850 arg2 = (int)(SWIG_As_int(obj1));
20851 if (SWIG_arg_fail(2)) SWIG_fail;
20852 }
20853 if (obj2) {
20854 {
20855 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20856 if (SWIG_arg_fail(3)) SWIG_fail;
20857 }
20858 }
20859 {
20860 PyThreadState* __tstate = wxPyBeginAllowThreads();
20861 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20862
20863 wxPyEndAllowThreads(__tstate);
20864 if (PyErr_Occurred()) SWIG_fail;
20865 }
20866 {
20867 wxDateTime * resultptr;
20868 resultptr = new wxDateTime((wxDateTime &)(result));
20869 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20870 }
20871 return resultobj;
20872 fail:
20873 return NULL;
20874 }
20875
20876
20877 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20878 PyObject *resultobj;
20879 wxDateTime *arg1 = (wxDateTime *) 0 ;
20880 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20881 int arg3 = (int) wxDateTime::Inv_Year ;
20882 wxDateTime *result;
20883 PyObject * obj0 = 0 ;
20884 PyObject * obj1 = 0 ;
20885 PyObject * obj2 = 0 ;
20886 char *kwnames[] = {
20887 (char *) "self",(char *) "month",(char *) "year", NULL
20888 };
20889
20890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20892 if (SWIG_arg_fail(1)) SWIG_fail;
20893 if (obj1) {
20894 {
20895 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20896 if (SWIG_arg_fail(2)) SWIG_fail;
20897 }
20898 }
20899 if (obj2) {
20900 {
20901 arg3 = (int)(SWIG_As_int(obj2));
20902 if (SWIG_arg_fail(3)) SWIG_fail;
20903 }
20904 }
20905 {
20906 PyThreadState* __tstate = wxPyBeginAllowThreads();
20907 {
20908 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20909 result = (wxDateTime *) &_result_ref;
20910 }
20911
20912 wxPyEndAllowThreads(__tstate);
20913 if (PyErr_Occurred()) SWIG_fail;
20914 }
20915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20916 return resultobj;
20917 fail:
20918 return NULL;
20919 }
20920
20921
20922 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20923 PyObject *resultobj;
20924 wxDateTime *arg1 = (wxDateTime *) 0 ;
20925 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20926 int arg3 = (int) wxDateTime::Inv_Year ;
20927 wxDateTime result;
20928 PyObject * obj0 = 0 ;
20929 PyObject * obj1 = 0 ;
20930 PyObject * obj2 = 0 ;
20931 char *kwnames[] = {
20932 (char *) "self",(char *) "month",(char *) "year", NULL
20933 };
20934
20935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20937 if (SWIG_arg_fail(1)) SWIG_fail;
20938 if (obj1) {
20939 {
20940 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20941 if (SWIG_arg_fail(2)) SWIG_fail;
20942 }
20943 }
20944 if (obj2) {
20945 {
20946 arg3 = (int)(SWIG_As_int(obj2));
20947 if (SWIG_arg_fail(3)) SWIG_fail;
20948 }
20949 }
20950 {
20951 PyThreadState* __tstate = wxPyBeginAllowThreads();
20952 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20953
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 {
20958 wxDateTime * resultptr;
20959 resultptr = new wxDateTime((wxDateTime &)(result));
20960 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20961 }
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20969 PyObject *resultobj;
20970 wxDateTime *arg1 = (wxDateTime *) 0 ;
20971 int arg2 ;
20972 wxDateTime *result;
20973 PyObject * obj0 = 0 ;
20974 PyObject * obj1 = 0 ;
20975 char *kwnames[] = {
20976 (char *) "self",(char *) "yday", NULL
20977 };
20978
20979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20981 if (SWIG_arg_fail(1)) SWIG_fail;
20982 {
20983 arg2 = (int)(SWIG_As_int(obj1));
20984 if (SWIG_arg_fail(2)) SWIG_fail;
20985 }
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 {
20989 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20990 result = (wxDateTime *) &_result_ref;
20991 }
20992
20993 wxPyEndAllowThreads(__tstate);
20994 if (PyErr_Occurred()) SWIG_fail;
20995 }
20996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20997 return resultobj;
20998 fail:
20999 return NULL;
21000 }
21001
21002
21003 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21004 PyObject *resultobj;
21005 wxDateTime *arg1 = (wxDateTime *) 0 ;
21006 int arg2 ;
21007 wxDateTime result;
21008 PyObject * obj0 = 0 ;
21009 PyObject * obj1 = 0 ;
21010 char *kwnames[] = {
21011 (char *) "self",(char *) "yday", NULL
21012 };
21013
21014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21016 if (SWIG_arg_fail(1)) SWIG_fail;
21017 {
21018 arg2 = (int)(SWIG_As_int(obj1));
21019 if (SWIG_arg_fail(2)) SWIG_fail;
21020 }
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 result = (arg1)->GetYearDay(arg2);
21024
21025 wxPyEndAllowThreads(__tstate);
21026 if (PyErr_Occurred()) SWIG_fail;
21027 }
21028 {
21029 wxDateTime * resultptr;
21030 resultptr = new wxDateTime((wxDateTime &)(result));
21031 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21032 }
21033 return resultobj;
21034 fail:
21035 return NULL;
21036 }
21037
21038
21039 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21040 PyObject *resultobj;
21041 wxDateTime *arg1 = (wxDateTime *) 0 ;
21042 double result;
21043 PyObject * obj0 = 0 ;
21044 char *kwnames[] = {
21045 (char *) "self", NULL
21046 };
21047
21048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21050 if (SWIG_arg_fail(1)) SWIG_fail;
21051 {
21052 PyThreadState* __tstate = wxPyBeginAllowThreads();
21053 result = (double)(arg1)->GetJulianDayNumber();
21054
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 {
21059 resultobj = SWIG_From_double((double)(result));
21060 }
21061 return resultobj;
21062 fail:
21063 return NULL;
21064 }
21065
21066
21067 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21068 PyObject *resultobj;
21069 wxDateTime *arg1 = (wxDateTime *) 0 ;
21070 double result;
21071 PyObject * obj0 = 0 ;
21072 char *kwnames[] = {
21073 (char *) "self", NULL
21074 };
21075
21076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21078 if (SWIG_arg_fail(1)) SWIG_fail;
21079 {
21080 PyThreadState* __tstate = wxPyBeginAllowThreads();
21081 result = (double)(arg1)->GetJDN();
21082
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 {
21087 resultobj = SWIG_From_double((double)(result));
21088 }
21089 return resultobj;
21090 fail:
21091 return NULL;
21092 }
21093
21094
21095 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21096 PyObject *resultobj;
21097 wxDateTime *arg1 = (wxDateTime *) 0 ;
21098 double result;
21099 PyObject * obj0 = 0 ;
21100 char *kwnames[] = {
21101 (char *) "self", NULL
21102 };
21103
21104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21106 if (SWIG_arg_fail(1)) SWIG_fail;
21107 {
21108 PyThreadState* __tstate = wxPyBeginAllowThreads();
21109 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21110
21111 wxPyEndAllowThreads(__tstate);
21112 if (PyErr_Occurred()) SWIG_fail;
21113 }
21114 {
21115 resultobj = SWIG_From_double((double)(result));
21116 }
21117 return resultobj;
21118 fail:
21119 return NULL;
21120 }
21121
21122
21123 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21124 PyObject *resultobj;
21125 wxDateTime *arg1 = (wxDateTime *) 0 ;
21126 double result;
21127 PyObject * obj0 = 0 ;
21128 char *kwnames[] = {
21129 (char *) "self", NULL
21130 };
21131
21132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21134 if (SWIG_arg_fail(1)) SWIG_fail;
21135 {
21136 PyThreadState* __tstate = wxPyBeginAllowThreads();
21137 result = (double)(arg1)->GetMJD();
21138
21139 wxPyEndAllowThreads(__tstate);
21140 if (PyErr_Occurred()) SWIG_fail;
21141 }
21142 {
21143 resultobj = SWIG_From_double((double)(result));
21144 }
21145 return resultobj;
21146 fail:
21147 return NULL;
21148 }
21149
21150
21151 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21152 PyObject *resultobj;
21153 wxDateTime *arg1 = (wxDateTime *) 0 ;
21154 double result;
21155 PyObject * obj0 = 0 ;
21156 char *kwnames[] = {
21157 (char *) "self", NULL
21158 };
21159
21160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21162 if (SWIG_arg_fail(1)) SWIG_fail;
21163 {
21164 PyThreadState* __tstate = wxPyBeginAllowThreads();
21165 result = (double)(arg1)->GetRataDie();
21166
21167 wxPyEndAllowThreads(__tstate);
21168 if (PyErr_Occurred()) SWIG_fail;
21169 }
21170 {
21171 resultobj = SWIG_From_double((double)(result));
21172 }
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21180 PyObject *resultobj;
21181 wxDateTime *arg1 = (wxDateTime *) 0 ;
21182 wxDateTime::TimeZone *arg2 = 0 ;
21183 bool arg3 = (bool) false ;
21184 wxDateTime result;
21185 bool temp2 = false ;
21186 PyObject * obj0 = 0 ;
21187 PyObject * obj1 = 0 ;
21188 PyObject * obj2 = 0 ;
21189 char *kwnames[] = {
21190 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21191 };
21192
21193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) 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 {
21197 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21198 temp2 = true;
21199 }
21200 if (obj2) {
21201 {
21202 arg3 = (bool)(SWIG_As_bool(obj2));
21203 if (SWIG_arg_fail(3)) SWIG_fail;
21204 }
21205 }
21206 {
21207 PyThreadState* __tstate = wxPyBeginAllowThreads();
21208 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21209
21210 wxPyEndAllowThreads(__tstate);
21211 if (PyErr_Occurred()) SWIG_fail;
21212 }
21213 {
21214 wxDateTime * resultptr;
21215 resultptr = new wxDateTime((wxDateTime &)(result));
21216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21217 }
21218 {
21219 if (temp2) delete arg2;
21220 }
21221 return resultobj;
21222 fail:
21223 {
21224 if (temp2) delete arg2;
21225 }
21226 return NULL;
21227 }
21228
21229
21230 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21231 PyObject *resultobj;
21232 wxDateTime *arg1 = (wxDateTime *) 0 ;
21233 wxDateTime::TimeZone *arg2 = 0 ;
21234 bool arg3 = (bool) false ;
21235 wxDateTime *result;
21236 bool temp2 = false ;
21237 PyObject * obj0 = 0 ;
21238 PyObject * obj1 = 0 ;
21239 PyObject * obj2 = 0 ;
21240 char *kwnames[] = {
21241 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21242 };
21243
21244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21246 if (SWIG_arg_fail(1)) SWIG_fail;
21247 {
21248 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21249 temp2 = true;
21250 }
21251 if (obj2) {
21252 {
21253 arg3 = (bool)(SWIG_As_bool(obj2));
21254 if (SWIG_arg_fail(3)) SWIG_fail;
21255 }
21256 }
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 {
21260 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21261 result = (wxDateTime *) &_result_ref;
21262 }
21263
21264 wxPyEndAllowThreads(__tstate);
21265 if (PyErr_Occurred()) SWIG_fail;
21266 }
21267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21268 {
21269 if (temp2) delete arg2;
21270 }
21271 return resultobj;
21272 fail:
21273 {
21274 if (temp2) delete arg2;
21275 }
21276 return NULL;
21277 }
21278
21279
21280 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21281 PyObject *resultobj;
21282 wxDateTime *arg1 = (wxDateTime *) 0 ;
21283 bool arg2 = (bool) false ;
21284 wxDateTime result;
21285 PyObject * obj0 = 0 ;
21286 PyObject * obj1 = 0 ;
21287 char *kwnames[] = {
21288 (char *) "self",(char *) "noDST", NULL
21289 };
21290
21291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21293 if (SWIG_arg_fail(1)) SWIG_fail;
21294 if (obj1) {
21295 {
21296 arg2 = (bool)(SWIG_As_bool(obj1));
21297 if (SWIG_arg_fail(2)) SWIG_fail;
21298 }
21299 }
21300 {
21301 PyThreadState* __tstate = wxPyBeginAllowThreads();
21302 result = (arg1)->ToGMT(arg2);
21303
21304 wxPyEndAllowThreads(__tstate);
21305 if (PyErr_Occurred()) SWIG_fail;
21306 }
21307 {
21308 wxDateTime * resultptr;
21309 resultptr = new wxDateTime((wxDateTime &)(result));
21310 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21311 }
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21319 PyObject *resultobj;
21320 wxDateTime *arg1 = (wxDateTime *) 0 ;
21321 bool arg2 = (bool) false ;
21322 wxDateTime *result;
21323 PyObject * obj0 = 0 ;
21324 PyObject * obj1 = 0 ;
21325 char *kwnames[] = {
21326 (char *) "self",(char *) "noDST", NULL
21327 };
21328
21329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21331 if (SWIG_arg_fail(1)) SWIG_fail;
21332 if (obj1) {
21333 {
21334 arg2 = (bool)(SWIG_As_bool(obj1));
21335 if (SWIG_arg_fail(2)) SWIG_fail;
21336 }
21337 }
21338 {
21339 PyThreadState* __tstate = wxPyBeginAllowThreads();
21340 {
21341 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21342 result = (wxDateTime *) &_result_ref;
21343 }
21344
21345 wxPyEndAllowThreads(__tstate);
21346 if (PyErr_Occurred()) SWIG_fail;
21347 }
21348 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21349 return resultobj;
21350 fail:
21351 return NULL;
21352 }
21353
21354
21355 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21356 PyObject *resultobj;
21357 wxDateTime *arg1 = (wxDateTime *) 0 ;
21358 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21359 int result;
21360 PyObject * obj0 = 0 ;
21361 PyObject * obj1 = 0 ;
21362 char *kwnames[] = {
21363 (char *) "self",(char *) "country", NULL
21364 };
21365
21366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21368 if (SWIG_arg_fail(1)) SWIG_fail;
21369 if (obj1) {
21370 {
21371 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21372 if (SWIG_arg_fail(2)) SWIG_fail;
21373 }
21374 }
21375 {
21376 PyThreadState* __tstate = wxPyBeginAllowThreads();
21377 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21378
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 {
21383 resultobj = SWIG_From_int((int)(result));
21384 }
21385 return resultobj;
21386 fail:
21387 return NULL;
21388 }
21389
21390
21391 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21392 PyObject *resultobj;
21393 wxDateTime *arg1 = (wxDateTime *) 0 ;
21394 bool result;
21395 PyObject * obj0 = 0 ;
21396 char *kwnames[] = {
21397 (char *) "self", NULL
21398 };
21399
21400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21402 if (SWIG_arg_fail(1)) SWIG_fail;
21403 {
21404 PyThreadState* __tstate = wxPyBeginAllowThreads();
21405 result = (bool)((wxDateTime const *)arg1)->IsValid();
21406
21407 wxPyEndAllowThreads(__tstate);
21408 if (PyErr_Occurred()) SWIG_fail;
21409 }
21410 {
21411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21412 }
21413 return resultobj;
21414 fail:
21415 return NULL;
21416 }
21417
21418
21419 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21420 PyObject *resultobj;
21421 wxDateTime *arg1 = (wxDateTime *) 0 ;
21422 time_t result;
21423 PyObject * obj0 = 0 ;
21424 char *kwnames[] = {
21425 (char *) "self", NULL
21426 };
21427
21428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21430 if (SWIG_arg_fail(1)) SWIG_fail;
21431 {
21432 PyThreadState* __tstate = wxPyBeginAllowThreads();
21433 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21434
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 {
21439 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21440 }
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21448 PyObject *resultobj;
21449 wxDateTime *arg1 = (wxDateTime *) 0 ;
21450 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21451 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21452 int result;
21453 bool temp2 = false ;
21454 PyObject * obj0 = 0 ;
21455 PyObject * obj1 = 0 ;
21456 char *kwnames[] = {
21457 (char *) "self",(char *) "tz", NULL
21458 };
21459
21460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21462 if (SWIG_arg_fail(1)) SWIG_fail;
21463 if (obj1) {
21464 {
21465 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21466 temp2 = true;
21467 }
21468 }
21469 {
21470 PyThreadState* __tstate = wxPyBeginAllowThreads();
21471 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21472
21473 wxPyEndAllowThreads(__tstate);
21474 if (PyErr_Occurred()) SWIG_fail;
21475 }
21476 {
21477 resultobj = SWIG_From_int((int)(result));
21478 }
21479 {
21480 if (temp2) delete arg2;
21481 }
21482 return resultobj;
21483 fail:
21484 {
21485 if (temp2) delete arg2;
21486 }
21487 return NULL;
21488 }
21489
21490
21491 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21492 PyObject *resultobj;
21493 wxDateTime *arg1 = (wxDateTime *) 0 ;
21494 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21495 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21496 wxDateTime::Month result;
21497 bool temp2 = false ;
21498 PyObject * obj0 = 0 ;
21499 PyObject * obj1 = 0 ;
21500 char *kwnames[] = {
21501 (char *) "self",(char *) "tz", NULL
21502 };
21503
21504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21506 if (SWIG_arg_fail(1)) SWIG_fail;
21507 if (obj1) {
21508 {
21509 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21510 temp2 = true;
21511 }
21512 }
21513 {
21514 PyThreadState* __tstate = wxPyBeginAllowThreads();
21515 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21516
21517 wxPyEndAllowThreads(__tstate);
21518 if (PyErr_Occurred()) SWIG_fail;
21519 }
21520 resultobj = SWIG_From_int((result));
21521 {
21522 if (temp2) delete arg2;
21523 }
21524 return resultobj;
21525 fail:
21526 {
21527 if (temp2) delete arg2;
21528 }
21529 return NULL;
21530 }
21531
21532
21533 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21534 PyObject *resultobj;
21535 wxDateTime *arg1 = (wxDateTime *) 0 ;
21536 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21537 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21538 int result;
21539 bool temp2 = false ;
21540 PyObject * obj0 = 0 ;
21541 PyObject * obj1 = 0 ;
21542 char *kwnames[] = {
21543 (char *) "self",(char *) "tz", NULL
21544 };
21545
21546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21548 if (SWIG_arg_fail(1)) SWIG_fail;
21549 if (obj1) {
21550 {
21551 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21552 temp2 = true;
21553 }
21554 }
21555 {
21556 PyThreadState* __tstate = wxPyBeginAllowThreads();
21557 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21558
21559 wxPyEndAllowThreads(__tstate);
21560 if (PyErr_Occurred()) SWIG_fail;
21561 }
21562 {
21563 resultobj = SWIG_From_int((int)(result));
21564 }
21565 {
21566 if (temp2) delete arg2;
21567 }
21568 return resultobj;
21569 fail:
21570 {
21571 if (temp2) delete arg2;
21572 }
21573 return NULL;
21574 }
21575
21576
21577 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21578 PyObject *resultobj;
21579 wxDateTime *arg1 = (wxDateTime *) 0 ;
21580 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21581 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21582 wxDateTime::WeekDay result;
21583 bool temp2 = false ;
21584 PyObject * obj0 = 0 ;
21585 PyObject * obj1 = 0 ;
21586 char *kwnames[] = {
21587 (char *) "self",(char *) "tz", NULL
21588 };
21589
21590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21592 if (SWIG_arg_fail(1)) SWIG_fail;
21593 if (obj1) {
21594 {
21595 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21596 temp2 = true;
21597 }
21598 }
21599 {
21600 PyThreadState* __tstate = wxPyBeginAllowThreads();
21601 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21602
21603 wxPyEndAllowThreads(__tstate);
21604 if (PyErr_Occurred()) SWIG_fail;
21605 }
21606 resultobj = SWIG_From_int((result));
21607 {
21608 if (temp2) delete arg2;
21609 }
21610 return resultobj;
21611 fail:
21612 {
21613 if (temp2) delete arg2;
21614 }
21615 return NULL;
21616 }
21617
21618
21619 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj;
21621 wxDateTime *arg1 = (wxDateTime *) 0 ;
21622 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21623 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21624 int result;
21625 bool temp2 = false ;
21626 PyObject * obj0 = 0 ;
21627 PyObject * obj1 = 0 ;
21628 char *kwnames[] = {
21629 (char *) "self",(char *) "tz", NULL
21630 };
21631
21632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21634 if (SWIG_arg_fail(1)) SWIG_fail;
21635 if (obj1) {
21636 {
21637 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21638 temp2 = true;
21639 }
21640 }
21641 {
21642 PyThreadState* __tstate = wxPyBeginAllowThreads();
21643 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21644
21645 wxPyEndAllowThreads(__tstate);
21646 if (PyErr_Occurred()) SWIG_fail;
21647 }
21648 {
21649 resultobj = SWIG_From_int((int)(result));
21650 }
21651 {
21652 if (temp2) delete arg2;
21653 }
21654 return resultobj;
21655 fail:
21656 {
21657 if (temp2) delete arg2;
21658 }
21659 return NULL;
21660 }
21661
21662
21663 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21664 PyObject *resultobj;
21665 wxDateTime *arg1 = (wxDateTime *) 0 ;
21666 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21667 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21668 int result;
21669 bool temp2 = false ;
21670 PyObject * obj0 = 0 ;
21671 PyObject * obj1 = 0 ;
21672 char *kwnames[] = {
21673 (char *) "self",(char *) "tz", NULL
21674 };
21675
21676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21678 if (SWIG_arg_fail(1)) SWIG_fail;
21679 if (obj1) {
21680 {
21681 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21682 temp2 = true;
21683 }
21684 }
21685 {
21686 PyThreadState* __tstate = wxPyBeginAllowThreads();
21687 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21688
21689 wxPyEndAllowThreads(__tstate);
21690 if (PyErr_Occurred()) SWIG_fail;
21691 }
21692 {
21693 resultobj = SWIG_From_int((int)(result));
21694 }
21695 {
21696 if (temp2) delete arg2;
21697 }
21698 return resultobj;
21699 fail:
21700 {
21701 if (temp2) delete arg2;
21702 }
21703 return NULL;
21704 }
21705
21706
21707 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21708 PyObject *resultobj;
21709 wxDateTime *arg1 = (wxDateTime *) 0 ;
21710 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21711 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21712 int result;
21713 bool temp2 = false ;
21714 PyObject * obj0 = 0 ;
21715 PyObject * obj1 = 0 ;
21716 char *kwnames[] = {
21717 (char *) "self",(char *) "tz", NULL
21718 };
21719
21720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21722 if (SWIG_arg_fail(1)) SWIG_fail;
21723 if (obj1) {
21724 {
21725 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21726 temp2 = true;
21727 }
21728 }
21729 {
21730 PyThreadState* __tstate = wxPyBeginAllowThreads();
21731 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21732
21733 wxPyEndAllowThreads(__tstate);
21734 if (PyErr_Occurred()) SWIG_fail;
21735 }
21736 {
21737 resultobj = SWIG_From_int((int)(result));
21738 }
21739 {
21740 if (temp2) delete arg2;
21741 }
21742 return resultobj;
21743 fail:
21744 {
21745 if (temp2) delete arg2;
21746 }
21747 return NULL;
21748 }
21749
21750
21751 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj;
21753 wxDateTime *arg1 = (wxDateTime *) 0 ;
21754 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21755 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21756 int result;
21757 bool temp2 = false ;
21758 PyObject * obj0 = 0 ;
21759 PyObject * obj1 = 0 ;
21760 char *kwnames[] = {
21761 (char *) "self",(char *) "tz", NULL
21762 };
21763
21764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21766 if (SWIG_arg_fail(1)) SWIG_fail;
21767 if (obj1) {
21768 {
21769 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21770 temp2 = true;
21771 }
21772 }
21773 {
21774 PyThreadState* __tstate = wxPyBeginAllowThreads();
21775 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21776
21777 wxPyEndAllowThreads(__tstate);
21778 if (PyErr_Occurred()) SWIG_fail;
21779 }
21780 {
21781 resultobj = SWIG_From_int((int)(result));
21782 }
21783 {
21784 if (temp2) delete arg2;
21785 }
21786 return resultobj;
21787 fail:
21788 {
21789 if (temp2) delete arg2;
21790 }
21791 return NULL;
21792 }
21793
21794
21795 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21796 PyObject *resultobj;
21797 wxDateTime *arg1 = (wxDateTime *) 0 ;
21798 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21799 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21800 int result;
21801 bool temp2 = false ;
21802 PyObject * obj0 = 0 ;
21803 PyObject * obj1 = 0 ;
21804 char *kwnames[] = {
21805 (char *) "self",(char *) "tz", NULL
21806 };
21807
21808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21810 if (SWIG_arg_fail(1)) SWIG_fail;
21811 if (obj1) {
21812 {
21813 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21814 temp2 = true;
21815 }
21816 }
21817 {
21818 PyThreadState* __tstate = wxPyBeginAllowThreads();
21819 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21820
21821 wxPyEndAllowThreads(__tstate);
21822 if (PyErr_Occurred()) SWIG_fail;
21823 }
21824 {
21825 resultobj = SWIG_From_int((int)(result));
21826 }
21827 {
21828 if (temp2) delete arg2;
21829 }
21830 return resultobj;
21831 fail:
21832 {
21833 if (temp2) delete arg2;
21834 }
21835 return NULL;
21836 }
21837
21838
21839 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21840 PyObject *resultobj;
21841 wxDateTime *arg1 = (wxDateTime *) 0 ;
21842 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21843 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21844 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21845 int result;
21846 bool temp3 = false ;
21847 PyObject * obj0 = 0 ;
21848 PyObject * obj1 = 0 ;
21849 PyObject * obj2 = 0 ;
21850 char *kwnames[] = {
21851 (char *) "self",(char *) "flags",(char *) "tz", NULL
21852 };
21853
21854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21856 if (SWIG_arg_fail(1)) SWIG_fail;
21857 if (obj1) {
21858 {
21859 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21860 if (SWIG_arg_fail(2)) SWIG_fail;
21861 }
21862 }
21863 if (obj2) {
21864 {
21865 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21866 temp3 = true;
21867 }
21868 }
21869 {
21870 PyThreadState* __tstate = wxPyBeginAllowThreads();
21871 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21872
21873 wxPyEndAllowThreads(__tstate);
21874 if (PyErr_Occurred()) SWIG_fail;
21875 }
21876 {
21877 resultobj = SWIG_From_int((int)(result));
21878 }
21879 {
21880 if (temp3) delete arg3;
21881 }
21882 return resultobj;
21883 fail:
21884 {
21885 if (temp3) delete arg3;
21886 }
21887 return NULL;
21888 }
21889
21890
21891 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21892 PyObject *resultobj;
21893 wxDateTime *arg1 = (wxDateTime *) 0 ;
21894 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21895 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21896 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21897 int result;
21898 bool temp3 = false ;
21899 PyObject * obj0 = 0 ;
21900 PyObject * obj1 = 0 ;
21901 PyObject * obj2 = 0 ;
21902 char *kwnames[] = {
21903 (char *) "self",(char *) "flags",(char *) "tz", NULL
21904 };
21905
21906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21908 if (SWIG_arg_fail(1)) SWIG_fail;
21909 if (obj1) {
21910 {
21911 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21912 if (SWIG_arg_fail(2)) SWIG_fail;
21913 }
21914 }
21915 if (obj2) {
21916 {
21917 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21918 temp3 = true;
21919 }
21920 }
21921 {
21922 PyThreadState* __tstate = wxPyBeginAllowThreads();
21923 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21924
21925 wxPyEndAllowThreads(__tstate);
21926 if (PyErr_Occurred()) SWIG_fail;
21927 }
21928 {
21929 resultobj = SWIG_From_int((int)(result));
21930 }
21931 {
21932 if (temp3) delete arg3;
21933 }
21934 return resultobj;
21935 fail:
21936 {
21937 if (temp3) delete arg3;
21938 }
21939 return NULL;
21940 }
21941
21942
21943 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21944 PyObject *resultobj;
21945 wxDateTime *arg1 = (wxDateTime *) 0 ;
21946 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21947 bool result;
21948 PyObject * obj0 = 0 ;
21949 PyObject * obj1 = 0 ;
21950 char *kwnames[] = {
21951 (char *) "self",(char *) "country", NULL
21952 };
21953
21954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21956 if (SWIG_arg_fail(1)) SWIG_fail;
21957 if (obj1) {
21958 {
21959 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21960 if (SWIG_arg_fail(2)) SWIG_fail;
21961 }
21962 }
21963 {
21964 PyThreadState* __tstate = wxPyBeginAllowThreads();
21965 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21966
21967 wxPyEndAllowThreads(__tstate);
21968 if (PyErr_Occurred()) SWIG_fail;
21969 }
21970 {
21971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21972 }
21973 return resultobj;
21974 fail:
21975 return NULL;
21976 }
21977
21978
21979 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21980 PyObject *resultobj;
21981 wxDateTime *arg1 = (wxDateTime *) 0 ;
21982 wxDateTime *arg2 = 0 ;
21983 bool result;
21984 PyObject * obj0 = 0 ;
21985 PyObject * obj1 = 0 ;
21986 char *kwnames[] = {
21987 (char *) "self",(char *) "datetime", NULL
21988 };
21989
21990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21992 if (SWIG_arg_fail(1)) SWIG_fail;
21993 {
21994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21995 if (SWIG_arg_fail(2)) SWIG_fail;
21996 if (arg2 == NULL) {
21997 SWIG_null_ref("wxDateTime");
21998 }
21999 if (SWIG_arg_fail(2)) SWIG_fail;
22000 }
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22004
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 {
22009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22010 }
22011 return resultobj;
22012 fail:
22013 return NULL;
22014 }
22015
22016
22017 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22018 PyObject *resultobj;
22019 wxDateTime *arg1 = (wxDateTime *) 0 ;
22020 wxDateTime *arg2 = 0 ;
22021 bool result;
22022 PyObject * obj0 = 0 ;
22023 PyObject * obj1 = 0 ;
22024 char *kwnames[] = {
22025 (char *) "self",(char *) "datetime", NULL
22026 };
22027
22028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22030 if (SWIG_arg_fail(1)) SWIG_fail;
22031 {
22032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22033 if (SWIG_arg_fail(2)) SWIG_fail;
22034 if (arg2 == NULL) {
22035 SWIG_null_ref("wxDateTime");
22036 }
22037 if (SWIG_arg_fail(2)) SWIG_fail;
22038 }
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22042
22043 wxPyEndAllowThreads(__tstate);
22044 if (PyErr_Occurred()) SWIG_fail;
22045 }
22046 {
22047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22048 }
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22056 PyObject *resultobj;
22057 wxDateTime *arg1 = (wxDateTime *) 0 ;
22058 wxDateTime *arg2 = 0 ;
22059 bool result;
22060 PyObject * obj0 = 0 ;
22061 PyObject * obj1 = 0 ;
22062 char *kwnames[] = {
22063 (char *) "self",(char *) "datetime", NULL
22064 };
22065
22066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22068 if (SWIG_arg_fail(1)) SWIG_fail;
22069 {
22070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22071 if (SWIG_arg_fail(2)) SWIG_fail;
22072 if (arg2 == NULL) {
22073 SWIG_null_ref("wxDateTime");
22074 }
22075 if (SWIG_arg_fail(2)) SWIG_fail;
22076 }
22077 {
22078 PyThreadState* __tstate = wxPyBeginAllowThreads();
22079 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22080
22081 wxPyEndAllowThreads(__tstate);
22082 if (PyErr_Occurred()) SWIG_fail;
22083 }
22084 {
22085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22086 }
22087 return resultobj;
22088 fail:
22089 return NULL;
22090 }
22091
22092
22093 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22094 PyObject *resultobj;
22095 wxDateTime *arg1 = (wxDateTime *) 0 ;
22096 wxDateTime *arg2 = 0 ;
22097 wxDateTime *arg3 = 0 ;
22098 bool result;
22099 PyObject * obj0 = 0 ;
22100 PyObject * obj1 = 0 ;
22101 PyObject * obj2 = 0 ;
22102 char *kwnames[] = {
22103 (char *) "self",(char *) "t1",(char *) "t2", NULL
22104 };
22105
22106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22108 if (SWIG_arg_fail(1)) SWIG_fail;
22109 {
22110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22111 if (SWIG_arg_fail(2)) SWIG_fail;
22112 if (arg2 == NULL) {
22113 SWIG_null_ref("wxDateTime");
22114 }
22115 if (SWIG_arg_fail(2)) SWIG_fail;
22116 }
22117 {
22118 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22119 if (SWIG_arg_fail(3)) SWIG_fail;
22120 if (arg3 == NULL) {
22121 SWIG_null_ref("wxDateTime");
22122 }
22123 if (SWIG_arg_fail(3)) SWIG_fail;
22124 }
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22128
22129 wxPyEndAllowThreads(__tstate);
22130 if (PyErr_Occurred()) SWIG_fail;
22131 }
22132 {
22133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22134 }
22135 return resultobj;
22136 fail:
22137 return NULL;
22138 }
22139
22140
22141 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22142 PyObject *resultobj;
22143 wxDateTime *arg1 = (wxDateTime *) 0 ;
22144 wxDateTime *arg2 = 0 ;
22145 wxDateTime *arg3 = 0 ;
22146 bool result;
22147 PyObject * obj0 = 0 ;
22148 PyObject * obj1 = 0 ;
22149 PyObject * obj2 = 0 ;
22150 char *kwnames[] = {
22151 (char *) "self",(char *) "t1",(char *) "t2", NULL
22152 };
22153
22154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22156 if (SWIG_arg_fail(1)) SWIG_fail;
22157 {
22158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22159 if (SWIG_arg_fail(2)) SWIG_fail;
22160 if (arg2 == NULL) {
22161 SWIG_null_ref("wxDateTime");
22162 }
22163 if (SWIG_arg_fail(2)) SWIG_fail;
22164 }
22165 {
22166 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22167 if (SWIG_arg_fail(3)) SWIG_fail;
22168 if (arg3 == NULL) {
22169 SWIG_null_ref("wxDateTime");
22170 }
22171 if (SWIG_arg_fail(3)) SWIG_fail;
22172 }
22173 {
22174 PyThreadState* __tstate = wxPyBeginAllowThreads();
22175 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22176
22177 wxPyEndAllowThreads(__tstate);
22178 if (PyErr_Occurred()) SWIG_fail;
22179 }
22180 {
22181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22182 }
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj;
22191 wxDateTime *arg1 = (wxDateTime *) 0 ;
22192 wxDateTime *arg2 = 0 ;
22193 bool result;
22194 PyObject * obj0 = 0 ;
22195 PyObject * obj1 = 0 ;
22196 char *kwnames[] = {
22197 (char *) "self",(char *) "dt", NULL
22198 };
22199
22200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22202 if (SWIG_arg_fail(1)) SWIG_fail;
22203 {
22204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22205 if (SWIG_arg_fail(2)) SWIG_fail;
22206 if (arg2 == NULL) {
22207 SWIG_null_ref("wxDateTime");
22208 }
22209 if (SWIG_arg_fail(2)) SWIG_fail;
22210 }
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22214
22215 wxPyEndAllowThreads(__tstate);
22216 if (PyErr_Occurred()) SWIG_fail;
22217 }
22218 {
22219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22220 }
22221 return resultobj;
22222 fail:
22223 return NULL;
22224 }
22225
22226
22227 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22228 PyObject *resultobj;
22229 wxDateTime *arg1 = (wxDateTime *) 0 ;
22230 wxDateTime *arg2 = 0 ;
22231 bool result;
22232 PyObject * obj0 = 0 ;
22233 PyObject * obj1 = 0 ;
22234 char *kwnames[] = {
22235 (char *) "self",(char *) "dt", NULL
22236 };
22237
22238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22240 if (SWIG_arg_fail(1)) SWIG_fail;
22241 {
22242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22243 if (SWIG_arg_fail(2)) SWIG_fail;
22244 if (arg2 == NULL) {
22245 SWIG_null_ref("wxDateTime");
22246 }
22247 if (SWIG_arg_fail(2)) SWIG_fail;
22248 }
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22252
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 {
22257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22258 }
22259 return resultobj;
22260 fail:
22261 return NULL;
22262 }
22263
22264
22265 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22266 PyObject *resultobj;
22267 wxDateTime *arg1 = (wxDateTime *) 0 ;
22268 wxDateTime *arg2 = 0 ;
22269 wxTimeSpan *arg3 = 0 ;
22270 bool result;
22271 PyObject * obj0 = 0 ;
22272 PyObject * obj1 = 0 ;
22273 PyObject * obj2 = 0 ;
22274 char *kwnames[] = {
22275 (char *) "self",(char *) "dt",(char *) "ts", NULL
22276 };
22277
22278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22280 if (SWIG_arg_fail(1)) SWIG_fail;
22281 {
22282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22283 if (SWIG_arg_fail(2)) SWIG_fail;
22284 if (arg2 == NULL) {
22285 SWIG_null_ref("wxDateTime");
22286 }
22287 if (SWIG_arg_fail(2)) SWIG_fail;
22288 }
22289 {
22290 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22291 if (SWIG_arg_fail(3)) SWIG_fail;
22292 if (arg3 == NULL) {
22293 SWIG_null_ref("wxTimeSpan");
22294 }
22295 if (SWIG_arg_fail(3)) SWIG_fail;
22296 }
22297 {
22298 PyThreadState* __tstate = wxPyBeginAllowThreads();
22299 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22300
22301 wxPyEndAllowThreads(__tstate);
22302 if (PyErr_Occurred()) SWIG_fail;
22303 }
22304 {
22305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22306 }
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22314 PyObject *resultobj;
22315 wxDateTime *arg1 = (wxDateTime *) 0 ;
22316 wxTimeSpan *arg2 = 0 ;
22317 wxDateTime *result;
22318 PyObject * obj0 = 0 ;
22319 PyObject * obj1 = 0 ;
22320 char *kwnames[] = {
22321 (char *) "self",(char *) "diff", NULL
22322 };
22323
22324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22326 if (SWIG_arg_fail(1)) SWIG_fail;
22327 {
22328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22329 if (SWIG_arg_fail(2)) SWIG_fail;
22330 if (arg2 == NULL) {
22331 SWIG_null_ref("wxTimeSpan");
22332 }
22333 if (SWIG_arg_fail(2)) SWIG_fail;
22334 }
22335 {
22336 PyThreadState* __tstate = wxPyBeginAllowThreads();
22337 {
22338 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22339 result = (wxDateTime *) &_result_ref;
22340 }
22341
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxDateTime *arg1 = (wxDateTime *) 0 ;
22355 wxDateSpan *arg2 = 0 ;
22356 wxDateTime *result;
22357 PyObject * obj0 = 0 ;
22358 PyObject * obj1 = 0 ;
22359 char *kwnames[] = {
22360 (char *) "self",(char *) "diff", NULL
22361 };
22362
22363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22365 if (SWIG_arg_fail(1)) SWIG_fail;
22366 {
22367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22368 if (SWIG_arg_fail(2)) SWIG_fail;
22369 if (arg2 == NULL) {
22370 SWIG_null_ref("wxDateSpan");
22371 }
22372 if (SWIG_arg_fail(2)) SWIG_fail;
22373 }
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 {
22377 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22378 result = (wxDateTime *) &_result_ref;
22379 }
22380
22381 wxPyEndAllowThreads(__tstate);
22382 if (PyErr_Occurred()) SWIG_fail;
22383 }
22384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22392 PyObject *resultobj;
22393 wxDateTime *arg1 = (wxDateTime *) 0 ;
22394 wxTimeSpan *arg2 = 0 ;
22395 wxDateTime *result;
22396 PyObject * obj0 = 0 ;
22397 PyObject * obj1 = 0 ;
22398 char *kwnames[] = {
22399 (char *) "self",(char *) "diff", NULL
22400 };
22401
22402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22404 if (SWIG_arg_fail(1)) SWIG_fail;
22405 {
22406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22407 if (SWIG_arg_fail(2)) SWIG_fail;
22408 if (arg2 == NULL) {
22409 SWIG_null_ref("wxTimeSpan");
22410 }
22411 if (SWIG_arg_fail(2)) SWIG_fail;
22412 }
22413 {
22414 PyThreadState* __tstate = wxPyBeginAllowThreads();
22415 {
22416 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22417 result = (wxDateTime *) &_result_ref;
22418 }
22419
22420 wxPyEndAllowThreads(__tstate);
22421 if (PyErr_Occurred()) SWIG_fail;
22422 }
22423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22424 return resultobj;
22425 fail:
22426 return NULL;
22427 }
22428
22429
22430 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22431 PyObject *resultobj;
22432 wxDateTime *arg1 = (wxDateTime *) 0 ;
22433 wxDateSpan *arg2 = 0 ;
22434 wxDateTime *result;
22435 PyObject * obj0 = 0 ;
22436 PyObject * obj1 = 0 ;
22437 char *kwnames[] = {
22438 (char *) "self",(char *) "diff", NULL
22439 };
22440
22441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22443 if (SWIG_arg_fail(1)) SWIG_fail;
22444 {
22445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22446 if (SWIG_arg_fail(2)) SWIG_fail;
22447 if (arg2 == NULL) {
22448 SWIG_null_ref("wxDateSpan");
22449 }
22450 if (SWIG_arg_fail(2)) SWIG_fail;
22451 }
22452 {
22453 PyThreadState* __tstate = wxPyBeginAllowThreads();
22454 {
22455 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22456 result = (wxDateTime *) &_result_ref;
22457 }
22458
22459 wxPyEndAllowThreads(__tstate);
22460 if (PyErr_Occurred()) SWIG_fail;
22461 }
22462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22463 return resultobj;
22464 fail:
22465 return NULL;
22466 }
22467
22468
22469 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22470 PyObject *resultobj;
22471 wxDateTime *arg1 = (wxDateTime *) 0 ;
22472 wxDateTime *arg2 = 0 ;
22473 wxTimeSpan result;
22474 PyObject * obj0 = 0 ;
22475 PyObject * obj1 = 0 ;
22476 char *kwnames[] = {
22477 (char *) "self",(char *) "dt", NULL
22478 };
22479
22480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22482 if (SWIG_arg_fail(1)) SWIG_fail;
22483 {
22484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22485 if (SWIG_arg_fail(2)) SWIG_fail;
22486 if (arg2 == NULL) {
22487 SWIG_null_ref("wxDateTime");
22488 }
22489 if (SWIG_arg_fail(2)) SWIG_fail;
22490 }
22491 {
22492 PyThreadState* __tstate = wxPyBeginAllowThreads();
22493 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22494
22495 wxPyEndAllowThreads(__tstate);
22496 if (PyErr_Occurred()) SWIG_fail;
22497 }
22498 {
22499 wxTimeSpan * resultptr;
22500 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22501 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22502 }
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22510 PyObject *resultobj;
22511 wxDateTime *arg1 = (wxDateTime *) 0 ;
22512 wxTimeSpan *arg2 = 0 ;
22513 wxDateTime *result;
22514 PyObject * obj0 = 0 ;
22515 PyObject * obj1 = 0 ;
22516
22517 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22519 if (SWIG_arg_fail(1)) SWIG_fail;
22520 {
22521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22522 if (SWIG_arg_fail(2)) SWIG_fail;
22523 if (arg2 == NULL) {
22524 SWIG_null_ref("wxTimeSpan");
22525 }
22526 if (SWIG_arg_fail(2)) SWIG_fail;
22527 }
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 {
22531 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22532 result = (wxDateTime *) &_result_ref;
22533 }
22534
22535 wxPyEndAllowThreads(__tstate);
22536 if (PyErr_Occurred()) SWIG_fail;
22537 }
22538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22539 return resultobj;
22540 fail:
22541 return NULL;
22542 }
22543
22544
22545 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22546 PyObject *resultobj;
22547 wxDateTime *arg1 = (wxDateTime *) 0 ;
22548 wxDateSpan *arg2 = 0 ;
22549 wxDateTime *result;
22550 PyObject * obj0 = 0 ;
22551 PyObject * obj1 = 0 ;
22552
22553 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22555 if (SWIG_arg_fail(1)) SWIG_fail;
22556 {
22557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22558 if (SWIG_arg_fail(2)) SWIG_fail;
22559 if (arg2 == NULL) {
22560 SWIG_null_ref("wxDateSpan");
22561 }
22562 if (SWIG_arg_fail(2)) SWIG_fail;
22563 }
22564 {
22565 PyThreadState* __tstate = wxPyBeginAllowThreads();
22566 {
22567 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22568 result = (wxDateTime *) &_result_ref;
22569 }
22570
22571 wxPyEndAllowThreads(__tstate);
22572 if (PyErr_Occurred()) SWIG_fail;
22573 }
22574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22582 int argc;
22583 PyObject *argv[3];
22584 int ii;
22585
22586 argc = PyObject_Length(args);
22587 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22588 argv[ii] = PyTuple_GetItem(args,ii);
22589 }
22590 if (argc == 2) {
22591 int _v;
22592 {
22593 void *ptr;
22594 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22595 _v = 0;
22596 PyErr_Clear();
22597 } else {
22598 _v = 1;
22599 }
22600 }
22601 if (_v) {
22602 {
22603 void *ptr = 0;
22604 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22605 _v = 0;
22606 PyErr_Clear();
22607 } else {
22608 _v = (ptr != 0);
22609 }
22610 }
22611 if (_v) {
22612 return _wrap_DateTime___iadd____SWIG_0(self,args);
22613 }
22614 }
22615 }
22616 if (argc == 2) {
22617 int _v;
22618 {
22619 void *ptr;
22620 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22621 _v = 0;
22622 PyErr_Clear();
22623 } else {
22624 _v = 1;
22625 }
22626 }
22627 if (_v) {
22628 {
22629 void *ptr = 0;
22630 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22631 _v = 0;
22632 PyErr_Clear();
22633 } else {
22634 _v = (ptr != 0);
22635 }
22636 }
22637 if (_v) {
22638 return _wrap_DateTime___iadd____SWIG_1(self,args);
22639 }
22640 }
22641 }
22642
22643 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22644 return NULL;
22645 }
22646
22647
22648 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22649 PyObject *resultobj;
22650 wxDateTime *arg1 = (wxDateTime *) 0 ;
22651 wxTimeSpan *arg2 = 0 ;
22652 wxDateTime *result;
22653 PyObject * obj0 = 0 ;
22654 PyObject * obj1 = 0 ;
22655
22656 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22658 if (SWIG_arg_fail(1)) SWIG_fail;
22659 {
22660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22661 if (SWIG_arg_fail(2)) SWIG_fail;
22662 if (arg2 == NULL) {
22663 SWIG_null_ref("wxTimeSpan");
22664 }
22665 if (SWIG_arg_fail(2)) SWIG_fail;
22666 }
22667 {
22668 PyThreadState* __tstate = wxPyBeginAllowThreads();
22669 {
22670 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22671 result = (wxDateTime *) &_result_ref;
22672 }
22673
22674 wxPyEndAllowThreads(__tstate);
22675 if (PyErr_Occurred()) SWIG_fail;
22676 }
22677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22685 PyObject *resultobj;
22686 wxDateTime *arg1 = (wxDateTime *) 0 ;
22687 wxDateSpan *arg2 = 0 ;
22688 wxDateTime *result;
22689 PyObject * obj0 = 0 ;
22690 PyObject * obj1 = 0 ;
22691
22692 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22694 if (SWIG_arg_fail(1)) SWIG_fail;
22695 {
22696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22697 if (SWIG_arg_fail(2)) SWIG_fail;
22698 if (arg2 == NULL) {
22699 SWIG_null_ref("wxDateSpan");
22700 }
22701 if (SWIG_arg_fail(2)) SWIG_fail;
22702 }
22703 {
22704 PyThreadState* __tstate = wxPyBeginAllowThreads();
22705 {
22706 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22707 result = (wxDateTime *) &_result_ref;
22708 }
22709
22710 wxPyEndAllowThreads(__tstate);
22711 if (PyErr_Occurred()) SWIG_fail;
22712 }
22713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22714 return resultobj;
22715 fail:
22716 return NULL;
22717 }
22718
22719
22720 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22721 int argc;
22722 PyObject *argv[3];
22723 int ii;
22724
22725 argc = PyObject_Length(args);
22726 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22727 argv[ii] = PyTuple_GetItem(args,ii);
22728 }
22729 if (argc == 2) {
22730 int _v;
22731 {
22732 void *ptr;
22733 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22734 _v = 0;
22735 PyErr_Clear();
22736 } else {
22737 _v = 1;
22738 }
22739 }
22740 if (_v) {
22741 {
22742 void *ptr = 0;
22743 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22744 _v = 0;
22745 PyErr_Clear();
22746 } else {
22747 _v = (ptr != 0);
22748 }
22749 }
22750 if (_v) {
22751 return _wrap_DateTime___isub____SWIG_0(self,args);
22752 }
22753 }
22754 }
22755 if (argc == 2) {
22756 int _v;
22757 {
22758 void *ptr;
22759 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22760 _v = 0;
22761 PyErr_Clear();
22762 } else {
22763 _v = 1;
22764 }
22765 }
22766 if (_v) {
22767 {
22768 void *ptr = 0;
22769 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22770 _v = 0;
22771 PyErr_Clear();
22772 } else {
22773 _v = (ptr != 0);
22774 }
22775 }
22776 if (_v) {
22777 return _wrap_DateTime___isub____SWIG_1(self,args);
22778 }
22779 }
22780 }
22781
22782 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22783 return NULL;
22784 }
22785
22786
22787 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22788 PyObject *resultobj;
22789 wxDateTime *arg1 = (wxDateTime *) 0 ;
22790 wxTimeSpan *arg2 = 0 ;
22791 wxDateTime result;
22792 PyObject * obj0 = 0 ;
22793 PyObject * obj1 = 0 ;
22794
22795 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22797 if (SWIG_arg_fail(1)) SWIG_fail;
22798 {
22799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22800 if (SWIG_arg_fail(2)) SWIG_fail;
22801 if (arg2 == NULL) {
22802 SWIG_null_ref("wxTimeSpan");
22803 }
22804 if (SWIG_arg_fail(2)) SWIG_fail;
22805 }
22806 {
22807 PyThreadState* __tstate = wxPyBeginAllowThreads();
22808 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22809
22810 wxPyEndAllowThreads(__tstate);
22811 if (PyErr_Occurred()) SWIG_fail;
22812 }
22813 {
22814 wxDateTime * resultptr;
22815 resultptr = new wxDateTime((wxDateTime &)(result));
22816 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22817 }
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22825 PyObject *resultobj;
22826 wxDateTime *arg1 = (wxDateTime *) 0 ;
22827 wxDateSpan *arg2 = 0 ;
22828 wxDateTime result;
22829 PyObject * obj0 = 0 ;
22830 PyObject * obj1 = 0 ;
22831
22832 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22834 if (SWIG_arg_fail(1)) SWIG_fail;
22835 {
22836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22837 if (SWIG_arg_fail(2)) SWIG_fail;
22838 if (arg2 == NULL) {
22839 SWIG_null_ref("wxDateSpan");
22840 }
22841 if (SWIG_arg_fail(2)) SWIG_fail;
22842 }
22843 {
22844 PyThreadState* __tstate = wxPyBeginAllowThreads();
22845 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22846
22847 wxPyEndAllowThreads(__tstate);
22848 if (PyErr_Occurred()) SWIG_fail;
22849 }
22850 {
22851 wxDateTime * resultptr;
22852 resultptr = new wxDateTime((wxDateTime &)(result));
22853 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22854 }
22855 return resultobj;
22856 fail:
22857 return NULL;
22858 }
22859
22860
22861 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22862 int argc;
22863 PyObject *argv[3];
22864 int ii;
22865
22866 argc = PyObject_Length(args);
22867 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22868 argv[ii] = PyTuple_GetItem(args,ii);
22869 }
22870 if (argc == 2) {
22871 int _v;
22872 {
22873 void *ptr;
22874 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22875 _v = 0;
22876 PyErr_Clear();
22877 } else {
22878 _v = 1;
22879 }
22880 }
22881 if (_v) {
22882 {
22883 void *ptr = 0;
22884 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22885 _v = 0;
22886 PyErr_Clear();
22887 } else {
22888 _v = (ptr != 0);
22889 }
22890 }
22891 if (_v) {
22892 return _wrap_DateTime___add____SWIG_0(self,args);
22893 }
22894 }
22895 }
22896 if (argc == 2) {
22897 int _v;
22898 {
22899 void *ptr;
22900 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22901 _v = 0;
22902 PyErr_Clear();
22903 } else {
22904 _v = 1;
22905 }
22906 }
22907 if (_v) {
22908 {
22909 void *ptr = 0;
22910 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22911 _v = 0;
22912 PyErr_Clear();
22913 } else {
22914 _v = (ptr != 0);
22915 }
22916 }
22917 if (_v) {
22918 return _wrap_DateTime___add____SWIG_1(self,args);
22919 }
22920 }
22921 }
22922
22923 Py_INCREF(Py_NotImplemented);
22924 return Py_NotImplemented;
22925 }
22926
22927
22928 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22929 PyObject *resultobj;
22930 wxDateTime *arg1 = (wxDateTime *) 0 ;
22931 wxDateTime *arg2 = 0 ;
22932 wxTimeSpan result;
22933 PyObject * obj0 = 0 ;
22934 PyObject * obj1 = 0 ;
22935
22936 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22938 if (SWIG_arg_fail(1)) SWIG_fail;
22939 {
22940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22941 if (SWIG_arg_fail(2)) SWIG_fail;
22942 if (arg2 == NULL) {
22943 SWIG_null_ref("wxDateTime");
22944 }
22945 if (SWIG_arg_fail(2)) SWIG_fail;
22946 }
22947 {
22948 PyThreadState* __tstate = wxPyBeginAllowThreads();
22949 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22950
22951 wxPyEndAllowThreads(__tstate);
22952 if (PyErr_Occurred()) SWIG_fail;
22953 }
22954 {
22955 wxTimeSpan * resultptr;
22956 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22958 }
22959 return resultobj;
22960 fail:
22961 return NULL;
22962 }
22963
22964
22965 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22966 PyObject *resultobj;
22967 wxDateTime *arg1 = (wxDateTime *) 0 ;
22968 wxTimeSpan *arg2 = 0 ;
22969 wxDateTime result;
22970 PyObject * obj0 = 0 ;
22971 PyObject * obj1 = 0 ;
22972
22973 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22975 if (SWIG_arg_fail(1)) SWIG_fail;
22976 {
22977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22978 if (SWIG_arg_fail(2)) SWIG_fail;
22979 if (arg2 == NULL) {
22980 SWIG_null_ref("wxTimeSpan");
22981 }
22982 if (SWIG_arg_fail(2)) SWIG_fail;
22983 }
22984 {
22985 PyThreadState* __tstate = wxPyBeginAllowThreads();
22986 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22987
22988 wxPyEndAllowThreads(__tstate);
22989 if (PyErr_Occurred()) SWIG_fail;
22990 }
22991 {
22992 wxDateTime * resultptr;
22993 resultptr = new wxDateTime((wxDateTime &)(result));
22994 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22995 }
22996 return resultobj;
22997 fail:
22998 return NULL;
22999 }
23000
23001
23002 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23003 PyObject *resultobj;
23004 wxDateTime *arg1 = (wxDateTime *) 0 ;
23005 wxDateSpan *arg2 = 0 ;
23006 wxDateTime result;
23007 PyObject * obj0 = 0 ;
23008 PyObject * obj1 = 0 ;
23009
23010 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23012 if (SWIG_arg_fail(1)) SWIG_fail;
23013 {
23014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23015 if (SWIG_arg_fail(2)) SWIG_fail;
23016 if (arg2 == NULL) {
23017 SWIG_null_ref("wxDateSpan");
23018 }
23019 if (SWIG_arg_fail(2)) SWIG_fail;
23020 }
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23024
23025 wxPyEndAllowThreads(__tstate);
23026 if (PyErr_Occurred()) SWIG_fail;
23027 }
23028 {
23029 wxDateTime * resultptr;
23030 resultptr = new wxDateTime((wxDateTime &)(result));
23031 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23032 }
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23040 int argc;
23041 PyObject *argv[3];
23042 int ii;
23043
23044 argc = PyObject_Length(args);
23045 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23046 argv[ii] = PyTuple_GetItem(args,ii);
23047 }
23048 if (argc == 2) {
23049 int _v;
23050 {
23051 void *ptr;
23052 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23053 _v = 0;
23054 PyErr_Clear();
23055 } else {
23056 _v = 1;
23057 }
23058 }
23059 if (_v) {
23060 {
23061 void *ptr = 0;
23062 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23063 _v = 0;
23064 PyErr_Clear();
23065 } else {
23066 _v = (ptr != 0);
23067 }
23068 }
23069 if (_v) {
23070 return _wrap_DateTime___sub____SWIG_0(self,args);
23071 }
23072 }
23073 }
23074 if (argc == 2) {
23075 int _v;
23076 {
23077 void *ptr;
23078 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23079 _v = 0;
23080 PyErr_Clear();
23081 } else {
23082 _v = 1;
23083 }
23084 }
23085 if (_v) {
23086 {
23087 void *ptr = 0;
23088 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23089 _v = 0;
23090 PyErr_Clear();
23091 } else {
23092 _v = (ptr != 0);
23093 }
23094 }
23095 if (_v) {
23096 return _wrap_DateTime___sub____SWIG_1(self,args);
23097 }
23098 }
23099 }
23100 if (argc == 2) {
23101 int _v;
23102 {
23103 void *ptr;
23104 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23105 _v = 0;
23106 PyErr_Clear();
23107 } else {
23108 _v = 1;
23109 }
23110 }
23111 if (_v) {
23112 {
23113 void *ptr = 0;
23114 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23115 _v = 0;
23116 PyErr_Clear();
23117 } else {
23118 _v = (ptr != 0);
23119 }
23120 }
23121 if (_v) {
23122 return _wrap_DateTime___sub____SWIG_2(self,args);
23123 }
23124 }
23125 }
23126
23127 Py_INCREF(Py_NotImplemented);
23128 return Py_NotImplemented;
23129 }
23130
23131
23132 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23133 PyObject *resultobj;
23134 wxDateTime *arg1 = (wxDateTime *) 0 ;
23135 wxDateTime *arg2 = (wxDateTime *) 0 ;
23136 bool result;
23137 PyObject * obj0 = 0 ;
23138 PyObject * obj1 = 0 ;
23139 char *kwnames[] = {
23140 (char *) "self",(char *) "other", NULL
23141 };
23142
23143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23145 if (SWIG_arg_fail(1)) SWIG_fail;
23146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23147 if (SWIG_arg_fail(2)) SWIG_fail;
23148 {
23149 PyThreadState* __tstate = wxPyBeginAllowThreads();
23150 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23151
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 {
23156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23157 }
23158 return resultobj;
23159 fail:
23160 return NULL;
23161 }
23162
23163
23164 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23165 PyObject *resultobj;
23166 wxDateTime *arg1 = (wxDateTime *) 0 ;
23167 wxDateTime *arg2 = (wxDateTime *) 0 ;
23168 bool result;
23169 PyObject * obj0 = 0 ;
23170 PyObject * obj1 = 0 ;
23171 char *kwnames[] = {
23172 (char *) "self",(char *) "other", NULL
23173 };
23174
23175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23177 if (SWIG_arg_fail(1)) SWIG_fail;
23178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23179 if (SWIG_arg_fail(2)) SWIG_fail;
23180 {
23181 PyThreadState* __tstate = wxPyBeginAllowThreads();
23182 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23183
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 {
23188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23189 }
23190 return resultobj;
23191 fail:
23192 return NULL;
23193 }
23194
23195
23196 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23197 PyObject *resultobj;
23198 wxDateTime *arg1 = (wxDateTime *) 0 ;
23199 wxDateTime *arg2 = (wxDateTime *) 0 ;
23200 bool result;
23201 PyObject * obj0 = 0 ;
23202 PyObject * obj1 = 0 ;
23203 char *kwnames[] = {
23204 (char *) "self",(char *) "other", NULL
23205 };
23206
23207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23209 if (SWIG_arg_fail(1)) SWIG_fail;
23210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23211 if (SWIG_arg_fail(2)) SWIG_fail;
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23215
23216 wxPyEndAllowThreads(__tstate);
23217 if (PyErr_Occurred()) SWIG_fail;
23218 }
23219 {
23220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23221 }
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23229 PyObject *resultobj;
23230 wxDateTime *arg1 = (wxDateTime *) 0 ;
23231 wxDateTime *arg2 = (wxDateTime *) 0 ;
23232 bool result;
23233 PyObject * obj0 = 0 ;
23234 PyObject * obj1 = 0 ;
23235 char *kwnames[] = {
23236 (char *) "self",(char *) "other", NULL
23237 };
23238
23239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23241 if (SWIG_arg_fail(1)) SWIG_fail;
23242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23243 if (SWIG_arg_fail(2)) SWIG_fail;
23244 {
23245 PyThreadState* __tstate = wxPyBeginAllowThreads();
23246 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23247
23248 wxPyEndAllowThreads(__tstate);
23249 if (PyErr_Occurred()) SWIG_fail;
23250 }
23251 {
23252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23253 }
23254 return resultobj;
23255 fail:
23256 return NULL;
23257 }
23258
23259
23260 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23261 PyObject *resultobj;
23262 wxDateTime *arg1 = (wxDateTime *) 0 ;
23263 wxDateTime *arg2 = (wxDateTime *) 0 ;
23264 bool result;
23265 PyObject * obj0 = 0 ;
23266 PyObject * obj1 = 0 ;
23267 char *kwnames[] = {
23268 (char *) "self",(char *) "other", NULL
23269 };
23270
23271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23273 if (SWIG_arg_fail(1)) SWIG_fail;
23274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23275 if (SWIG_arg_fail(2)) SWIG_fail;
23276 {
23277 PyThreadState* __tstate = wxPyBeginAllowThreads();
23278 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23279
23280 wxPyEndAllowThreads(__tstate);
23281 if (PyErr_Occurred()) SWIG_fail;
23282 }
23283 {
23284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23285 }
23286 return resultobj;
23287 fail:
23288 return NULL;
23289 }
23290
23291
23292 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23293 PyObject *resultobj;
23294 wxDateTime *arg1 = (wxDateTime *) 0 ;
23295 wxDateTime *arg2 = (wxDateTime *) 0 ;
23296 bool result;
23297 PyObject * obj0 = 0 ;
23298 PyObject * obj1 = 0 ;
23299 char *kwnames[] = {
23300 (char *) "self",(char *) "other", NULL
23301 };
23302
23303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23305 if (SWIG_arg_fail(1)) SWIG_fail;
23306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23307 if (SWIG_arg_fail(2)) SWIG_fail;
23308 {
23309 PyThreadState* __tstate = wxPyBeginAllowThreads();
23310 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23311
23312 wxPyEndAllowThreads(__tstate);
23313 if (PyErr_Occurred()) SWIG_fail;
23314 }
23315 {
23316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23317 }
23318 return resultobj;
23319 fail:
23320 return NULL;
23321 }
23322
23323
23324 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23325 PyObject *resultobj;
23326 wxDateTime *arg1 = (wxDateTime *) 0 ;
23327 wxString *arg2 = 0 ;
23328 int result;
23329 bool temp2 = false ;
23330 PyObject * obj0 = 0 ;
23331 PyObject * obj1 = 0 ;
23332 char *kwnames[] = {
23333 (char *) "self",(char *) "date", NULL
23334 };
23335
23336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23338 if (SWIG_arg_fail(1)) SWIG_fail;
23339 {
23340 arg2 = wxString_in_helper(obj1);
23341 if (arg2 == NULL) SWIG_fail;
23342 temp2 = true;
23343 }
23344 {
23345 PyThreadState* __tstate = wxPyBeginAllowThreads();
23346 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23347
23348 wxPyEndAllowThreads(__tstate);
23349 if (PyErr_Occurred()) SWIG_fail;
23350 }
23351 {
23352 resultobj = SWIG_From_int((int)(result));
23353 }
23354 {
23355 if (temp2)
23356 delete arg2;
23357 }
23358 return resultobj;
23359 fail:
23360 {
23361 if (temp2)
23362 delete arg2;
23363 }
23364 return NULL;
23365 }
23366
23367
23368 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23369 PyObject *resultobj;
23370 wxDateTime *arg1 = (wxDateTime *) 0 ;
23371 wxString *arg2 = 0 ;
23372 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23373 wxString *arg3 = (wxString *) &arg3_defvalue ;
23374 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23375 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23376 int result;
23377 bool temp2 = false ;
23378 bool temp3 = false ;
23379 PyObject * obj0 = 0 ;
23380 PyObject * obj1 = 0 ;
23381 PyObject * obj2 = 0 ;
23382 PyObject * obj3 = 0 ;
23383 char *kwnames[] = {
23384 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23385 };
23386
23387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23389 if (SWIG_arg_fail(1)) SWIG_fail;
23390 {
23391 arg2 = wxString_in_helper(obj1);
23392 if (arg2 == NULL) SWIG_fail;
23393 temp2 = true;
23394 }
23395 if (obj2) {
23396 {
23397 arg3 = wxString_in_helper(obj2);
23398 if (arg3 == NULL) SWIG_fail;
23399 temp3 = true;
23400 }
23401 }
23402 if (obj3) {
23403 {
23404 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23405 if (SWIG_arg_fail(4)) SWIG_fail;
23406 if (arg4 == NULL) {
23407 SWIG_null_ref("wxDateTime");
23408 }
23409 if (SWIG_arg_fail(4)) SWIG_fail;
23410 }
23411 }
23412 {
23413 PyThreadState* __tstate = wxPyBeginAllowThreads();
23414 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23415
23416 wxPyEndAllowThreads(__tstate);
23417 if (PyErr_Occurred()) SWIG_fail;
23418 }
23419 {
23420 resultobj = SWIG_From_int((int)(result));
23421 }
23422 {
23423 if (temp2)
23424 delete arg2;
23425 }
23426 {
23427 if (temp3)
23428 delete arg3;
23429 }
23430 return resultobj;
23431 fail:
23432 {
23433 if (temp2)
23434 delete arg2;
23435 }
23436 {
23437 if (temp3)
23438 delete arg3;
23439 }
23440 return NULL;
23441 }
23442
23443
23444 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj;
23446 wxDateTime *arg1 = (wxDateTime *) 0 ;
23447 wxString *arg2 = 0 ;
23448 int result;
23449 bool temp2 = false ;
23450 PyObject * obj0 = 0 ;
23451 PyObject * obj1 = 0 ;
23452 char *kwnames[] = {
23453 (char *) "self",(char *) "datetime", NULL
23454 };
23455
23456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23458 if (SWIG_arg_fail(1)) SWIG_fail;
23459 {
23460 arg2 = wxString_in_helper(obj1);
23461 if (arg2 == NULL) SWIG_fail;
23462 temp2 = true;
23463 }
23464 {
23465 PyThreadState* __tstate = wxPyBeginAllowThreads();
23466 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23467
23468 wxPyEndAllowThreads(__tstate);
23469 if (PyErr_Occurred()) SWIG_fail;
23470 }
23471 {
23472 resultobj = SWIG_From_int((int)(result));
23473 }
23474 {
23475 if (temp2)
23476 delete arg2;
23477 }
23478 return resultobj;
23479 fail:
23480 {
23481 if (temp2)
23482 delete arg2;
23483 }
23484 return NULL;
23485 }
23486
23487
23488 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23489 PyObject *resultobj;
23490 wxDateTime *arg1 = (wxDateTime *) 0 ;
23491 wxString *arg2 = 0 ;
23492 int result;
23493 bool temp2 = false ;
23494 PyObject * obj0 = 0 ;
23495 PyObject * obj1 = 0 ;
23496 char *kwnames[] = {
23497 (char *) "self",(char *) "date", NULL
23498 };
23499
23500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23502 if (SWIG_arg_fail(1)) SWIG_fail;
23503 {
23504 arg2 = wxString_in_helper(obj1);
23505 if (arg2 == NULL) SWIG_fail;
23506 temp2 = true;
23507 }
23508 {
23509 PyThreadState* __tstate = wxPyBeginAllowThreads();
23510 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23511
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 {
23516 resultobj = SWIG_From_int((int)(result));
23517 }
23518 {
23519 if (temp2)
23520 delete arg2;
23521 }
23522 return resultobj;
23523 fail:
23524 {
23525 if (temp2)
23526 delete arg2;
23527 }
23528 return NULL;
23529 }
23530
23531
23532 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23533 PyObject *resultobj;
23534 wxDateTime *arg1 = (wxDateTime *) 0 ;
23535 wxString *arg2 = 0 ;
23536 int result;
23537 bool temp2 = false ;
23538 PyObject * obj0 = 0 ;
23539 PyObject * obj1 = 0 ;
23540 char *kwnames[] = {
23541 (char *) "self",(char *) "time", NULL
23542 };
23543
23544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23546 if (SWIG_arg_fail(1)) SWIG_fail;
23547 {
23548 arg2 = wxString_in_helper(obj1);
23549 if (arg2 == NULL) SWIG_fail;
23550 temp2 = true;
23551 }
23552 {
23553 PyThreadState* __tstate = wxPyBeginAllowThreads();
23554 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23555
23556 wxPyEndAllowThreads(__tstate);
23557 if (PyErr_Occurred()) SWIG_fail;
23558 }
23559 {
23560 resultobj = SWIG_From_int((int)(result));
23561 }
23562 {
23563 if (temp2)
23564 delete arg2;
23565 }
23566 return resultobj;
23567 fail:
23568 {
23569 if (temp2)
23570 delete arg2;
23571 }
23572 return NULL;
23573 }
23574
23575
23576 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj;
23578 wxDateTime *arg1 = (wxDateTime *) 0 ;
23579 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23580 wxString *arg2 = (wxString *) &arg2_defvalue ;
23581 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23582 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23583 wxString result;
23584 bool temp2 = false ;
23585 bool temp3 = false ;
23586 PyObject * obj0 = 0 ;
23587 PyObject * obj1 = 0 ;
23588 PyObject * obj2 = 0 ;
23589 char *kwnames[] = {
23590 (char *) "self",(char *) "format",(char *) "tz", NULL
23591 };
23592
23593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23595 if (SWIG_arg_fail(1)) SWIG_fail;
23596 if (obj1) {
23597 {
23598 arg2 = wxString_in_helper(obj1);
23599 if (arg2 == NULL) SWIG_fail;
23600 temp2 = true;
23601 }
23602 }
23603 if (obj2) {
23604 {
23605 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23606 temp3 = true;
23607 }
23608 }
23609 {
23610 PyThreadState* __tstate = wxPyBeginAllowThreads();
23611 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23612
23613 wxPyEndAllowThreads(__tstate);
23614 if (PyErr_Occurred()) SWIG_fail;
23615 }
23616 {
23617 #if wxUSE_UNICODE
23618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23619 #else
23620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23621 #endif
23622 }
23623 {
23624 if (temp2)
23625 delete arg2;
23626 }
23627 {
23628 if (temp3) delete arg3;
23629 }
23630 return resultobj;
23631 fail:
23632 {
23633 if (temp2)
23634 delete arg2;
23635 }
23636 {
23637 if (temp3) delete arg3;
23638 }
23639 return NULL;
23640 }
23641
23642
23643 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23644 PyObject *resultobj;
23645 wxDateTime *arg1 = (wxDateTime *) 0 ;
23646 wxString result;
23647 PyObject * obj0 = 0 ;
23648 char *kwnames[] = {
23649 (char *) "self", NULL
23650 };
23651
23652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23654 if (SWIG_arg_fail(1)) SWIG_fail;
23655 {
23656 PyThreadState* __tstate = wxPyBeginAllowThreads();
23657 result = ((wxDateTime const *)arg1)->FormatDate();
23658
23659 wxPyEndAllowThreads(__tstate);
23660 if (PyErr_Occurred()) SWIG_fail;
23661 }
23662 {
23663 #if wxUSE_UNICODE
23664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23665 #else
23666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23667 #endif
23668 }
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23676 PyObject *resultobj;
23677 wxDateTime *arg1 = (wxDateTime *) 0 ;
23678 wxString result;
23679 PyObject * obj0 = 0 ;
23680 char *kwnames[] = {
23681 (char *) "self", NULL
23682 };
23683
23684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23686 if (SWIG_arg_fail(1)) SWIG_fail;
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 result = ((wxDateTime const *)arg1)->FormatTime();
23690
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 {
23695 #if wxUSE_UNICODE
23696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23697 #else
23698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23699 #endif
23700 }
23701 return resultobj;
23702 fail:
23703 return NULL;
23704 }
23705
23706
23707 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23708 PyObject *resultobj;
23709 wxDateTime *arg1 = (wxDateTime *) 0 ;
23710 wxString result;
23711 PyObject * obj0 = 0 ;
23712 char *kwnames[] = {
23713 (char *) "self", NULL
23714 };
23715
23716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23718 if (SWIG_arg_fail(1)) SWIG_fail;
23719 {
23720 PyThreadState* __tstate = wxPyBeginAllowThreads();
23721 result = ((wxDateTime const *)arg1)->FormatISODate();
23722
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 {
23727 #if wxUSE_UNICODE
23728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23729 #else
23730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23731 #endif
23732 }
23733 return resultobj;
23734 fail:
23735 return NULL;
23736 }
23737
23738
23739 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23740 PyObject *resultobj;
23741 wxDateTime *arg1 = (wxDateTime *) 0 ;
23742 wxString result;
23743 PyObject * obj0 = 0 ;
23744 char *kwnames[] = {
23745 (char *) "self", NULL
23746 };
23747
23748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23750 if (SWIG_arg_fail(1)) SWIG_fail;
23751 {
23752 PyThreadState* __tstate = wxPyBeginAllowThreads();
23753 result = ((wxDateTime const *)arg1)->FormatISOTime();
23754
23755 wxPyEndAllowThreads(__tstate);
23756 if (PyErr_Occurred()) SWIG_fail;
23757 }
23758 {
23759 #if wxUSE_UNICODE
23760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23761 #else
23762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23763 #endif
23764 }
23765 return resultobj;
23766 fail:
23767 return NULL;
23768 }
23769
23770
23771 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23772 PyObject *obj;
23773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23774 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23775 Py_INCREF(obj);
23776 return Py_BuildValue((char *)"");
23777 }
23778 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23779 PyObject *resultobj;
23780 long arg1 ;
23781 wxTimeSpan result;
23782 PyObject * obj0 = 0 ;
23783 char *kwnames[] = {
23784 (char *) "sec", NULL
23785 };
23786
23787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23788 {
23789 arg1 = (long)(SWIG_As_long(obj0));
23790 if (SWIG_arg_fail(1)) SWIG_fail;
23791 }
23792 {
23793 PyThreadState* __tstate = wxPyBeginAllowThreads();
23794 result = wxTimeSpan::Seconds(arg1);
23795
23796 wxPyEndAllowThreads(__tstate);
23797 if (PyErr_Occurred()) SWIG_fail;
23798 }
23799 {
23800 wxTimeSpan * resultptr;
23801 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23802 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23803 }
23804 return resultobj;
23805 fail:
23806 return NULL;
23807 }
23808
23809
23810 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23811 PyObject *resultobj;
23812 wxTimeSpan result;
23813 char *kwnames[] = {
23814 NULL
23815 };
23816
23817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23818 {
23819 PyThreadState* __tstate = wxPyBeginAllowThreads();
23820 result = wxTimeSpan::Second();
23821
23822 wxPyEndAllowThreads(__tstate);
23823 if (PyErr_Occurred()) SWIG_fail;
23824 }
23825 {
23826 wxTimeSpan * resultptr;
23827 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23829 }
23830 return resultobj;
23831 fail:
23832 return NULL;
23833 }
23834
23835
23836 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj;
23838 long arg1 ;
23839 wxTimeSpan result;
23840 PyObject * obj0 = 0 ;
23841 char *kwnames[] = {
23842 (char *) "min", NULL
23843 };
23844
23845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23846 {
23847 arg1 = (long)(SWIG_As_long(obj0));
23848 if (SWIG_arg_fail(1)) SWIG_fail;
23849 }
23850 {
23851 PyThreadState* __tstate = wxPyBeginAllowThreads();
23852 result = wxTimeSpan::Minutes(arg1);
23853
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 {
23858 wxTimeSpan * resultptr;
23859 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23860 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23861 }
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23869 PyObject *resultobj;
23870 wxTimeSpan result;
23871 char *kwnames[] = {
23872 NULL
23873 };
23874
23875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23876 {
23877 PyThreadState* __tstate = wxPyBeginAllowThreads();
23878 result = wxTimeSpan::Minute();
23879
23880 wxPyEndAllowThreads(__tstate);
23881 if (PyErr_Occurred()) SWIG_fail;
23882 }
23883 {
23884 wxTimeSpan * resultptr;
23885 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23887 }
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj;
23896 long arg1 ;
23897 wxTimeSpan result;
23898 PyObject * obj0 = 0 ;
23899 char *kwnames[] = {
23900 (char *) "hours", NULL
23901 };
23902
23903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23904 {
23905 arg1 = (long)(SWIG_As_long(obj0));
23906 if (SWIG_arg_fail(1)) SWIG_fail;
23907 }
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = wxTimeSpan::Hours(arg1);
23911
23912 wxPyEndAllowThreads(__tstate);
23913 if (PyErr_Occurred()) SWIG_fail;
23914 }
23915 {
23916 wxTimeSpan * resultptr;
23917 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23919 }
23920 return resultobj;
23921 fail:
23922 return NULL;
23923 }
23924
23925
23926 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23927 PyObject *resultobj;
23928 wxTimeSpan result;
23929 char *kwnames[] = {
23930 NULL
23931 };
23932
23933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 result = wxTimeSpan::Hour();
23937
23938 wxPyEndAllowThreads(__tstate);
23939 if (PyErr_Occurred()) SWIG_fail;
23940 }
23941 {
23942 wxTimeSpan * resultptr;
23943 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23945 }
23946 return resultobj;
23947 fail:
23948 return NULL;
23949 }
23950
23951
23952 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23953 PyObject *resultobj;
23954 long arg1 ;
23955 wxTimeSpan result;
23956 PyObject * obj0 = 0 ;
23957 char *kwnames[] = {
23958 (char *) "days", NULL
23959 };
23960
23961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23962 {
23963 arg1 = (long)(SWIG_As_long(obj0));
23964 if (SWIG_arg_fail(1)) SWIG_fail;
23965 }
23966 {
23967 PyThreadState* __tstate = wxPyBeginAllowThreads();
23968 result = wxTimeSpan::Days(arg1);
23969
23970 wxPyEndAllowThreads(__tstate);
23971 if (PyErr_Occurred()) SWIG_fail;
23972 }
23973 {
23974 wxTimeSpan * resultptr;
23975 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23976 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23977 }
23978 return resultobj;
23979 fail:
23980 return NULL;
23981 }
23982
23983
23984 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23985 PyObject *resultobj;
23986 wxTimeSpan result;
23987 char *kwnames[] = {
23988 NULL
23989 };
23990
23991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 result = wxTimeSpan::Day();
23995
23996 wxPyEndAllowThreads(__tstate);
23997 if (PyErr_Occurred()) SWIG_fail;
23998 }
23999 {
24000 wxTimeSpan * resultptr;
24001 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24003 }
24004 return resultobj;
24005 fail:
24006 return NULL;
24007 }
24008
24009
24010 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24011 PyObject *resultobj;
24012 long arg1 ;
24013 wxTimeSpan result;
24014 PyObject * obj0 = 0 ;
24015 char *kwnames[] = {
24016 (char *) "days", NULL
24017 };
24018
24019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24020 {
24021 arg1 = (long)(SWIG_As_long(obj0));
24022 if (SWIG_arg_fail(1)) SWIG_fail;
24023 }
24024 {
24025 PyThreadState* __tstate = wxPyBeginAllowThreads();
24026 result = wxTimeSpan::Weeks(arg1);
24027
24028 wxPyEndAllowThreads(__tstate);
24029 if (PyErr_Occurred()) SWIG_fail;
24030 }
24031 {
24032 wxTimeSpan * resultptr;
24033 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24034 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24035 }
24036 return resultobj;
24037 fail:
24038 return NULL;
24039 }
24040
24041
24042 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24043 PyObject *resultobj;
24044 wxTimeSpan result;
24045 char *kwnames[] = {
24046 NULL
24047 };
24048
24049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = wxTimeSpan::Week();
24053
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 {
24058 wxTimeSpan * resultptr;
24059 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24060 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24061 }
24062 return resultobj;
24063 fail:
24064 return NULL;
24065 }
24066
24067
24068 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24069 PyObject *resultobj;
24070 long arg1 = (long) 0 ;
24071 long arg2 = (long) 0 ;
24072 long arg3 = (long) 0 ;
24073 long arg4 = (long) 0 ;
24074 wxTimeSpan *result;
24075 PyObject * obj0 = 0 ;
24076 PyObject * obj1 = 0 ;
24077 PyObject * obj2 = 0 ;
24078 PyObject * obj3 = 0 ;
24079 char *kwnames[] = {
24080 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24081 };
24082
24083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24084 if (obj0) {
24085 {
24086 arg1 = (long)(SWIG_As_long(obj0));
24087 if (SWIG_arg_fail(1)) SWIG_fail;
24088 }
24089 }
24090 if (obj1) {
24091 {
24092 arg2 = (long)(SWIG_As_long(obj1));
24093 if (SWIG_arg_fail(2)) SWIG_fail;
24094 }
24095 }
24096 if (obj2) {
24097 {
24098 arg3 = (long)(SWIG_As_long(obj2));
24099 if (SWIG_arg_fail(3)) SWIG_fail;
24100 }
24101 }
24102 if (obj3) {
24103 {
24104 arg4 = (long)(SWIG_As_long(obj3));
24105 if (SWIG_arg_fail(4)) SWIG_fail;
24106 }
24107 }
24108 {
24109 PyThreadState* __tstate = wxPyBeginAllowThreads();
24110 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24111
24112 wxPyEndAllowThreads(__tstate);
24113 if (PyErr_Occurred()) SWIG_fail;
24114 }
24115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24116 return resultobj;
24117 fail:
24118 return NULL;
24119 }
24120
24121
24122 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24123 PyObject *resultobj;
24124 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24125 PyObject * obj0 = 0 ;
24126 char *kwnames[] = {
24127 (char *) "self", NULL
24128 };
24129
24130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24132 if (SWIG_arg_fail(1)) SWIG_fail;
24133 {
24134 PyThreadState* __tstate = wxPyBeginAllowThreads();
24135 delete arg1;
24136
24137 wxPyEndAllowThreads(__tstate);
24138 if (PyErr_Occurred()) SWIG_fail;
24139 }
24140 Py_INCREF(Py_None); resultobj = Py_None;
24141 return resultobj;
24142 fail:
24143 return NULL;
24144 }
24145
24146
24147 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24148 PyObject *resultobj;
24149 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24150 wxTimeSpan *arg2 = 0 ;
24151 wxTimeSpan *result;
24152 PyObject * obj0 = 0 ;
24153 PyObject * obj1 = 0 ;
24154 char *kwnames[] = {
24155 (char *) "self",(char *) "diff", NULL
24156 };
24157
24158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24160 if (SWIG_arg_fail(1)) SWIG_fail;
24161 {
24162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24163 if (SWIG_arg_fail(2)) SWIG_fail;
24164 if (arg2 == NULL) {
24165 SWIG_null_ref("wxTimeSpan");
24166 }
24167 if (SWIG_arg_fail(2)) SWIG_fail;
24168 }
24169 {
24170 PyThreadState* __tstate = wxPyBeginAllowThreads();
24171 {
24172 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24173 result = (wxTimeSpan *) &_result_ref;
24174 }
24175
24176 wxPyEndAllowThreads(__tstate);
24177 if (PyErr_Occurred()) SWIG_fail;
24178 }
24179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24180 return resultobj;
24181 fail:
24182 return NULL;
24183 }
24184
24185
24186 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24187 PyObject *resultobj;
24188 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24189 wxTimeSpan *arg2 = 0 ;
24190 wxTimeSpan *result;
24191 PyObject * obj0 = 0 ;
24192 PyObject * obj1 = 0 ;
24193 char *kwnames[] = {
24194 (char *) "self",(char *) "diff", NULL
24195 };
24196
24197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24199 if (SWIG_arg_fail(1)) SWIG_fail;
24200 {
24201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24202 if (SWIG_arg_fail(2)) SWIG_fail;
24203 if (arg2 == NULL) {
24204 SWIG_null_ref("wxTimeSpan");
24205 }
24206 if (SWIG_arg_fail(2)) SWIG_fail;
24207 }
24208 {
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 {
24211 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24212 result = (wxTimeSpan *) &_result_ref;
24213 }
24214
24215 wxPyEndAllowThreads(__tstate);
24216 if (PyErr_Occurred()) SWIG_fail;
24217 }
24218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24226 PyObject *resultobj;
24227 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24228 int arg2 ;
24229 wxTimeSpan *result;
24230 PyObject * obj0 = 0 ;
24231 PyObject * obj1 = 0 ;
24232 char *kwnames[] = {
24233 (char *) "self",(char *) "n", NULL
24234 };
24235
24236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24238 if (SWIG_arg_fail(1)) SWIG_fail;
24239 {
24240 arg2 = (int)(SWIG_As_int(obj1));
24241 if (SWIG_arg_fail(2)) SWIG_fail;
24242 }
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 {
24246 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24247 result = (wxTimeSpan *) &_result_ref;
24248 }
24249
24250 wxPyEndAllowThreads(__tstate);
24251 if (PyErr_Occurred()) SWIG_fail;
24252 }
24253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24254 return resultobj;
24255 fail:
24256 return NULL;
24257 }
24258
24259
24260 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24261 PyObject *resultobj;
24262 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24263 wxTimeSpan *result;
24264 PyObject * obj0 = 0 ;
24265 char *kwnames[] = {
24266 (char *) "self", NULL
24267 };
24268
24269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24271 if (SWIG_arg_fail(1)) SWIG_fail;
24272 {
24273 PyThreadState* __tstate = wxPyBeginAllowThreads();
24274 {
24275 wxTimeSpan &_result_ref = (arg1)->Neg();
24276 result = (wxTimeSpan *) &_result_ref;
24277 }
24278
24279 wxPyEndAllowThreads(__tstate);
24280 if (PyErr_Occurred()) SWIG_fail;
24281 }
24282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24283 return resultobj;
24284 fail:
24285 return NULL;
24286 }
24287
24288
24289 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24290 PyObject *resultobj;
24291 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24292 wxTimeSpan result;
24293 PyObject * obj0 = 0 ;
24294 char *kwnames[] = {
24295 (char *) "self", NULL
24296 };
24297
24298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24300 if (SWIG_arg_fail(1)) SWIG_fail;
24301 {
24302 PyThreadState* __tstate = wxPyBeginAllowThreads();
24303 result = ((wxTimeSpan const *)arg1)->Abs();
24304
24305 wxPyEndAllowThreads(__tstate);
24306 if (PyErr_Occurred()) SWIG_fail;
24307 }
24308 {
24309 wxTimeSpan * resultptr;
24310 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24311 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24312 }
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24320 PyObject *resultobj;
24321 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24322 wxTimeSpan *arg2 = 0 ;
24323 wxTimeSpan *result;
24324 PyObject * obj0 = 0 ;
24325 PyObject * obj1 = 0 ;
24326 char *kwnames[] = {
24327 (char *) "self",(char *) "diff", NULL
24328 };
24329
24330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24332 if (SWIG_arg_fail(1)) SWIG_fail;
24333 {
24334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24335 if (SWIG_arg_fail(2)) SWIG_fail;
24336 if (arg2 == NULL) {
24337 SWIG_null_ref("wxTimeSpan");
24338 }
24339 if (SWIG_arg_fail(2)) SWIG_fail;
24340 }
24341 {
24342 PyThreadState* __tstate = wxPyBeginAllowThreads();
24343 {
24344 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24345 result = (wxTimeSpan *) &_result_ref;
24346 }
24347
24348 wxPyEndAllowThreads(__tstate);
24349 if (PyErr_Occurred()) SWIG_fail;
24350 }
24351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24359 PyObject *resultobj;
24360 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24361 wxTimeSpan *arg2 = 0 ;
24362 wxTimeSpan *result;
24363 PyObject * obj0 = 0 ;
24364 PyObject * obj1 = 0 ;
24365 char *kwnames[] = {
24366 (char *) "self",(char *) "diff", NULL
24367 };
24368
24369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24371 if (SWIG_arg_fail(1)) SWIG_fail;
24372 {
24373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24374 if (SWIG_arg_fail(2)) SWIG_fail;
24375 if (arg2 == NULL) {
24376 SWIG_null_ref("wxTimeSpan");
24377 }
24378 if (SWIG_arg_fail(2)) SWIG_fail;
24379 }
24380 {
24381 PyThreadState* __tstate = wxPyBeginAllowThreads();
24382 {
24383 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24384 result = (wxTimeSpan *) &_result_ref;
24385 }
24386
24387 wxPyEndAllowThreads(__tstate);
24388 if (PyErr_Occurred()) SWIG_fail;
24389 }
24390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24391 return resultobj;
24392 fail:
24393 return NULL;
24394 }
24395
24396
24397 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24398 PyObject *resultobj;
24399 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24400 int arg2 ;
24401 wxTimeSpan *result;
24402 PyObject * obj0 = 0 ;
24403 PyObject * obj1 = 0 ;
24404 char *kwnames[] = {
24405 (char *) "self",(char *) "n", NULL
24406 };
24407
24408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24410 if (SWIG_arg_fail(1)) SWIG_fail;
24411 {
24412 arg2 = (int)(SWIG_As_int(obj1));
24413 if (SWIG_arg_fail(2)) SWIG_fail;
24414 }
24415 {
24416 PyThreadState* __tstate = wxPyBeginAllowThreads();
24417 {
24418 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24419 result = (wxTimeSpan *) &_result_ref;
24420 }
24421
24422 wxPyEndAllowThreads(__tstate);
24423 if (PyErr_Occurred()) SWIG_fail;
24424 }
24425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24433 PyObject *resultobj;
24434 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24435 wxTimeSpan *result;
24436 PyObject * obj0 = 0 ;
24437 char *kwnames[] = {
24438 (char *) "self", NULL
24439 };
24440
24441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24443 if (SWIG_arg_fail(1)) SWIG_fail;
24444 {
24445 PyThreadState* __tstate = wxPyBeginAllowThreads();
24446 {
24447 wxTimeSpan &_result_ref = (arg1)->operator -();
24448 result = (wxTimeSpan *) &_result_ref;
24449 }
24450
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24462 PyObject *resultobj;
24463 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24464 wxTimeSpan *arg2 = 0 ;
24465 wxTimeSpan result;
24466 PyObject * obj0 = 0 ;
24467 PyObject * obj1 = 0 ;
24468 char *kwnames[] = {
24469 (char *) "self",(char *) "other", NULL
24470 };
24471
24472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24474 if (SWIG_arg_fail(1)) SWIG_fail;
24475 {
24476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24477 if (SWIG_arg_fail(2)) SWIG_fail;
24478 if (arg2 == NULL) {
24479 SWIG_null_ref("wxTimeSpan");
24480 }
24481 if (SWIG_arg_fail(2)) SWIG_fail;
24482 }
24483 {
24484 PyThreadState* __tstate = wxPyBeginAllowThreads();
24485 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24486
24487 wxPyEndAllowThreads(__tstate);
24488 if (PyErr_Occurred()) SWIG_fail;
24489 }
24490 {
24491 wxTimeSpan * resultptr;
24492 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24494 }
24495 return resultobj;
24496 fail:
24497 return NULL;
24498 }
24499
24500
24501 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24502 PyObject *resultobj;
24503 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24504 wxTimeSpan *arg2 = 0 ;
24505 wxTimeSpan result;
24506 PyObject * obj0 = 0 ;
24507 PyObject * obj1 = 0 ;
24508 char *kwnames[] = {
24509 (char *) "self",(char *) "other", NULL
24510 };
24511
24512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24514 if (SWIG_arg_fail(1)) SWIG_fail;
24515 {
24516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24517 if (SWIG_arg_fail(2)) SWIG_fail;
24518 if (arg2 == NULL) {
24519 SWIG_null_ref("wxTimeSpan");
24520 }
24521 if (SWIG_arg_fail(2)) SWIG_fail;
24522 }
24523 {
24524 PyThreadState* __tstate = wxPyBeginAllowThreads();
24525 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24526
24527 wxPyEndAllowThreads(__tstate);
24528 if (PyErr_Occurred()) SWIG_fail;
24529 }
24530 {
24531 wxTimeSpan * resultptr;
24532 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24534 }
24535 return resultobj;
24536 fail:
24537 return NULL;
24538 }
24539
24540
24541 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24542 PyObject *resultobj;
24543 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24544 int arg2 ;
24545 wxTimeSpan result;
24546 PyObject * obj0 = 0 ;
24547 PyObject * obj1 = 0 ;
24548 char *kwnames[] = {
24549 (char *) "self",(char *) "n", NULL
24550 };
24551
24552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24554 if (SWIG_arg_fail(1)) SWIG_fail;
24555 {
24556 arg2 = (int)(SWIG_As_int(obj1));
24557 if (SWIG_arg_fail(2)) SWIG_fail;
24558 }
24559 {
24560 PyThreadState* __tstate = wxPyBeginAllowThreads();
24561 result = wxTimeSpan___mul__(arg1,arg2);
24562
24563 wxPyEndAllowThreads(__tstate);
24564 if (PyErr_Occurred()) SWIG_fail;
24565 }
24566 {
24567 wxTimeSpan * resultptr;
24568 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24570 }
24571 return resultobj;
24572 fail:
24573 return NULL;
24574 }
24575
24576
24577 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24578 PyObject *resultobj;
24579 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24580 int arg2 ;
24581 wxTimeSpan result;
24582 PyObject * obj0 = 0 ;
24583 PyObject * obj1 = 0 ;
24584 char *kwnames[] = {
24585 (char *) "self",(char *) "n", NULL
24586 };
24587
24588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24590 if (SWIG_arg_fail(1)) SWIG_fail;
24591 {
24592 arg2 = (int)(SWIG_As_int(obj1));
24593 if (SWIG_arg_fail(2)) SWIG_fail;
24594 }
24595 {
24596 PyThreadState* __tstate = wxPyBeginAllowThreads();
24597 result = wxTimeSpan___rmul__(arg1,arg2);
24598
24599 wxPyEndAllowThreads(__tstate);
24600 if (PyErr_Occurred()) SWIG_fail;
24601 }
24602 {
24603 wxTimeSpan * resultptr;
24604 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24606 }
24607 return resultobj;
24608 fail:
24609 return NULL;
24610 }
24611
24612
24613 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24614 PyObject *resultobj;
24615 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24616 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24617 bool result;
24618 PyObject * obj0 = 0 ;
24619 PyObject * obj1 = 0 ;
24620 char *kwnames[] = {
24621 (char *) "self",(char *) "other", NULL
24622 };
24623
24624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24626 if (SWIG_arg_fail(1)) SWIG_fail;
24627 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24628 if (SWIG_arg_fail(2)) SWIG_fail;
24629 {
24630 PyThreadState* __tstate = wxPyBeginAllowThreads();
24631 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24632
24633 wxPyEndAllowThreads(__tstate);
24634 if (PyErr_Occurred()) SWIG_fail;
24635 }
24636 {
24637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24638 }
24639 return resultobj;
24640 fail:
24641 return NULL;
24642 }
24643
24644
24645 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24646 PyObject *resultobj;
24647 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24648 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24649 bool result;
24650 PyObject * obj0 = 0 ;
24651 PyObject * obj1 = 0 ;
24652 char *kwnames[] = {
24653 (char *) "self",(char *) "other", NULL
24654 };
24655
24656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24658 if (SWIG_arg_fail(1)) SWIG_fail;
24659 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24660 if (SWIG_arg_fail(2)) SWIG_fail;
24661 {
24662 PyThreadState* __tstate = wxPyBeginAllowThreads();
24663 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24664
24665 wxPyEndAllowThreads(__tstate);
24666 if (PyErr_Occurred()) SWIG_fail;
24667 }
24668 {
24669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24670 }
24671 return resultobj;
24672 fail:
24673 return NULL;
24674 }
24675
24676
24677 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24678 PyObject *resultobj;
24679 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24680 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24681 bool result;
24682 PyObject * obj0 = 0 ;
24683 PyObject * obj1 = 0 ;
24684 char *kwnames[] = {
24685 (char *) "self",(char *) "other", NULL
24686 };
24687
24688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24690 if (SWIG_arg_fail(1)) SWIG_fail;
24691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24692 if (SWIG_arg_fail(2)) SWIG_fail;
24693 {
24694 PyThreadState* __tstate = wxPyBeginAllowThreads();
24695 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24696
24697 wxPyEndAllowThreads(__tstate);
24698 if (PyErr_Occurred()) SWIG_fail;
24699 }
24700 {
24701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24702 }
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24710 PyObject *resultobj;
24711 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24712 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24713 bool result;
24714 PyObject * obj0 = 0 ;
24715 PyObject * obj1 = 0 ;
24716 char *kwnames[] = {
24717 (char *) "self",(char *) "other", NULL
24718 };
24719
24720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24722 if (SWIG_arg_fail(1)) SWIG_fail;
24723 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24724 if (SWIG_arg_fail(2)) SWIG_fail;
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24728
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 {
24733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24734 }
24735 return resultobj;
24736 fail:
24737 return NULL;
24738 }
24739
24740
24741 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24742 PyObject *resultobj;
24743 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24744 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24745 bool result;
24746 PyObject * obj0 = 0 ;
24747 PyObject * obj1 = 0 ;
24748 char *kwnames[] = {
24749 (char *) "self",(char *) "other", NULL
24750 };
24751
24752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24754 if (SWIG_arg_fail(1)) SWIG_fail;
24755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24756 if (SWIG_arg_fail(2)) SWIG_fail;
24757 {
24758 PyThreadState* __tstate = wxPyBeginAllowThreads();
24759 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24760
24761 wxPyEndAllowThreads(__tstate);
24762 if (PyErr_Occurred()) SWIG_fail;
24763 }
24764 {
24765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24766 }
24767 return resultobj;
24768 fail:
24769 return NULL;
24770 }
24771
24772
24773 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24774 PyObject *resultobj;
24775 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24776 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24777 bool result;
24778 PyObject * obj0 = 0 ;
24779 PyObject * obj1 = 0 ;
24780 char *kwnames[] = {
24781 (char *) "self",(char *) "other", NULL
24782 };
24783
24784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(1)) SWIG_fail;
24787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24788 if (SWIG_arg_fail(2)) SWIG_fail;
24789 {
24790 PyThreadState* __tstate = wxPyBeginAllowThreads();
24791 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24792
24793 wxPyEndAllowThreads(__tstate);
24794 if (PyErr_Occurred()) SWIG_fail;
24795 }
24796 {
24797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24798 }
24799 return resultobj;
24800 fail:
24801 return NULL;
24802 }
24803
24804
24805 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24806 PyObject *resultobj;
24807 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24808 bool result;
24809 PyObject * obj0 = 0 ;
24810 char *kwnames[] = {
24811 (char *) "self", NULL
24812 };
24813
24814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24816 if (SWIG_arg_fail(1)) SWIG_fail;
24817 {
24818 PyThreadState* __tstate = wxPyBeginAllowThreads();
24819 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24820
24821 wxPyEndAllowThreads(__tstate);
24822 if (PyErr_Occurred()) SWIG_fail;
24823 }
24824 {
24825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24826 }
24827 return resultobj;
24828 fail:
24829 return NULL;
24830 }
24831
24832
24833 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24834 PyObject *resultobj;
24835 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24836 bool result;
24837 PyObject * obj0 = 0 ;
24838 char *kwnames[] = {
24839 (char *) "self", NULL
24840 };
24841
24842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24844 if (SWIG_arg_fail(1)) SWIG_fail;
24845 {
24846 PyThreadState* __tstate = wxPyBeginAllowThreads();
24847 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24848
24849 wxPyEndAllowThreads(__tstate);
24850 if (PyErr_Occurred()) SWIG_fail;
24851 }
24852 {
24853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24854 }
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24862 PyObject *resultobj;
24863 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24864 bool result;
24865 PyObject * obj0 = 0 ;
24866 char *kwnames[] = {
24867 (char *) "self", NULL
24868 };
24869
24870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24872 if (SWIG_arg_fail(1)) SWIG_fail;
24873 {
24874 PyThreadState* __tstate = wxPyBeginAllowThreads();
24875 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24876
24877 wxPyEndAllowThreads(__tstate);
24878 if (PyErr_Occurred()) SWIG_fail;
24879 }
24880 {
24881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24882 }
24883 return resultobj;
24884 fail:
24885 return NULL;
24886 }
24887
24888
24889 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24890 PyObject *resultobj;
24891 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24892 wxTimeSpan *arg2 = 0 ;
24893 bool result;
24894 PyObject * obj0 = 0 ;
24895 PyObject * obj1 = 0 ;
24896 char *kwnames[] = {
24897 (char *) "self",(char *) "ts", NULL
24898 };
24899
24900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24902 if (SWIG_arg_fail(1)) SWIG_fail;
24903 {
24904 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24905 if (SWIG_arg_fail(2)) SWIG_fail;
24906 if (arg2 == NULL) {
24907 SWIG_null_ref("wxTimeSpan");
24908 }
24909 if (SWIG_arg_fail(2)) SWIG_fail;
24910 }
24911 {
24912 PyThreadState* __tstate = wxPyBeginAllowThreads();
24913 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24914
24915 wxPyEndAllowThreads(__tstate);
24916 if (PyErr_Occurred()) SWIG_fail;
24917 }
24918 {
24919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24920 }
24921 return resultobj;
24922 fail:
24923 return NULL;
24924 }
24925
24926
24927 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24928 PyObject *resultobj;
24929 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24930 wxTimeSpan *arg2 = 0 ;
24931 bool result;
24932 PyObject * obj0 = 0 ;
24933 PyObject * obj1 = 0 ;
24934 char *kwnames[] = {
24935 (char *) "self",(char *) "ts", NULL
24936 };
24937
24938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24940 if (SWIG_arg_fail(1)) SWIG_fail;
24941 {
24942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24943 if (SWIG_arg_fail(2)) SWIG_fail;
24944 if (arg2 == NULL) {
24945 SWIG_null_ref("wxTimeSpan");
24946 }
24947 if (SWIG_arg_fail(2)) SWIG_fail;
24948 }
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24952
24953 wxPyEndAllowThreads(__tstate);
24954 if (PyErr_Occurred()) SWIG_fail;
24955 }
24956 {
24957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24958 }
24959 return resultobj;
24960 fail:
24961 return NULL;
24962 }
24963
24964
24965 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24966 PyObject *resultobj;
24967 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24968 wxTimeSpan *arg2 = 0 ;
24969 bool result;
24970 PyObject * obj0 = 0 ;
24971 PyObject * obj1 = 0 ;
24972 char *kwnames[] = {
24973 (char *) "self",(char *) "t", NULL
24974 };
24975
24976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24978 if (SWIG_arg_fail(1)) SWIG_fail;
24979 {
24980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24981 if (SWIG_arg_fail(2)) SWIG_fail;
24982 if (arg2 == NULL) {
24983 SWIG_null_ref("wxTimeSpan");
24984 }
24985 if (SWIG_arg_fail(2)) SWIG_fail;
24986 }
24987 {
24988 PyThreadState* __tstate = wxPyBeginAllowThreads();
24989 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24990
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 {
24995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24996 }
24997 return resultobj;
24998 fail:
24999 return NULL;
25000 }
25001
25002
25003 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25004 PyObject *resultobj;
25005 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25006 int result;
25007 PyObject * obj0 = 0 ;
25008 char *kwnames[] = {
25009 (char *) "self", NULL
25010 };
25011
25012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25014 if (SWIG_arg_fail(1)) SWIG_fail;
25015 {
25016 PyThreadState* __tstate = wxPyBeginAllowThreads();
25017 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25018
25019 wxPyEndAllowThreads(__tstate);
25020 if (PyErr_Occurred()) SWIG_fail;
25021 }
25022 {
25023 resultobj = SWIG_From_int((int)(result));
25024 }
25025 return resultobj;
25026 fail:
25027 return NULL;
25028 }
25029
25030
25031 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25032 PyObject *resultobj;
25033 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25034 int result;
25035 PyObject * obj0 = 0 ;
25036 char *kwnames[] = {
25037 (char *) "self", NULL
25038 };
25039
25040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25042 if (SWIG_arg_fail(1)) SWIG_fail;
25043 {
25044 PyThreadState* __tstate = wxPyBeginAllowThreads();
25045 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25046
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 {
25051 resultobj = SWIG_From_int((int)(result));
25052 }
25053 return resultobj;
25054 fail:
25055 return NULL;
25056 }
25057
25058
25059 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25060 PyObject *resultobj;
25061 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25062 int result;
25063 PyObject * obj0 = 0 ;
25064 char *kwnames[] = {
25065 (char *) "self", NULL
25066 };
25067
25068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25070 if (SWIG_arg_fail(1)) SWIG_fail;
25071 {
25072 PyThreadState* __tstate = wxPyBeginAllowThreads();
25073 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25074
25075 wxPyEndAllowThreads(__tstate);
25076 if (PyErr_Occurred()) SWIG_fail;
25077 }
25078 {
25079 resultobj = SWIG_From_int((int)(result));
25080 }
25081 return resultobj;
25082 fail:
25083 return NULL;
25084 }
25085
25086
25087 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25088 PyObject *resultobj;
25089 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25090 int result;
25091 PyObject * obj0 = 0 ;
25092 char *kwnames[] = {
25093 (char *) "self", NULL
25094 };
25095
25096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25098 if (SWIG_arg_fail(1)) SWIG_fail;
25099 {
25100 PyThreadState* __tstate = wxPyBeginAllowThreads();
25101 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25102
25103 wxPyEndAllowThreads(__tstate);
25104 if (PyErr_Occurred()) SWIG_fail;
25105 }
25106 {
25107 resultobj = SWIG_From_int((int)(result));
25108 }
25109 return resultobj;
25110 fail:
25111 return NULL;
25112 }
25113
25114
25115 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25116 PyObject *resultobj;
25117 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25118 wxLongLong result;
25119 PyObject * obj0 = 0 ;
25120 char *kwnames[] = {
25121 (char *) "self", NULL
25122 };
25123
25124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25126 if (SWIG_arg_fail(1)) SWIG_fail;
25127 {
25128 PyThreadState* __tstate = wxPyBeginAllowThreads();
25129 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25130
25131 wxPyEndAllowThreads(__tstate);
25132 if (PyErr_Occurred()) SWIG_fail;
25133 }
25134 {
25135 PyObject *hi, *lo, *shifter, *shifted;
25136 hi = PyLong_FromLong( (&result)->GetHi() );
25137 lo = PyLong_FromLong( (&result)->GetLo() );
25138 shifter = PyLong_FromLong(32);
25139 shifted = PyNumber_Lshift(hi, shifter);
25140 resultobj = PyNumber_Or(shifted, lo);
25141 Py_DECREF(hi);
25142 Py_DECREF(lo);
25143 Py_DECREF(shifter);
25144 Py_DECREF(shifted);
25145 }
25146 return resultobj;
25147 fail:
25148 return NULL;
25149 }
25150
25151
25152 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25153 PyObject *resultobj;
25154 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25155 wxLongLong result;
25156 PyObject * obj0 = 0 ;
25157 char *kwnames[] = {
25158 (char *) "self", NULL
25159 };
25160
25161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25163 if (SWIG_arg_fail(1)) SWIG_fail;
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25167
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 {
25172 PyObject *hi, *lo, *shifter, *shifted;
25173 hi = PyLong_FromLong( (&result)->GetHi() );
25174 lo = PyLong_FromLong( (&result)->GetLo() );
25175 shifter = PyLong_FromLong(32);
25176 shifted = PyNumber_Lshift(hi, shifter);
25177 resultobj = PyNumber_Or(shifted, lo);
25178 Py_DECREF(hi);
25179 Py_DECREF(lo);
25180 Py_DECREF(shifter);
25181 Py_DECREF(shifted);
25182 }
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25190 PyObject *resultobj;
25191 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25192 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25193 wxString *arg2 = (wxString *) &arg2_defvalue ;
25194 wxString result;
25195 bool temp2 = false ;
25196 PyObject * obj0 = 0 ;
25197 PyObject * obj1 = 0 ;
25198 char *kwnames[] = {
25199 (char *) "self",(char *) "format", NULL
25200 };
25201
25202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25204 if (SWIG_arg_fail(1)) SWIG_fail;
25205 if (obj1) {
25206 {
25207 arg2 = wxString_in_helper(obj1);
25208 if (arg2 == NULL) SWIG_fail;
25209 temp2 = true;
25210 }
25211 }
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25215
25216 wxPyEndAllowThreads(__tstate);
25217 if (PyErr_Occurred()) SWIG_fail;
25218 }
25219 {
25220 #if wxUSE_UNICODE
25221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25222 #else
25223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25224 #endif
25225 }
25226 {
25227 if (temp2)
25228 delete arg2;
25229 }
25230 return resultobj;
25231 fail:
25232 {
25233 if (temp2)
25234 delete arg2;
25235 }
25236 return NULL;
25237 }
25238
25239
25240 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25241 PyObject *obj;
25242 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25243 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25244 Py_INCREF(obj);
25245 return Py_BuildValue((char *)"");
25246 }
25247 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25248 PyObject *resultobj;
25249 int arg1 = (int) 0 ;
25250 int arg2 = (int) 0 ;
25251 int arg3 = (int) 0 ;
25252 int arg4 = (int) 0 ;
25253 wxDateSpan *result;
25254 PyObject * obj0 = 0 ;
25255 PyObject * obj1 = 0 ;
25256 PyObject * obj2 = 0 ;
25257 PyObject * obj3 = 0 ;
25258 char *kwnames[] = {
25259 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25260 };
25261
25262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25263 if (obj0) {
25264 {
25265 arg1 = (int)(SWIG_As_int(obj0));
25266 if (SWIG_arg_fail(1)) SWIG_fail;
25267 }
25268 }
25269 if (obj1) {
25270 {
25271 arg2 = (int)(SWIG_As_int(obj1));
25272 if (SWIG_arg_fail(2)) SWIG_fail;
25273 }
25274 }
25275 if (obj2) {
25276 {
25277 arg3 = (int)(SWIG_As_int(obj2));
25278 if (SWIG_arg_fail(3)) SWIG_fail;
25279 }
25280 }
25281 if (obj3) {
25282 {
25283 arg4 = (int)(SWIG_As_int(obj3));
25284 if (SWIG_arg_fail(4)) SWIG_fail;
25285 }
25286 }
25287 {
25288 PyThreadState* __tstate = wxPyBeginAllowThreads();
25289 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25290
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25295 return resultobj;
25296 fail:
25297 return NULL;
25298 }
25299
25300
25301 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25302 PyObject *resultobj;
25303 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25304 PyObject * obj0 = 0 ;
25305 char *kwnames[] = {
25306 (char *) "self", NULL
25307 };
25308
25309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25311 if (SWIG_arg_fail(1)) SWIG_fail;
25312 {
25313 PyThreadState* __tstate = wxPyBeginAllowThreads();
25314 delete arg1;
25315
25316 wxPyEndAllowThreads(__tstate);
25317 if (PyErr_Occurred()) SWIG_fail;
25318 }
25319 Py_INCREF(Py_None); resultobj = Py_None;
25320 return resultobj;
25321 fail:
25322 return NULL;
25323 }
25324
25325
25326 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25327 PyObject *resultobj;
25328 int arg1 ;
25329 wxDateSpan result;
25330 PyObject * obj0 = 0 ;
25331 char *kwnames[] = {
25332 (char *) "days", NULL
25333 };
25334
25335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25336 {
25337 arg1 = (int)(SWIG_As_int(obj0));
25338 if (SWIG_arg_fail(1)) SWIG_fail;
25339 }
25340 {
25341 PyThreadState* __tstate = wxPyBeginAllowThreads();
25342 result = wxDateSpan::Days(arg1);
25343
25344 wxPyEndAllowThreads(__tstate);
25345 if (PyErr_Occurred()) SWIG_fail;
25346 }
25347 {
25348 wxDateSpan * resultptr;
25349 resultptr = new wxDateSpan((wxDateSpan &)(result));
25350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25351 }
25352 return resultobj;
25353 fail:
25354 return NULL;
25355 }
25356
25357
25358 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25359 PyObject *resultobj;
25360 wxDateSpan result;
25361 char *kwnames[] = {
25362 NULL
25363 };
25364
25365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25366 {
25367 PyThreadState* __tstate = wxPyBeginAllowThreads();
25368 result = wxDateSpan::Day();
25369
25370 wxPyEndAllowThreads(__tstate);
25371 if (PyErr_Occurred()) SWIG_fail;
25372 }
25373 {
25374 wxDateSpan * resultptr;
25375 resultptr = new wxDateSpan((wxDateSpan &)(result));
25376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25377 }
25378 return resultobj;
25379 fail:
25380 return NULL;
25381 }
25382
25383
25384 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25385 PyObject *resultobj;
25386 int arg1 ;
25387 wxDateSpan result;
25388 PyObject * obj0 = 0 ;
25389 char *kwnames[] = {
25390 (char *) "weeks", NULL
25391 };
25392
25393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25394 {
25395 arg1 = (int)(SWIG_As_int(obj0));
25396 if (SWIG_arg_fail(1)) SWIG_fail;
25397 }
25398 {
25399 PyThreadState* __tstate = wxPyBeginAllowThreads();
25400 result = wxDateSpan::Weeks(arg1);
25401
25402 wxPyEndAllowThreads(__tstate);
25403 if (PyErr_Occurred()) SWIG_fail;
25404 }
25405 {
25406 wxDateSpan * resultptr;
25407 resultptr = new wxDateSpan((wxDateSpan &)(result));
25408 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25409 }
25410 return resultobj;
25411 fail:
25412 return NULL;
25413 }
25414
25415
25416 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25417 PyObject *resultobj;
25418 wxDateSpan result;
25419 char *kwnames[] = {
25420 NULL
25421 };
25422
25423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25424 {
25425 PyThreadState* __tstate = wxPyBeginAllowThreads();
25426 result = wxDateSpan::Week();
25427
25428 wxPyEndAllowThreads(__tstate);
25429 if (PyErr_Occurred()) SWIG_fail;
25430 }
25431 {
25432 wxDateSpan * resultptr;
25433 resultptr = new wxDateSpan((wxDateSpan &)(result));
25434 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25435 }
25436 return resultobj;
25437 fail:
25438 return NULL;
25439 }
25440
25441
25442 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25443 PyObject *resultobj;
25444 int arg1 ;
25445 wxDateSpan result;
25446 PyObject * obj0 = 0 ;
25447 char *kwnames[] = {
25448 (char *) "mon", NULL
25449 };
25450
25451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25452 {
25453 arg1 = (int)(SWIG_As_int(obj0));
25454 if (SWIG_arg_fail(1)) SWIG_fail;
25455 }
25456 {
25457 PyThreadState* __tstate = wxPyBeginAllowThreads();
25458 result = wxDateSpan::Months(arg1);
25459
25460 wxPyEndAllowThreads(__tstate);
25461 if (PyErr_Occurred()) SWIG_fail;
25462 }
25463 {
25464 wxDateSpan * resultptr;
25465 resultptr = new wxDateSpan((wxDateSpan &)(result));
25466 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25467 }
25468 return resultobj;
25469 fail:
25470 return NULL;
25471 }
25472
25473
25474 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25475 PyObject *resultobj;
25476 wxDateSpan result;
25477 char *kwnames[] = {
25478 NULL
25479 };
25480
25481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25482 {
25483 PyThreadState* __tstate = wxPyBeginAllowThreads();
25484 result = wxDateSpan::Month();
25485
25486 wxPyEndAllowThreads(__tstate);
25487 if (PyErr_Occurred()) SWIG_fail;
25488 }
25489 {
25490 wxDateSpan * resultptr;
25491 resultptr = new wxDateSpan((wxDateSpan &)(result));
25492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25493 }
25494 return resultobj;
25495 fail:
25496 return NULL;
25497 }
25498
25499
25500 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25501 PyObject *resultobj;
25502 int arg1 ;
25503 wxDateSpan result;
25504 PyObject * obj0 = 0 ;
25505 char *kwnames[] = {
25506 (char *) "years", NULL
25507 };
25508
25509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25510 {
25511 arg1 = (int)(SWIG_As_int(obj0));
25512 if (SWIG_arg_fail(1)) SWIG_fail;
25513 }
25514 {
25515 PyThreadState* __tstate = wxPyBeginAllowThreads();
25516 result = wxDateSpan::Years(arg1);
25517
25518 wxPyEndAllowThreads(__tstate);
25519 if (PyErr_Occurred()) SWIG_fail;
25520 }
25521 {
25522 wxDateSpan * resultptr;
25523 resultptr = new wxDateSpan((wxDateSpan &)(result));
25524 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25525 }
25526 return resultobj;
25527 fail:
25528 return NULL;
25529 }
25530
25531
25532 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25533 PyObject *resultobj;
25534 wxDateSpan result;
25535 char *kwnames[] = {
25536 NULL
25537 };
25538
25539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 result = wxDateSpan::Year();
25543
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 {
25548 wxDateSpan * resultptr;
25549 resultptr = new wxDateSpan((wxDateSpan &)(result));
25550 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25551 }
25552 return resultobj;
25553 fail:
25554 return NULL;
25555 }
25556
25557
25558 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25559 PyObject *resultobj;
25560 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25561 int arg2 ;
25562 wxDateSpan *result;
25563 PyObject * obj0 = 0 ;
25564 PyObject * obj1 = 0 ;
25565 char *kwnames[] = {
25566 (char *) "self",(char *) "n", NULL
25567 };
25568
25569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25571 if (SWIG_arg_fail(1)) SWIG_fail;
25572 {
25573 arg2 = (int)(SWIG_As_int(obj1));
25574 if (SWIG_arg_fail(2)) SWIG_fail;
25575 }
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 {
25579 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25580 result = (wxDateSpan *) &_result_ref;
25581 }
25582
25583 wxPyEndAllowThreads(__tstate);
25584 if (PyErr_Occurred()) SWIG_fail;
25585 }
25586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25587 return resultobj;
25588 fail:
25589 return NULL;
25590 }
25591
25592
25593 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25594 PyObject *resultobj;
25595 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25596 int arg2 ;
25597 wxDateSpan *result;
25598 PyObject * obj0 = 0 ;
25599 PyObject * obj1 = 0 ;
25600 char *kwnames[] = {
25601 (char *) "self",(char *) "n", NULL
25602 };
25603
25604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25606 if (SWIG_arg_fail(1)) SWIG_fail;
25607 {
25608 arg2 = (int)(SWIG_As_int(obj1));
25609 if (SWIG_arg_fail(2)) SWIG_fail;
25610 }
25611 {
25612 PyThreadState* __tstate = wxPyBeginAllowThreads();
25613 {
25614 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25615 result = (wxDateSpan *) &_result_ref;
25616 }
25617
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25622 return resultobj;
25623 fail:
25624 return NULL;
25625 }
25626
25627
25628 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25629 PyObject *resultobj;
25630 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25631 int arg2 ;
25632 wxDateSpan *result;
25633 PyObject * obj0 = 0 ;
25634 PyObject * obj1 = 0 ;
25635 char *kwnames[] = {
25636 (char *) "self",(char *) "n", NULL
25637 };
25638
25639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25641 if (SWIG_arg_fail(1)) SWIG_fail;
25642 {
25643 arg2 = (int)(SWIG_As_int(obj1));
25644 if (SWIG_arg_fail(2)) SWIG_fail;
25645 }
25646 {
25647 PyThreadState* __tstate = wxPyBeginAllowThreads();
25648 {
25649 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25650 result = (wxDateSpan *) &_result_ref;
25651 }
25652
25653 wxPyEndAllowThreads(__tstate);
25654 if (PyErr_Occurred()) SWIG_fail;
25655 }
25656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25657 return resultobj;
25658 fail:
25659 return NULL;
25660 }
25661
25662
25663 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25664 PyObject *resultobj;
25665 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25666 int arg2 ;
25667 wxDateSpan *result;
25668 PyObject * obj0 = 0 ;
25669 PyObject * obj1 = 0 ;
25670 char *kwnames[] = {
25671 (char *) "self",(char *) "n", NULL
25672 };
25673
25674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25676 if (SWIG_arg_fail(1)) SWIG_fail;
25677 {
25678 arg2 = (int)(SWIG_As_int(obj1));
25679 if (SWIG_arg_fail(2)) SWIG_fail;
25680 }
25681 {
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 {
25684 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25685 result = (wxDateSpan *) &_result_ref;
25686 }
25687
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25699 PyObject *resultobj;
25700 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25701 int result;
25702 PyObject * obj0 = 0 ;
25703 char *kwnames[] = {
25704 (char *) "self", NULL
25705 };
25706
25707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25709 if (SWIG_arg_fail(1)) SWIG_fail;
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 result = (int)((wxDateSpan const *)arg1)->GetYears();
25713
25714 wxPyEndAllowThreads(__tstate);
25715 if (PyErr_Occurred()) SWIG_fail;
25716 }
25717 {
25718 resultobj = SWIG_From_int((int)(result));
25719 }
25720 return resultobj;
25721 fail:
25722 return NULL;
25723 }
25724
25725
25726 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25727 PyObject *resultobj;
25728 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25729 int result;
25730 PyObject * obj0 = 0 ;
25731 char *kwnames[] = {
25732 (char *) "self", NULL
25733 };
25734
25735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25737 if (SWIG_arg_fail(1)) SWIG_fail;
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25741
25742 wxPyEndAllowThreads(__tstate);
25743 if (PyErr_Occurred()) SWIG_fail;
25744 }
25745 {
25746 resultobj = SWIG_From_int((int)(result));
25747 }
25748 return resultobj;
25749 fail:
25750 return NULL;
25751 }
25752
25753
25754 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25755 PyObject *resultobj;
25756 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25757 int result;
25758 PyObject * obj0 = 0 ;
25759 char *kwnames[] = {
25760 (char *) "self", NULL
25761 };
25762
25763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25765 if (SWIG_arg_fail(1)) SWIG_fail;
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25769
25770 wxPyEndAllowThreads(__tstate);
25771 if (PyErr_Occurred()) SWIG_fail;
25772 }
25773 {
25774 resultobj = SWIG_From_int((int)(result));
25775 }
25776 return resultobj;
25777 fail:
25778 return NULL;
25779 }
25780
25781
25782 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25783 PyObject *resultobj;
25784 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25785 int result;
25786 PyObject * obj0 = 0 ;
25787 char *kwnames[] = {
25788 (char *) "self", NULL
25789 };
25790
25791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25793 if (SWIG_arg_fail(1)) SWIG_fail;
25794 {
25795 PyThreadState* __tstate = wxPyBeginAllowThreads();
25796 result = (int)((wxDateSpan const *)arg1)->GetDays();
25797
25798 wxPyEndAllowThreads(__tstate);
25799 if (PyErr_Occurred()) SWIG_fail;
25800 }
25801 {
25802 resultobj = SWIG_From_int((int)(result));
25803 }
25804 return resultobj;
25805 fail:
25806 return NULL;
25807 }
25808
25809
25810 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25811 PyObject *resultobj;
25812 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25813 int result;
25814 PyObject * obj0 = 0 ;
25815 char *kwnames[] = {
25816 (char *) "self", NULL
25817 };
25818
25819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25821 if (SWIG_arg_fail(1)) SWIG_fail;
25822 {
25823 PyThreadState* __tstate = wxPyBeginAllowThreads();
25824 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25825
25826 wxPyEndAllowThreads(__tstate);
25827 if (PyErr_Occurred()) SWIG_fail;
25828 }
25829 {
25830 resultobj = SWIG_From_int((int)(result));
25831 }
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25839 PyObject *resultobj;
25840 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25841 wxDateSpan *arg2 = 0 ;
25842 wxDateSpan *result;
25843 PyObject * obj0 = 0 ;
25844 PyObject * obj1 = 0 ;
25845 char *kwnames[] = {
25846 (char *) "self",(char *) "other", NULL
25847 };
25848
25849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25851 if (SWIG_arg_fail(1)) SWIG_fail;
25852 {
25853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25854 if (SWIG_arg_fail(2)) SWIG_fail;
25855 if (arg2 == NULL) {
25856 SWIG_null_ref("wxDateSpan");
25857 }
25858 if (SWIG_arg_fail(2)) SWIG_fail;
25859 }
25860 {
25861 PyThreadState* __tstate = wxPyBeginAllowThreads();
25862 {
25863 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25864 result = (wxDateSpan *) &_result_ref;
25865 }
25866
25867 wxPyEndAllowThreads(__tstate);
25868 if (PyErr_Occurred()) SWIG_fail;
25869 }
25870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj;
25879 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25880 wxDateSpan *arg2 = 0 ;
25881 wxDateSpan *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_Subtract",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 {
25892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25893 if (SWIG_arg_fail(2)) SWIG_fail;
25894 if (arg2 == NULL) {
25895 SWIG_null_ref("wxDateSpan");
25896 }
25897 if (SWIG_arg_fail(2)) SWIG_fail;
25898 }
25899 {
25900 PyThreadState* __tstate = wxPyBeginAllowThreads();
25901 {
25902 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25903 result = (wxDateSpan *) &_result_ref;
25904 }
25905
25906 wxPyEndAllowThreads(__tstate);
25907 if (PyErr_Occurred()) SWIG_fail;
25908 }
25909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25910 return resultobj;
25911 fail:
25912 return NULL;
25913 }
25914
25915
25916 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25917 PyObject *resultobj;
25918 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25919 wxDateSpan *result;
25920 PyObject * obj0 = 0 ;
25921 char *kwnames[] = {
25922 (char *) "self", NULL
25923 };
25924
25925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25927 if (SWIG_arg_fail(1)) SWIG_fail;
25928 {
25929 PyThreadState* __tstate = wxPyBeginAllowThreads();
25930 {
25931 wxDateSpan &_result_ref = (arg1)->Neg();
25932 result = (wxDateSpan *) &_result_ref;
25933 }
25934
25935 wxPyEndAllowThreads(__tstate);
25936 if (PyErr_Occurred()) SWIG_fail;
25937 }
25938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25939 return resultobj;
25940 fail:
25941 return NULL;
25942 }
25943
25944
25945 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25946 PyObject *resultobj;
25947 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25948 int arg2 ;
25949 wxDateSpan *result;
25950 PyObject * obj0 = 0 ;
25951 PyObject * obj1 = 0 ;
25952 char *kwnames[] = {
25953 (char *) "self",(char *) "factor", NULL
25954 };
25955
25956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25958 if (SWIG_arg_fail(1)) SWIG_fail;
25959 {
25960 arg2 = (int)(SWIG_As_int(obj1));
25961 if (SWIG_arg_fail(2)) SWIG_fail;
25962 }
25963 {
25964 PyThreadState* __tstate = wxPyBeginAllowThreads();
25965 {
25966 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25967 result = (wxDateSpan *) &_result_ref;
25968 }
25969
25970 wxPyEndAllowThreads(__tstate);
25971 if (PyErr_Occurred()) SWIG_fail;
25972 }
25973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25974 return resultobj;
25975 fail:
25976 return NULL;
25977 }
25978
25979
25980 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25981 PyObject *resultobj;
25982 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25983 wxDateSpan *arg2 = 0 ;
25984 wxDateSpan *result;
25985 PyObject * obj0 = 0 ;
25986 PyObject * obj1 = 0 ;
25987 char *kwnames[] = {
25988 (char *) "self",(char *) "other", NULL
25989 };
25990
25991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25993 if (SWIG_arg_fail(1)) SWIG_fail;
25994 {
25995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25996 if (SWIG_arg_fail(2)) SWIG_fail;
25997 if (arg2 == NULL) {
25998 SWIG_null_ref("wxDateSpan");
25999 }
26000 if (SWIG_arg_fail(2)) SWIG_fail;
26001 }
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 {
26005 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26006 result = (wxDateSpan *) &_result_ref;
26007 }
26008
26009 wxPyEndAllowThreads(__tstate);
26010 if (PyErr_Occurred()) SWIG_fail;
26011 }
26012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26013 return resultobj;
26014 fail:
26015 return NULL;
26016 }
26017
26018
26019 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26020 PyObject *resultobj;
26021 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26022 wxDateSpan *arg2 = 0 ;
26023 wxDateSpan *result;
26024 PyObject * obj0 = 0 ;
26025 PyObject * obj1 = 0 ;
26026 char *kwnames[] = {
26027 (char *) "self",(char *) "other", NULL
26028 };
26029
26030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26032 if (SWIG_arg_fail(1)) SWIG_fail;
26033 {
26034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26035 if (SWIG_arg_fail(2)) SWIG_fail;
26036 if (arg2 == NULL) {
26037 SWIG_null_ref("wxDateSpan");
26038 }
26039 if (SWIG_arg_fail(2)) SWIG_fail;
26040 }
26041 {
26042 PyThreadState* __tstate = wxPyBeginAllowThreads();
26043 {
26044 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26045 result = (wxDateSpan *) &_result_ref;
26046 }
26047
26048 wxPyEndAllowThreads(__tstate);
26049 if (PyErr_Occurred()) SWIG_fail;
26050 }
26051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26052 return resultobj;
26053 fail:
26054 return NULL;
26055 }
26056
26057
26058 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26059 PyObject *resultobj;
26060 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26061 wxDateSpan *result;
26062 PyObject * obj0 = 0 ;
26063 char *kwnames[] = {
26064 (char *) "self", NULL
26065 };
26066
26067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26069 if (SWIG_arg_fail(1)) SWIG_fail;
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 {
26073 wxDateSpan &_result_ref = (arg1)->operator -();
26074 result = (wxDateSpan *) &_result_ref;
26075 }
26076
26077 wxPyEndAllowThreads(__tstate);
26078 if (PyErr_Occurred()) SWIG_fail;
26079 }
26080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26081 return resultobj;
26082 fail:
26083 return NULL;
26084 }
26085
26086
26087 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26088 PyObject *resultobj;
26089 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26090 int arg2 ;
26091 wxDateSpan *result;
26092 PyObject * obj0 = 0 ;
26093 PyObject * obj1 = 0 ;
26094 char *kwnames[] = {
26095 (char *) "self",(char *) "factor", NULL
26096 };
26097
26098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26100 if (SWIG_arg_fail(1)) SWIG_fail;
26101 {
26102 arg2 = (int)(SWIG_As_int(obj1));
26103 if (SWIG_arg_fail(2)) SWIG_fail;
26104 }
26105 {
26106 PyThreadState* __tstate = wxPyBeginAllowThreads();
26107 {
26108 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26109 result = (wxDateSpan *) &_result_ref;
26110 }
26111
26112 wxPyEndAllowThreads(__tstate);
26113 if (PyErr_Occurred()) SWIG_fail;
26114 }
26115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26123 PyObject *resultobj;
26124 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26125 wxDateSpan *arg2 = 0 ;
26126 wxDateSpan result;
26127 PyObject * obj0 = 0 ;
26128 PyObject * obj1 = 0 ;
26129 char *kwnames[] = {
26130 (char *) "self",(char *) "other", NULL
26131 };
26132
26133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26135 if (SWIG_arg_fail(1)) SWIG_fail;
26136 {
26137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26138 if (SWIG_arg_fail(2)) SWIG_fail;
26139 if (arg2 == NULL) {
26140 SWIG_null_ref("wxDateSpan");
26141 }
26142 if (SWIG_arg_fail(2)) SWIG_fail;
26143 }
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26147
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 {
26152 wxDateSpan * resultptr;
26153 resultptr = new wxDateSpan((wxDateSpan &)(result));
26154 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26155 }
26156 return resultobj;
26157 fail:
26158 return NULL;
26159 }
26160
26161
26162 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26163 PyObject *resultobj;
26164 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26165 wxDateSpan *arg2 = 0 ;
26166 wxDateSpan result;
26167 PyObject * obj0 = 0 ;
26168 PyObject * obj1 = 0 ;
26169 char *kwnames[] = {
26170 (char *) "self",(char *) "other", NULL
26171 };
26172
26173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26175 if (SWIG_arg_fail(1)) SWIG_fail;
26176 {
26177 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26178 if (SWIG_arg_fail(2)) SWIG_fail;
26179 if (arg2 == NULL) {
26180 SWIG_null_ref("wxDateSpan");
26181 }
26182 if (SWIG_arg_fail(2)) SWIG_fail;
26183 }
26184 {
26185 PyThreadState* __tstate = wxPyBeginAllowThreads();
26186 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26187
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 {
26192 wxDateSpan * resultptr;
26193 resultptr = new wxDateSpan((wxDateSpan &)(result));
26194 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26195 }
26196 return resultobj;
26197 fail:
26198 return NULL;
26199 }
26200
26201
26202 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26203 PyObject *resultobj;
26204 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26205 int arg2 ;
26206 wxDateSpan result;
26207 PyObject * obj0 = 0 ;
26208 PyObject * obj1 = 0 ;
26209 char *kwnames[] = {
26210 (char *) "self",(char *) "n", NULL
26211 };
26212
26213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26215 if (SWIG_arg_fail(1)) SWIG_fail;
26216 {
26217 arg2 = (int)(SWIG_As_int(obj1));
26218 if (SWIG_arg_fail(2)) SWIG_fail;
26219 }
26220 {
26221 PyThreadState* __tstate = wxPyBeginAllowThreads();
26222 result = wxDateSpan___mul__(arg1,arg2);
26223
26224 wxPyEndAllowThreads(__tstate);
26225 if (PyErr_Occurred()) SWIG_fail;
26226 }
26227 {
26228 wxDateSpan * resultptr;
26229 resultptr = new wxDateSpan((wxDateSpan &)(result));
26230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26231 }
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26239 PyObject *resultobj;
26240 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26241 int arg2 ;
26242 wxDateSpan result;
26243 PyObject * obj0 = 0 ;
26244 PyObject * obj1 = 0 ;
26245 char *kwnames[] = {
26246 (char *) "self",(char *) "n", NULL
26247 };
26248
26249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26251 if (SWIG_arg_fail(1)) SWIG_fail;
26252 {
26253 arg2 = (int)(SWIG_As_int(obj1));
26254 if (SWIG_arg_fail(2)) SWIG_fail;
26255 }
26256 {
26257 PyThreadState* __tstate = wxPyBeginAllowThreads();
26258 result = wxDateSpan___rmul__(arg1,arg2);
26259
26260 wxPyEndAllowThreads(__tstate);
26261 if (PyErr_Occurred()) SWIG_fail;
26262 }
26263 {
26264 wxDateSpan * resultptr;
26265 resultptr = new wxDateSpan((wxDateSpan &)(result));
26266 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26267 }
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26275 PyObject *resultobj;
26276 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26277 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26278 bool result;
26279 PyObject * obj0 = 0 ;
26280 PyObject * obj1 = 0 ;
26281 char *kwnames[] = {
26282 (char *) "self",(char *) "other", NULL
26283 };
26284
26285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26287 if (SWIG_arg_fail(1)) SWIG_fail;
26288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26289 if (SWIG_arg_fail(2)) SWIG_fail;
26290 {
26291 PyThreadState* __tstate = wxPyBeginAllowThreads();
26292 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26293
26294 wxPyEndAllowThreads(__tstate);
26295 if (PyErr_Occurred()) SWIG_fail;
26296 }
26297 {
26298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26299 }
26300 return resultobj;
26301 fail:
26302 return NULL;
26303 }
26304
26305
26306 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26307 PyObject *resultobj;
26308 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26309 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26310 bool result;
26311 PyObject * obj0 = 0 ;
26312 PyObject * obj1 = 0 ;
26313 char *kwnames[] = {
26314 (char *) "self",(char *) "other", NULL
26315 };
26316
26317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26319 if (SWIG_arg_fail(1)) SWIG_fail;
26320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26321 if (SWIG_arg_fail(2)) SWIG_fail;
26322 {
26323 PyThreadState* __tstate = wxPyBeginAllowThreads();
26324 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26325
26326 wxPyEndAllowThreads(__tstate);
26327 if (PyErr_Occurred()) SWIG_fail;
26328 }
26329 {
26330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26331 }
26332 return resultobj;
26333 fail:
26334 return NULL;
26335 }
26336
26337
26338 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26339 PyObject *obj;
26340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26341 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26342 Py_INCREF(obj);
26343 return Py_BuildValue((char *)"");
26344 }
26345 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26346 PyObject *resultobj;
26347 long result;
26348 char *kwnames[] = {
26349 NULL
26350 };
26351
26352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 result = (long)wxGetLocalTime();
26356
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 {
26361 resultobj = SWIG_From_long((long)(result));
26362 }
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj;
26371 long result;
26372 char *kwnames[] = {
26373 NULL
26374 };
26375
26376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = (long)wxGetUTCTime();
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 {
26385 resultobj = SWIG_From_long((long)(result));
26386 }
26387 return resultobj;
26388 fail:
26389 return NULL;
26390 }
26391
26392
26393 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26394 PyObject *resultobj;
26395 long result;
26396 char *kwnames[] = {
26397 NULL
26398 };
26399
26400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26401 {
26402 PyThreadState* __tstate = wxPyBeginAllowThreads();
26403 result = (long)wxGetCurrentTime();
26404
26405 wxPyEndAllowThreads(__tstate);
26406 if (PyErr_Occurred()) SWIG_fail;
26407 }
26408 {
26409 resultobj = SWIG_From_long((long)(result));
26410 }
26411 return resultobj;
26412 fail:
26413 return NULL;
26414 }
26415
26416
26417 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26418 PyObject *resultobj;
26419 wxLongLong result;
26420 char *kwnames[] = {
26421 NULL
26422 };
26423
26424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 result = wxGetLocalTimeMillis();
26428
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 {
26433 PyObject *hi, *lo, *shifter, *shifted;
26434 hi = PyLong_FromLong( (&result)->GetHi() );
26435 lo = PyLong_FromLong( (&result)->GetLo() );
26436 shifter = PyLong_FromLong(32);
26437 shifted = PyNumber_Lshift(hi, shifter);
26438 resultobj = PyNumber_Or(shifted, lo);
26439 Py_DECREF(hi);
26440 Py_DECREF(lo);
26441 Py_DECREF(shifter);
26442 Py_DECREF(shifted);
26443 }
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 static int _wrap_DefaultDateTime_set(PyObject *) {
26451 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26452 return 1;
26453 }
26454
26455
26456 static PyObject *_wrap_DefaultDateTime_get(void) {
26457 PyObject *pyobj;
26458
26459 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26460 return pyobj;
26461 }
26462
26463
26464 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26465 PyObject *resultobj;
26466 wxDataFormatId arg1 ;
26467 wxDataFormat *result;
26468 PyObject * obj0 = 0 ;
26469 char *kwnames[] = {
26470 (char *) "type", NULL
26471 };
26472
26473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26474 {
26475 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26476 if (SWIG_arg_fail(1)) SWIG_fail;
26477 }
26478 {
26479 PyThreadState* __tstate = wxPyBeginAllowThreads();
26480 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26481
26482 wxPyEndAllowThreads(__tstate);
26483 if (PyErr_Occurred()) SWIG_fail;
26484 }
26485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26486 return resultobj;
26487 fail:
26488 return NULL;
26489 }
26490
26491
26492 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26493 PyObject *resultobj;
26494 wxString *arg1 = 0 ;
26495 wxDataFormat *result;
26496 bool temp1 = false ;
26497 PyObject * obj0 = 0 ;
26498 char *kwnames[] = {
26499 (char *) "format", NULL
26500 };
26501
26502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26503 {
26504 arg1 = wxString_in_helper(obj0);
26505 if (arg1 == NULL) SWIG_fail;
26506 temp1 = true;
26507 }
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26511
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26516 {
26517 if (temp1)
26518 delete arg1;
26519 }
26520 return resultobj;
26521 fail:
26522 {
26523 if (temp1)
26524 delete arg1;
26525 }
26526 return NULL;
26527 }
26528
26529
26530 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj;
26532 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26533 PyObject * obj0 = 0 ;
26534 char *kwnames[] = {
26535 (char *) "self", NULL
26536 };
26537
26538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26540 if (SWIG_arg_fail(1)) SWIG_fail;
26541 {
26542 PyThreadState* __tstate = wxPyBeginAllowThreads();
26543 delete arg1;
26544
26545 wxPyEndAllowThreads(__tstate);
26546 if (PyErr_Occurred()) SWIG_fail;
26547 }
26548 Py_INCREF(Py_None); resultobj = Py_None;
26549 return resultobj;
26550 fail:
26551 return NULL;
26552 }
26553
26554
26555 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26556 PyObject *resultobj;
26557 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26558 wxDataFormatId arg2 ;
26559 bool result;
26560 PyObject * obj0 = 0 ;
26561 PyObject * obj1 = 0 ;
26562
26563 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26565 if (SWIG_arg_fail(1)) SWIG_fail;
26566 {
26567 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26568 if (SWIG_arg_fail(2)) SWIG_fail;
26569 }
26570 {
26571 PyThreadState* __tstate = wxPyBeginAllowThreads();
26572 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26573
26574 wxPyEndAllowThreads(__tstate);
26575 if (PyErr_Occurred()) SWIG_fail;
26576 }
26577 {
26578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26579 }
26580 return resultobj;
26581 fail:
26582 return NULL;
26583 }
26584
26585
26586 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26587 PyObject *resultobj;
26588 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26589 wxDataFormatId arg2 ;
26590 bool result;
26591 PyObject * obj0 = 0 ;
26592 PyObject * obj1 = 0 ;
26593
26594 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26596 if (SWIG_arg_fail(1)) SWIG_fail;
26597 {
26598 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26599 if (SWIG_arg_fail(2)) SWIG_fail;
26600 }
26601 {
26602 PyThreadState* __tstate = wxPyBeginAllowThreads();
26603 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26604
26605 wxPyEndAllowThreads(__tstate);
26606 if (PyErr_Occurred()) SWIG_fail;
26607 }
26608 {
26609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26610 }
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26618 PyObject *resultobj;
26619 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26620 wxDataFormat *arg2 = 0 ;
26621 bool result;
26622 PyObject * obj0 = 0 ;
26623 PyObject * obj1 = 0 ;
26624
26625 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26627 if (SWIG_arg_fail(1)) SWIG_fail;
26628 {
26629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26630 if (SWIG_arg_fail(2)) SWIG_fail;
26631 if (arg2 == NULL) {
26632 SWIG_null_ref("wxDataFormat");
26633 }
26634 if (SWIG_arg_fail(2)) SWIG_fail;
26635 }
26636 {
26637 PyThreadState* __tstate = wxPyBeginAllowThreads();
26638 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26639
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 {
26644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26645 }
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26653 int argc;
26654 PyObject *argv[3];
26655 int ii;
26656
26657 argc = PyObject_Length(args);
26658 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26659 argv[ii] = PyTuple_GetItem(args,ii);
26660 }
26661 if (argc == 2) {
26662 int _v;
26663 {
26664 void *ptr;
26665 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26666 _v = 0;
26667 PyErr_Clear();
26668 } else {
26669 _v = 1;
26670 }
26671 }
26672 if (_v) {
26673 {
26674 void *ptr = 0;
26675 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26676 _v = 0;
26677 PyErr_Clear();
26678 } else {
26679 _v = (ptr != 0);
26680 }
26681 }
26682 if (_v) {
26683 return _wrap_DataFormat___eq____SWIG_1(self,args);
26684 }
26685 }
26686 }
26687 if (argc == 2) {
26688 int _v;
26689 {
26690 void *ptr;
26691 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26692 _v = 0;
26693 PyErr_Clear();
26694 } else {
26695 _v = 1;
26696 }
26697 }
26698 if (_v) {
26699 _v = SWIG_Check_int(argv[1]);
26700 if (_v) {
26701 return _wrap_DataFormat___eq____SWIG_0(self,args);
26702 }
26703 }
26704 }
26705
26706 Py_INCREF(Py_NotImplemented);
26707 return Py_NotImplemented;
26708 }
26709
26710
26711 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26712 PyObject *resultobj;
26713 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26714 wxDataFormat *arg2 = 0 ;
26715 bool result;
26716 PyObject * obj0 = 0 ;
26717 PyObject * obj1 = 0 ;
26718
26719 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26721 if (SWIG_arg_fail(1)) SWIG_fail;
26722 {
26723 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26724 if (SWIG_arg_fail(2)) SWIG_fail;
26725 if (arg2 == NULL) {
26726 SWIG_null_ref("wxDataFormat");
26727 }
26728 if (SWIG_arg_fail(2)) SWIG_fail;
26729 }
26730 {
26731 PyThreadState* __tstate = wxPyBeginAllowThreads();
26732 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26733
26734 wxPyEndAllowThreads(__tstate);
26735 if (PyErr_Occurred()) SWIG_fail;
26736 }
26737 {
26738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26739 }
26740 return resultobj;
26741 fail:
26742 return NULL;
26743 }
26744
26745
26746 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26747 int argc;
26748 PyObject *argv[3];
26749 int ii;
26750
26751 argc = PyObject_Length(args);
26752 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26753 argv[ii] = PyTuple_GetItem(args,ii);
26754 }
26755 if (argc == 2) {
26756 int _v;
26757 {
26758 void *ptr;
26759 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26760 _v = 0;
26761 PyErr_Clear();
26762 } else {
26763 _v = 1;
26764 }
26765 }
26766 if (_v) {
26767 {
26768 void *ptr = 0;
26769 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26770 _v = 0;
26771 PyErr_Clear();
26772 } else {
26773 _v = (ptr != 0);
26774 }
26775 }
26776 if (_v) {
26777 return _wrap_DataFormat___ne____SWIG_1(self,args);
26778 }
26779 }
26780 }
26781 if (argc == 2) {
26782 int _v;
26783 {
26784 void *ptr;
26785 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26786 _v = 0;
26787 PyErr_Clear();
26788 } else {
26789 _v = 1;
26790 }
26791 }
26792 if (_v) {
26793 _v = SWIG_Check_int(argv[1]);
26794 if (_v) {
26795 return _wrap_DataFormat___ne____SWIG_0(self,args);
26796 }
26797 }
26798 }
26799
26800 Py_INCREF(Py_NotImplemented);
26801 return Py_NotImplemented;
26802 }
26803
26804
26805 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26806 PyObject *resultobj;
26807 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26808 wxDataFormatId arg2 ;
26809 PyObject * obj0 = 0 ;
26810 PyObject * obj1 = 0 ;
26811 char *kwnames[] = {
26812 (char *) "self",(char *) "format", NULL
26813 };
26814
26815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26817 if (SWIG_arg_fail(1)) SWIG_fail;
26818 {
26819 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26820 if (SWIG_arg_fail(2)) SWIG_fail;
26821 }
26822 {
26823 PyThreadState* __tstate = wxPyBeginAllowThreads();
26824 (arg1)->SetType((wxDataFormatId )arg2);
26825
26826 wxPyEndAllowThreads(__tstate);
26827 if (PyErr_Occurred()) SWIG_fail;
26828 }
26829 Py_INCREF(Py_None); resultobj = Py_None;
26830 return resultobj;
26831 fail:
26832 return NULL;
26833 }
26834
26835
26836 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26837 PyObject *resultobj;
26838 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26839 wxDataFormatId result;
26840 PyObject * obj0 = 0 ;
26841 char *kwnames[] = {
26842 (char *) "self", NULL
26843 };
26844
26845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26847 if (SWIG_arg_fail(1)) SWIG_fail;
26848 {
26849 PyThreadState* __tstate = wxPyBeginAllowThreads();
26850 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26851
26852 wxPyEndAllowThreads(__tstate);
26853 if (PyErr_Occurred()) SWIG_fail;
26854 }
26855 resultobj = SWIG_From_int((result));
26856 return resultobj;
26857 fail:
26858 return NULL;
26859 }
26860
26861
26862 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26863 PyObject *resultobj;
26864 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26865 wxString result;
26866 PyObject * obj0 = 0 ;
26867 char *kwnames[] = {
26868 (char *) "self", NULL
26869 };
26870
26871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26873 if (SWIG_arg_fail(1)) SWIG_fail;
26874 {
26875 PyThreadState* __tstate = wxPyBeginAllowThreads();
26876 result = ((wxDataFormat const *)arg1)->GetId();
26877
26878 wxPyEndAllowThreads(__tstate);
26879 if (PyErr_Occurred()) SWIG_fail;
26880 }
26881 {
26882 #if wxUSE_UNICODE
26883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26884 #else
26885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26886 #endif
26887 }
26888 return resultobj;
26889 fail:
26890 return NULL;
26891 }
26892
26893
26894 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26895 PyObject *resultobj;
26896 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26897 wxString *arg2 = 0 ;
26898 bool temp2 = false ;
26899 PyObject * obj0 = 0 ;
26900 PyObject * obj1 = 0 ;
26901 char *kwnames[] = {
26902 (char *) "self",(char *) "format", NULL
26903 };
26904
26905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26907 if (SWIG_arg_fail(1)) SWIG_fail;
26908 {
26909 arg2 = wxString_in_helper(obj1);
26910 if (arg2 == NULL) SWIG_fail;
26911 temp2 = true;
26912 }
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 (arg1)->SetId((wxString const &)*arg2);
26916
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 Py_INCREF(Py_None); resultobj = Py_None;
26921 {
26922 if (temp2)
26923 delete arg2;
26924 }
26925 return resultobj;
26926 fail:
26927 {
26928 if (temp2)
26929 delete arg2;
26930 }
26931 return NULL;
26932 }
26933
26934
26935 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26936 PyObject *obj;
26937 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26938 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26939 Py_INCREF(obj);
26940 return Py_BuildValue((char *)"");
26941 }
26942 static int _wrap_FormatInvalid_set(PyObject *) {
26943 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26944 return 1;
26945 }
26946
26947
26948 static PyObject *_wrap_FormatInvalid_get(void) {
26949 PyObject *pyobj;
26950
26951 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26952 return pyobj;
26953 }
26954
26955
26956 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26957 PyObject *resultobj;
26958 wxDataObject *arg1 = (wxDataObject *) 0 ;
26959 PyObject * obj0 = 0 ;
26960 char *kwnames[] = {
26961 (char *) "self", NULL
26962 };
26963
26964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26966 if (SWIG_arg_fail(1)) SWIG_fail;
26967 {
26968 PyThreadState* __tstate = wxPyBeginAllowThreads();
26969 delete arg1;
26970
26971 wxPyEndAllowThreads(__tstate);
26972 if (PyErr_Occurred()) SWIG_fail;
26973 }
26974 Py_INCREF(Py_None); resultobj = Py_None;
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26982 PyObject *resultobj;
26983 wxDataObject *arg1 = (wxDataObject *) 0 ;
26984 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26985 SwigValueWrapper<wxDataFormat > result;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char *kwnames[] = {
26989 (char *) "self",(char *) "dir", NULL
26990 };
26991
26992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26994 if (SWIG_arg_fail(1)) SWIG_fail;
26995 if (obj1) {
26996 {
26997 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26998 if (SWIG_arg_fail(2)) SWIG_fail;
26999 }
27000 }
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27004
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 {
27009 wxDataFormat * resultptr;
27010 resultptr = new wxDataFormat((wxDataFormat &)(result));
27011 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27012 }
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27020 PyObject *resultobj;
27021 wxDataObject *arg1 = (wxDataObject *) 0 ;
27022 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27023 size_t result;
27024 PyObject * obj0 = 0 ;
27025 PyObject * obj1 = 0 ;
27026 char *kwnames[] = {
27027 (char *) "self",(char *) "dir", NULL
27028 };
27029
27030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27032 if (SWIG_arg_fail(1)) SWIG_fail;
27033 if (obj1) {
27034 {
27035 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27036 if (SWIG_arg_fail(2)) SWIG_fail;
27037 }
27038 }
27039 {
27040 PyThreadState* __tstate = wxPyBeginAllowThreads();
27041 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27042
27043 wxPyEndAllowThreads(__tstate);
27044 if (PyErr_Occurred()) SWIG_fail;
27045 }
27046 {
27047 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27048 }
27049 return resultobj;
27050 fail:
27051 return NULL;
27052 }
27053
27054
27055 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27056 PyObject *resultobj;
27057 wxDataObject *arg1 = (wxDataObject *) 0 ;
27058 wxDataFormat *arg2 = 0 ;
27059 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27060 bool result;
27061 PyObject * obj0 = 0 ;
27062 PyObject * obj1 = 0 ;
27063 PyObject * obj2 = 0 ;
27064 char *kwnames[] = {
27065 (char *) "self",(char *) "format",(char *) "dir", NULL
27066 };
27067
27068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27070 if (SWIG_arg_fail(1)) SWIG_fail;
27071 {
27072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27073 if (SWIG_arg_fail(2)) SWIG_fail;
27074 if (arg2 == NULL) {
27075 SWIG_null_ref("wxDataFormat");
27076 }
27077 if (SWIG_arg_fail(2)) SWIG_fail;
27078 }
27079 if (obj2) {
27080 {
27081 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27082 if (SWIG_arg_fail(3)) SWIG_fail;
27083 }
27084 }
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27088
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 {
27093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27094 }
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27102 PyObject *resultobj;
27103 wxDataObject *arg1 = (wxDataObject *) 0 ;
27104 wxDataFormat *arg2 = 0 ;
27105 size_t result;
27106 PyObject * obj0 = 0 ;
27107 PyObject * obj1 = 0 ;
27108 char *kwnames[] = {
27109 (char *) "self",(char *) "format", NULL
27110 };
27111
27112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27114 if (SWIG_arg_fail(1)) SWIG_fail;
27115 {
27116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27117 if (SWIG_arg_fail(2)) SWIG_fail;
27118 if (arg2 == NULL) {
27119 SWIG_null_ref("wxDataFormat");
27120 }
27121 if (SWIG_arg_fail(2)) SWIG_fail;
27122 }
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27126
27127 wxPyEndAllowThreads(__tstate);
27128 if (PyErr_Occurred()) SWIG_fail;
27129 }
27130 {
27131 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27132 }
27133 return resultobj;
27134 fail:
27135 return NULL;
27136 }
27137
27138
27139 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27140 PyObject *resultobj;
27141 wxDataObject *arg1 = (wxDataObject *) 0 ;
27142 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27143 PyObject *result;
27144 PyObject * obj0 = 0 ;
27145 PyObject * obj1 = 0 ;
27146 char *kwnames[] = {
27147 (char *) "self",(char *) "dir", NULL
27148 };
27149
27150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27152 if (SWIG_arg_fail(1)) SWIG_fail;
27153 if (obj1) {
27154 {
27155 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27156 if (SWIG_arg_fail(2)) SWIG_fail;
27157 }
27158 }
27159 {
27160 PyThreadState* __tstate = wxPyBeginAllowThreads();
27161 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27162
27163 wxPyEndAllowThreads(__tstate);
27164 if (PyErr_Occurred()) SWIG_fail;
27165 }
27166 resultobj = result;
27167 return resultobj;
27168 fail:
27169 return NULL;
27170 }
27171
27172
27173 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27174 PyObject *resultobj;
27175 wxDataObject *arg1 = (wxDataObject *) 0 ;
27176 wxDataFormat *arg2 = 0 ;
27177 PyObject *result;
27178 PyObject * obj0 = 0 ;
27179 PyObject * obj1 = 0 ;
27180 char *kwnames[] = {
27181 (char *) "self",(char *) "format", NULL
27182 };
27183
27184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27186 if (SWIG_arg_fail(1)) SWIG_fail;
27187 {
27188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27189 if (SWIG_arg_fail(2)) SWIG_fail;
27190 if (arg2 == NULL) {
27191 SWIG_null_ref("wxDataFormat");
27192 }
27193 if (SWIG_arg_fail(2)) SWIG_fail;
27194 }
27195 {
27196 PyThreadState* __tstate = wxPyBeginAllowThreads();
27197 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27198
27199 wxPyEndAllowThreads(__tstate);
27200 if (PyErr_Occurred()) SWIG_fail;
27201 }
27202 resultobj = result;
27203 return resultobj;
27204 fail:
27205 return NULL;
27206 }
27207
27208
27209 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27210 PyObject *resultobj;
27211 wxDataObject *arg1 = (wxDataObject *) 0 ;
27212 wxDataFormat *arg2 = 0 ;
27213 PyObject *arg3 = (PyObject *) 0 ;
27214 bool result;
27215 PyObject * obj0 = 0 ;
27216 PyObject * obj1 = 0 ;
27217 PyObject * obj2 = 0 ;
27218 char *kwnames[] = {
27219 (char *) "self",(char *) "format",(char *) "data", NULL
27220 };
27221
27222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27224 if (SWIG_arg_fail(1)) SWIG_fail;
27225 {
27226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27227 if (SWIG_arg_fail(2)) SWIG_fail;
27228 if (arg2 == NULL) {
27229 SWIG_null_ref("wxDataFormat");
27230 }
27231 if (SWIG_arg_fail(2)) SWIG_fail;
27232 }
27233 arg3 = obj2;
27234 {
27235 PyThreadState* __tstate = wxPyBeginAllowThreads();
27236 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27237
27238 wxPyEndAllowThreads(__tstate);
27239 if (PyErr_Occurred()) SWIG_fail;
27240 }
27241 {
27242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27243 }
27244 return resultobj;
27245 fail:
27246 return NULL;
27247 }
27248
27249
27250 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27251 PyObject *obj;
27252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27253 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27254 Py_INCREF(obj);
27255 return Py_BuildValue((char *)"");
27256 }
27257 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27258 PyObject *resultobj;
27259 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27260 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27261 wxDataObjectSimple *result;
27262 PyObject * obj0 = 0 ;
27263 char *kwnames[] = {
27264 (char *) "format", NULL
27265 };
27266
27267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27268 if (obj0) {
27269 {
27270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27271 if (SWIG_arg_fail(1)) SWIG_fail;
27272 if (arg1 == NULL) {
27273 SWIG_null_ref("wxDataFormat");
27274 }
27275 if (SWIG_arg_fail(1)) SWIG_fail;
27276 }
27277 }
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27281
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27293 PyObject *resultobj;
27294 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27295 wxDataFormat *result;
27296 PyObject * obj0 = 0 ;
27297 char *kwnames[] = {
27298 (char *) "self", NULL
27299 };
27300
27301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27303 if (SWIG_arg_fail(1)) SWIG_fail;
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 {
27307 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27308 result = (wxDataFormat *) &_result_ref;
27309 }
27310
27311 wxPyEndAllowThreads(__tstate);
27312 if (PyErr_Occurred()) SWIG_fail;
27313 }
27314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27315 return resultobj;
27316 fail:
27317 return NULL;
27318 }
27319
27320
27321 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27322 PyObject *resultobj;
27323 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27324 wxDataFormat *arg2 = 0 ;
27325 PyObject * obj0 = 0 ;
27326 PyObject * obj1 = 0 ;
27327 char *kwnames[] = {
27328 (char *) "self",(char *) "format", NULL
27329 };
27330
27331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27333 if (SWIG_arg_fail(1)) SWIG_fail;
27334 {
27335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27336 if (SWIG_arg_fail(2)) SWIG_fail;
27337 if (arg2 == NULL) {
27338 SWIG_null_ref("wxDataFormat");
27339 }
27340 if (SWIG_arg_fail(2)) SWIG_fail;
27341 }
27342 {
27343 PyThreadState* __tstate = wxPyBeginAllowThreads();
27344 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27345
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 Py_INCREF(Py_None); resultobj = Py_None;
27350 return resultobj;
27351 fail:
27352 return NULL;
27353 }
27354
27355
27356 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27357 PyObject *resultobj;
27358 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27359 size_t result;
27360 PyObject * obj0 = 0 ;
27361 char *kwnames[] = {
27362 (char *) "self", NULL
27363 };
27364
27365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27367 if (SWIG_arg_fail(1)) SWIG_fail;
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27371
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 {
27376 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27377 }
27378 return resultobj;
27379 fail:
27380 return NULL;
27381 }
27382
27383
27384 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27385 PyObject *resultobj;
27386 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27387 PyObject *result;
27388 PyObject * obj0 = 0 ;
27389 char *kwnames[] = {
27390 (char *) "self", NULL
27391 };
27392
27393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27395 if (SWIG_arg_fail(1)) SWIG_fail;
27396 {
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27399
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 resultobj = result;
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27411 PyObject *resultobj;
27412 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27413 PyObject *arg2 = (PyObject *) 0 ;
27414 bool result;
27415 PyObject * obj0 = 0 ;
27416 PyObject * obj1 = 0 ;
27417 char *kwnames[] = {
27418 (char *) "self",(char *) "data", NULL
27419 };
27420
27421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27423 if (SWIG_arg_fail(1)) SWIG_fail;
27424 arg2 = obj1;
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27428
27429 wxPyEndAllowThreads(__tstate);
27430 if (PyErr_Occurred()) SWIG_fail;
27431 }
27432 {
27433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27434 }
27435 return resultobj;
27436 fail:
27437 return NULL;
27438 }
27439
27440
27441 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27442 PyObject *obj;
27443 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27444 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27445 Py_INCREF(obj);
27446 return Py_BuildValue((char *)"");
27447 }
27448 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27449 PyObject *resultobj;
27450 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27451 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27452 wxPyDataObjectSimple *result;
27453 PyObject * obj0 = 0 ;
27454 char *kwnames[] = {
27455 (char *) "format", NULL
27456 };
27457
27458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27459 if (obj0) {
27460 {
27461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27462 if (SWIG_arg_fail(1)) SWIG_fail;
27463 if (arg1 == NULL) {
27464 SWIG_null_ref("wxDataFormat");
27465 }
27466 if (SWIG_arg_fail(1)) SWIG_fail;
27467 }
27468 }
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27472
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27477 return resultobj;
27478 fail:
27479 return NULL;
27480 }
27481
27482
27483 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27484 PyObject *resultobj;
27485 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27486 PyObject *arg2 = (PyObject *) 0 ;
27487 PyObject *arg3 = (PyObject *) 0 ;
27488 PyObject * obj0 = 0 ;
27489 PyObject * obj1 = 0 ;
27490 PyObject * obj2 = 0 ;
27491 char *kwnames[] = {
27492 (char *) "self",(char *) "self",(char *) "_class", NULL
27493 };
27494
27495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27497 if (SWIG_arg_fail(1)) SWIG_fail;
27498 arg2 = obj1;
27499 arg3 = obj2;
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 (arg1)->_setCallbackInfo(arg2,arg3);
27503
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 Py_INCREF(Py_None); resultobj = Py_None;
27508 return resultobj;
27509 fail:
27510 return NULL;
27511 }
27512
27513
27514 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27515 PyObject *obj;
27516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27517 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27518 Py_INCREF(obj);
27519 return Py_BuildValue((char *)"");
27520 }
27521 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27522 PyObject *resultobj;
27523 wxDataObjectComposite *result;
27524 char *kwnames[] = {
27525 NULL
27526 };
27527
27528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27532
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27537 return resultobj;
27538 fail:
27539 return NULL;
27540 }
27541
27542
27543 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27544 PyObject *resultobj;
27545 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27546 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27547 bool arg3 = (bool) false ;
27548 PyObject * obj0 = 0 ;
27549 PyObject * obj1 = 0 ;
27550 PyObject * obj2 = 0 ;
27551 char *kwnames[] = {
27552 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27553 };
27554
27555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27557 if (SWIG_arg_fail(1)) SWIG_fail;
27558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27559 if (SWIG_arg_fail(2)) SWIG_fail;
27560 if (obj2) {
27561 {
27562 arg3 = (bool)(SWIG_As_bool(obj2));
27563 if (SWIG_arg_fail(3)) SWIG_fail;
27564 }
27565 }
27566 {
27567 PyThreadState* __tstate = wxPyBeginAllowThreads();
27568 (arg1)->Add(arg2,arg3);
27569
27570 wxPyEndAllowThreads(__tstate);
27571 if (PyErr_Occurred()) SWIG_fail;
27572 }
27573 Py_INCREF(Py_None); resultobj = Py_None;
27574 return resultobj;
27575 fail:
27576 return NULL;
27577 }
27578
27579
27580 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27581 PyObject *obj;
27582 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27583 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27584 Py_INCREF(obj);
27585 return Py_BuildValue((char *)"");
27586 }
27587 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27588 PyObject *resultobj;
27589 wxString const &arg1_defvalue = wxPyEmptyString ;
27590 wxString *arg1 = (wxString *) &arg1_defvalue ;
27591 wxTextDataObject *result;
27592 bool temp1 = false ;
27593 PyObject * obj0 = 0 ;
27594 char *kwnames[] = {
27595 (char *) "text", NULL
27596 };
27597
27598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27599 if (obj0) {
27600 {
27601 arg1 = wxString_in_helper(obj0);
27602 if (arg1 == NULL) SWIG_fail;
27603 temp1 = true;
27604 }
27605 }
27606 {
27607 PyThreadState* __tstate = wxPyBeginAllowThreads();
27608 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27609
27610 wxPyEndAllowThreads(__tstate);
27611 if (PyErr_Occurred()) SWIG_fail;
27612 }
27613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27614 {
27615 if (temp1)
27616 delete arg1;
27617 }
27618 return resultobj;
27619 fail:
27620 {
27621 if (temp1)
27622 delete arg1;
27623 }
27624 return NULL;
27625 }
27626
27627
27628 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27629 PyObject *resultobj;
27630 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27631 size_t result;
27632 PyObject * obj0 = 0 ;
27633 char *kwnames[] = {
27634 (char *) "self", NULL
27635 };
27636
27637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27639 if (SWIG_arg_fail(1)) SWIG_fail;
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 result = (size_t)(arg1)->GetTextLength();
27643
27644 wxPyEndAllowThreads(__tstate);
27645 if (PyErr_Occurred()) SWIG_fail;
27646 }
27647 {
27648 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27649 }
27650 return resultobj;
27651 fail:
27652 return NULL;
27653 }
27654
27655
27656 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27657 PyObject *resultobj;
27658 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27659 wxString result;
27660 PyObject * obj0 = 0 ;
27661 char *kwnames[] = {
27662 (char *) "self", NULL
27663 };
27664
27665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27667 if (SWIG_arg_fail(1)) SWIG_fail;
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 result = (arg1)->GetText();
27671
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 {
27676 #if wxUSE_UNICODE
27677 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27678 #else
27679 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27680 #endif
27681 }
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27689 PyObject *resultobj;
27690 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27691 wxString *arg2 = 0 ;
27692 bool temp2 = false ;
27693 PyObject * obj0 = 0 ;
27694 PyObject * obj1 = 0 ;
27695 char *kwnames[] = {
27696 (char *) "self",(char *) "text", NULL
27697 };
27698
27699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27701 if (SWIG_arg_fail(1)) SWIG_fail;
27702 {
27703 arg2 = wxString_in_helper(obj1);
27704 if (arg2 == NULL) SWIG_fail;
27705 temp2 = true;
27706 }
27707 {
27708 PyThreadState* __tstate = wxPyBeginAllowThreads();
27709 (arg1)->SetText((wxString const &)*arg2);
27710
27711 wxPyEndAllowThreads(__tstate);
27712 if (PyErr_Occurred()) SWIG_fail;
27713 }
27714 Py_INCREF(Py_None); resultobj = Py_None;
27715 {
27716 if (temp2)
27717 delete arg2;
27718 }
27719 return resultobj;
27720 fail:
27721 {
27722 if (temp2)
27723 delete arg2;
27724 }
27725 return NULL;
27726 }
27727
27728
27729 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27730 PyObject *obj;
27731 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27732 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27733 Py_INCREF(obj);
27734 return Py_BuildValue((char *)"");
27735 }
27736 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27737 PyObject *resultobj;
27738 wxString const &arg1_defvalue = wxPyEmptyString ;
27739 wxString *arg1 = (wxString *) &arg1_defvalue ;
27740 wxPyTextDataObject *result;
27741 bool temp1 = false ;
27742 PyObject * obj0 = 0 ;
27743 char *kwnames[] = {
27744 (char *) "text", NULL
27745 };
27746
27747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27748 if (obj0) {
27749 {
27750 arg1 = wxString_in_helper(obj0);
27751 if (arg1 == NULL) SWIG_fail;
27752 temp1 = true;
27753 }
27754 }
27755 {
27756 PyThreadState* __tstate = wxPyBeginAllowThreads();
27757 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27758
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27763 {
27764 if (temp1)
27765 delete arg1;
27766 }
27767 return resultobj;
27768 fail:
27769 {
27770 if (temp1)
27771 delete arg1;
27772 }
27773 return NULL;
27774 }
27775
27776
27777 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27778 PyObject *resultobj;
27779 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27780 PyObject *arg2 = (PyObject *) 0 ;
27781 PyObject *arg3 = (PyObject *) 0 ;
27782 PyObject * obj0 = 0 ;
27783 PyObject * obj1 = 0 ;
27784 PyObject * obj2 = 0 ;
27785 char *kwnames[] = {
27786 (char *) "self",(char *) "self",(char *) "_class", NULL
27787 };
27788
27789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27791 if (SWIG_arg_fail(1)) SWIG_fail;
27792 arg2 = obj1;
27793 arg3 = obj2;
27794 {
27795 PyThreadState* __tstate = wxPyBeginAllowThreads();
27796 (arg1)->_setCallbackInfo(arg2,arg3);
27797
27798 wxPyEndAllowThreads(__tstate);
27799 if (PyErr_Occurred()) SWIG_fail;
27800 }
27801 Py_INCREF(Py_None); resultobj = Py_None;
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27809 PyObject *obj;
27810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27811 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27812 Py_INCREF(obj);
27813 return Py_BuildValue((char *)"");
27814 }
27815 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27816 PyObject *resultobj;
27817 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27818 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27819 wxBitmapDataObject *result;
27820 PyObject * obj0 = 0 ;
27821 char *kwnames[] = {
27822 (char *) "bitmap", NULL
27823 };
27824
27825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27826 if (obj0) {
27827 {
27828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27829 if (SWIG_arg_fail(1)) SWIG_fail;
27830 if (arg1 == NULL) {
27831 SWIG_null_ref("wxBitmap");
27832 }
27833 if (SWIG_arg_fail(1)) SWIG_fail;
27834 }
27835 }
27836 {
27837 PyThreadState* __tstate = wxPyBeginAllowThreads();
27838 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27839
27840 wxPyEndAllowThreads(__tstate);
27841 if (PyErr_Occurred()) SWIG_fail;
27842 }
27843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27844 return resultobj;
27845 fail:
27846 return NULL;
27847 }
27848
27849
27850 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27851 PyObject *resultobj;
27852 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27853 wxBitmap result;
27854 PyObject * obj0 = 0 ;
27855 char *kwnames[] = {
27856 (char *) "self", NULL
27857 };
27858
27859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27861 if (SWIG_arg_fail(1)) SWIG_fail;
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27865
27866 wxPyEndAllowThreads(__tstate);
27867 if (PyErr_Occurred()) SWIG_fail;
27868 }
27869 {
27870 wxBitmap * resultptr;
27871 resultptr = new wxBitmap((wxBitmap &)(result));
27872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27873 }
27874 return resultobj;
27875 fail:
27876 return NULL;
27877 }
27878
27879
27880 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27881 PyObject *resultobj;
27882 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27883 wxBitmap *arg2 = 0 ;
27884 PyObject * obj0 = 0 ;
27885 PyObject * obj1 = 0 ;
27886 char *kwnames[] = {
27887 (char *) "self",(char *) "bitmap", NULL
27888 };
27889
27890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27892 if (SWIG_arg_fail(1)) SWIG_fail;
27893 {
27894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27895 if (SWIG_arg_fail(2)) SWIG_fail;
27896 if (arg2 == NULL) {
27897 SWIG_null_ref("wxBitmap");
27898 }
27899 if (SWIG_arg_fail(2)) SWIG_fail;
27900 }
27901 {
27902 PyThreadState* __tstate = wxPyBeginAllowThreads();
27903 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27904
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 Py_INCREF(Py_None); resultobj = Py_None;
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27916 PyObject *obj;
27917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27918 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27919 Py_INCREF(obj);
27920 return Py_BuildValue((char *)"");
27921 }
27922 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27923 PyObject *resultobj;
27924 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27925 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27926 wxPyBitmapDataObject *result;
27927 PyObject * obj0 = 0 ;
27928 char *kwnames[] = {
27929 (char *) "bitmap", NULL
27930 };
27931
27932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27933 if (obj0) {
27934 {
27935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27936 if (SWIG_arg_fail(1)) SWIG_fail;
27937 if (arg1 == NULL) {
27938 SWIG_null_ref("wxBitmap");
27939 }
27940 if (SWIG_arg_fail(1)) SWIG_fail;
27941 }
27942 }
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27946
27947 wxPyEndAllowThreads(__tstate);
27948 if (PyErr_Occurred()) SWIG_fail;
27949 }
27950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27951 return resultobj;
27952 fail:
27953 return NULL;
27954 }
27955
27956
27957 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27958 PyObject *resultobj;
27959 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27960 PyObject *arg2 = (PyObject *) 0 ;
27961 PyObject *arg3 = (PyObject *) 0 ;
27962 PyObject * obj0 = 0 ;
27963 PyObject * obj1 = 0 ;
27964 PyObject * obj2 = 0 ;
27965 char *kwnames[] = {
27966 (char *) "self",(char *) "self",(char *) "_class", NULL
27967 };
27968
27969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27971 if (SWIG_arg_fail(1)) SWIG_fail;
27972 arg2 = obj1;
27973 arg3 = obj2;
27974 {
27975 PyThreadState* __tstate = wxPyBeginAllowThreads();
27976 (arg1)->_setCallbackInfo(arg2,arg3);
27977
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 Py_INCREF(Py_None); resultobj = Py_None;
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27989 PyObject *obj;
27990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27991 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27992 Py_INCREF(obj);
27993 return Py_BuildValue((char *)"");
27994 }
27995 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27996 PyObject *resultobj;
27997 wxFileDataObject *result;
27998 char *kwnames[] = {
27999 NULL
28000 };
28001
28002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28003 {
28004 PyThreadState* __tstate = wxPyBeginAllowThreads();
28005 result = (wxFileDataObject *)new wxFileDataObject();
28006
28007 wxPyEndAllowThreads(__tstate);
28008 if (PyErr_Occurred()) SWIG_fail;
28009 }
28010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj;
28019 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28020 wxArrayString *result;
28021 PyObject * obj0 = 0 ;
28022 char *kwnames[] = {
28023 (char *) "self", NULL
28024 };
28025
28026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28028 if (SWIG_arg_fail(1)) SWIG_fail;
28029 {
28030 PyThreadState* __tstate = wxPyBeginAllowThreads();
28031 {
28032 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28033 result = (wxArrayString *) &_result_ref;
28034 }
28035
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 {
28040 resultobj = wxArrayString2PyList_helper(*result);
28041 }
28042 return resultobj;
28043 fail:
28044 return NULL;
28045 }
28046
28047
28048 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28049 PyObject *resultobj;
28050 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28051 wxString *arg2 = 0 ;
28052 bool temp2 = false ;
28053 PyObject * obj0 = 0 ;
28054 PyObject * obj1 = 0 ;
28055 char *kwnames[] = {
28056 (char *) "self",(char *) "filename", NULL
28057 };
28058
28059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28061 if (SWIG_arg_fail(1)) SWIG_fail;
28062 {
28063 arg2 = wxString_in_helper(obj1);
28064 if (arg2 == NULL) SWIG_fail;
28065 temp2 = true;
28066 }
28067 {
28068 PyThreadState* __tstate = wxPyBeginAllowThreads();
28069 (arg1)->AddFile((wxString const &)*arg2);
28070
28071 wxPyEndAllowThreads(__tstate);
28072 if (PyErr_Occurred()) SWIG_fail;
28073 }
28074 Py_INCREF(Py_None); resultobj = Py_None;
28075 {
28076 if (temp2)
28077 delete arg2;
28078 }
28079 return resultobj;
28080 fail:
28081 {
28082 if (temp2)
28083 delete arg2;
28084 }
28085 return NULL;
28086 }
28087
28088
28089 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28090 PyObject *obj;
28091 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28092 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28093 Py_INCREF(obj);
28094 return Py_BuildValue((char *)"");
28095 }
28096 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28097 PyObject *resultobj;
28098 wxDataFormat *arg1 = 0 ;
28099 wxCustomDataObject *result;
28100 PyObject * obj0 = 0 ;
28101
28102 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28103 {
28104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28105 if (SWIG_arg_fail(1)) SWIG_fail;
28106 if (arg1 == NULL) {
28107 SWIG_null_ref("wxDataFormat");
28108 }
28109 if (SWIG_arg_fail(1)) SWIG_fail;
28110 }
28111 {
28112 PyThreadState* __tstate = wxPyBeginAllowThreads();
28113 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28114
28115 wxPyEndAllowThreads(__tstate);
28116 if (PyErr_Occurred()) SWIG_fail;
28117 }
28118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28119 return resultobj;
28120 fail:
28121 return NULL;
28122 }
28123
28124
28125 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28126 PyObject *resultobj;
28127 wxString *arg1 = 0 ;
28128 wxCustomDataObject *result;
28129 bool temp1 = false ;
28130 PyObject * obj0 = 0 ;
28131
28132 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28133 {
28134 arg1 = wxString_in_helper(obj0);
28135 if (arg1 == NULL) SWIG_fail;
28136 temp1 = true;
28137 }
28138 {
28139 PyThreadState* __tstate = wxPyBeginAllowThreads();
28140 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28141
28142 wxPyEndAllowThreads(__tstate);
28143 if (PyErr_Occurred()) SWIG_fail;
28144 }
28145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28146 {
28147 if (temp1)
28148 delete arg1;
28149 }
28150 return resultobj;
28151 fail:
28152 {
28153 if (temp1)
28154 delete arg1;
28155 }
28156 return NULL;
28157 }
28158
28159
28160 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28161 PyObject *resultobj;
28162 wxCustomDataObject *result;
28163
28164 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28165 {
28166 PyThreadState* __tstate = wxPyBeginAllowThreads();
28167 result = (wxCustomDataObject *)new wxCustomDataObject();
28168
28169 wxPyEndAllowThreads(__tstate);
28170 if (PyErr_Occurred()) SWIG_fail;
28171 }
28172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28180 int argc;
28181 PyObject *argv[2];
28182 int ii;
28183
28184 argc = PyObject_Length(args);
28185 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28186 argv[ii] = PyTuple_GetItem(args,ii);
28187 }
28188 if (argc == 0) {
28189 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28190 }
28191 if (argc == 1) {
28192 int _v;
28193 {
28194 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28195 }
28196 if (_v) {
28197 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28198 }
28199 }
28200 if (argc == 1) {
28201 int _v;
28202 {
28203 void *ptr = 0;
28204 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28205 _v = 0;
28206 PyErr_Clear();
28207 } else {
28208 _v = (ptr != 0);
28209 }
28210 }
28211 if (_v) {
28212 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28213 }
28214 }
28215
28216 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28217 return NULL;
28218 }
28219
28220
28221 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28222 PyObject *resultobj;
28223 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28224 PyObject *arg2 = (PyObject *) 0 ;
28225 bool result;
28226 PyObject * obj0 = 0 ;
28227 PyObject * obj1 = 0 ;
28228 char *kwnames[] = {
28229 (char *) "self",(char *) "data", NULL
28230 };
28231
28232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28234 if (SWIG_arg_fail(1)) SWIG_fail;
28235 arg2 = obj1;
28236 {
28237 PyThreadState* __tstate = wxPyBeginAllowThreads();
28238 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28239
28240 wxPyEndAllowThreads(__tstate);
28241 if (PyErr_Occurred()) SWIG_fail;
28242 }
28243 {
28244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28245 }
28246 return resultobj;
28247 fail:
28248 return NULL;
28249 }
28250
28251
28252 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28253 PyObject *resultobj;
28254 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28255 size_t result;
28256 PyObject * obj0 = 0 ;
28257 char *kwnames[] = {
28258 (char *) "self", NULL
28259 };
28260
28261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28263 if (SWIG_arg_fail(1)) SWIG_fail;
28264 {
28265 PyThreadState* __tstate = wxPyBeginAllowThreads();
28266 result = (size_t)(arg1)->GetSize();
28267
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 {
28272 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28273 }
28274 return resultobj;
28275 fail:
28276 return NULL;
28277 }
28278
28279
28280 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28281 PyObject *resultobj;
28282 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28283 PyObject *result;
28284 PyObject * obj0 = 0 ;
28285 char *kwnames[] = {
28286 (char *) "self", NULL
28287 };
28288
28289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28291 if (SWIG_arg_fail(1)) SWIG_fail;
28292 {
28293 PyThreadState* __tstate = wxPyBeginAllowThreads();
28294 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28295
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 resultobj = result;
28300 return resultobj;
28301 fail:
28302 return NULL;
28303 }
28304
28305
28306 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28307 PyObject *obj;
28308 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28309 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28310 Py_INCREF(obj);
28311 return Py_BuildValue((char *)"");
28312 }
28313 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28314 PyObject *resultobj;
28315 wxURLDataObject *result;
28316 char *kwnames[] = {
28317 NULL
28318 };
28319
28320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28321 {
28322 PyThreadState* __tstate = wxPyBeginAllowThreads();
28323 result = (wxURLDataObject *)new wxURLDataObject();
28324
28325 wxPyEndAllowThreads(__tstate);
28326 if (PyErr_Occurred()) SWIG_fail;
28327 }
28328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28329 return resultobj;
28330 fail:
28331 return NULL;
28332 }
28333
28334
28335 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28336 PyObject *resultobj;
28337 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28338 wxString result;
28339 PyObject * obj0 = 0 ;
28340 char *kwnames[] = {
28341 (char *) "self", NULL
28342 };
28343
28344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28346 if (SWIG_arg_fail(1)) SWIG_fail;
28347 {
28348 PyThreadState* __tstate = wxPyBeginAllowThreads();
28349 result = (arg1)->GetURL();
28350
28351 wxPyEndAllowThreads(__tstate);
28352 if (PyErr_Occurred()) SWIG_fail;
28353 }
28354 {
28355 #if wxUSE_UNICODE
28356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28357 #else
28358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28359 #endif
28360 }
28361 return resultobj;
28362 fail:
28363 return NULL;
28364 }
28365
28366
28367 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28368 PyObject *resultobj;
28369 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28370 wxString *arg2 = 0 ;
28371 bool temp2 = false ;
28372 PyObject * obj0 = 0 ;
28373 PyObject * obj1 = 0 ;
28374 char *kwnames[] = {
28375 (char *) "self",(char *) "url", NULL
28376 };
28377
28378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28380 if (SWIG_arg_fail(1)) SWIG_fail;
28381 {
28382 arg2 = wxString_in_helper(obj1);
28383 if (arg2 == NULL) SWIG_fail;
28384 temp2 = true;
28385 }
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 (arg1)->SetURL((wxString const &)*arg2);
28389
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 Py_INCREF(Py_None); resultobj = Py_None;
28394 {
28395 if (temp2)
28396 delete arg2;
28397 }
28398 return resultobj;
28399 fail:
28400 {
28401 if (temp2)
28402 delete arg2;
28403 }
28404 return NULL;
28405 }
28406
28407
28408 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28409 PyObject *obj;
28410 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28411 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28412 Py_INCREF(obj);
28413 return Py_BuildValue((char *)"");
28414 }
28415 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28416 PyObject *resultobj;
28417 wxMetafileDataObject *result;
28418 char *kwnames[] = {
28419 NULL
28420 };
28421
28422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28426
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28431 return resultobj;
28432 fail:
28433 return NULL;
28434 }
28435
28436
28437 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28438 PyObject *obj;
28439 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28440 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28441 Py_INCREF(obj);
28442 return Py_BuildValue((char *)"");
28443 }
28444 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28445 PyObject *resultobj;
28446 wxDragResult arg1 ;
28447 bool result;
28448 PyObject * obj0 = 0 ;
28449 char *kwnames[] = {
28450 (char *) "res", NULL
28451 };
28452
28453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28454 {
28455 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28456 if (SWIG_arg_fail(1)) SWIG_fail;
28457 }
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28461
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 {
28466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28467 }
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28475 PyObject *resultobj;
28476 wxWindow *arg1 = (wxWindow *) 0 ;
28477 wxIcon const &arg2_defvalue = wxNullIcon ;
28478 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28479 wxIcon const &arg3_defvalue = wxNullIcon ;
28480 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28481 wxIcon const &arg4_defvalue = wxNullIcon ;
28482 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28483 wxPyDropSource *result;
28484 PyObject * obj0 = 0 ;
28485 PyObject * obj1 = 0 ;
28486 PyObject * obj2 = 0 ;
28487 PyObject * obj3 = 0 ;
28488 char *kwnames[] = {
28489 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28490 };
28491
28492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28494 if (SWIG_arg_fail(1)) SWIG_fail;
28495 if (obj1) {
28496 {
28497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28498 if (SWIG_arg_fail(2)) SWIG_fail;
28499 if (arg2 == NULL) {
28500 SWIG_null_ref("wxIcon");
28501 }
28502 if (SWIG_arg_fail(2)) SWIG_fail;
28503 }
28504 }
28505 if (obj2) {
28506 {
28507 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28508 if (SWIG_arg_fail(3)) SWIG_fail;
28509 if (arg3 == NULL) {
28510 SWIG_null_ref("wxIcon");
28511 }
28512 if (SWIG_arg_fail(3)) SWIG_fail;
28513 }
28514 }
28515 if (obj3) {
28516 {
28517 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28518 if (SWIG_arg_fail(4)) SWIG_fail;
28519 if (arg4 == NULL) {
28520 SWIG_null_ref("wxIcon");
28521 }
28522 if (SWIG_arg_fail(4)) SWIG_fail;
28523 }
28524 }
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28540 PyObject *resultobj;
28541 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28542 PyObject *arg2 = (PyObject *) 0 ;
28543 PyObject *arg3 = (PyObject *) 0 ;
28544 int arg4 ;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 PyObject * obj2 = 0 ;
28548 PyObject * obj3 = 0 ;
28549 char *kwnames[] = {
28550 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28551 };
28552
28553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28555 if (SWIG_arg_fail(1)) SWIG_fail;
28556 arg2 = obj1;
28557 arg3 = obj2;
28558 {
28559 arg4 = (int)(SWIG_As_int(obj3));
28560 if (SWIG_arg_fail(4)) SWIG_fail;
28561 }
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28565
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 Py_INCREF(Py_None); resultobj = Py_None;
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28577 PyObject *resultobj;
28578 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28579 PyObject * obj0 = 0 ;
28580 char *kwnames[] = {
28581 (char *) "self", NULL
28582 };
28583
28584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28586 if (SWIG_arg_fail(1)) SWIG_fail;
28587 {
28588 PyThreadState* __tstate = wxPyBeginAllowThreads();
28589 delete arg1;
28590
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 Py_INCREF(Py_None); resultobj = Py_None;
28595 return resultobj;
28596 fail:
28597 return NULL;
28598 }
28599
28600
28601 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28602 PyObject *resultobj;
28603 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28604 wxDataObject *arg2 = 0 ;
28605 PyObject * obj0 = 0 ;
28606 PyObject * obj1 = 0 ;
28607 char *kwnames[] = {
28608 (char *) "self",(char *) "data", NULL
28609 };
28610
28611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28613 if (SWIG_arg_fail(1)) SWIG_fail;
28614 {
28615 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28616 if (SWIG_arg_fail(2)) SWIG_fail;
28617 if (arg2 == NULL) {
28618 SWIG_null_ref("wxDataObject");
28619 }
28620 if (SWIG_arg_fail(2)) SWIG_fail;
28621 }
28622 {
28623 PyThreadState* __tstate = wxPyBeginAllowThreads();
28624 (arg1)->SetData(*arg2);
28625
28626 wxPyEndAllowThreads(__tstate);
28627 if (PyErr_Occurred()) SWIG_fail;
28628 }
28629 Py_INCREF(Py_None); resultobj = Py_None;
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28637 PyObject *resultobj;
28638 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28639 wxDataObject *result;
28640 PyObject * obj0 = 0 ;
28641 char *kwnames[] = {
28642 (char *) "self", NULL
28643 };
28644
28645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28647 if (SWIG_arg_fail(1)) SWIG_fail;
28648 {
28649 PyThreadState* __tstate = wxPyBeginAllowThreads();
28650 result = (wxDataObject *)(arg1)->GetDataObject();
28651
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj;
28664 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28665 wxDragResult arg2 ;
28666 wxCursor *arg3 = 0 ;
28667 PyObject * obj0 = 0 ;
28668 PyObject * obj1 = 0 ;
28669 PyObject * obj2 = 0 ;
28670 char *kwnames[] = {
28671 (char *) "self",(char *) "res",(char *) "cursor", NULL
28672 };
28673
28674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28676 if (SWIG_arg_fail(1)) SWIG_fail;
28677 {
28678 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28679 if (SWIG_arg_fail(2)) SWIG_fail;
28680 }
28681 {
28682 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28683 if (SWIG_arg_fail(3)) SWIG_fail;
28684 if (arg3 == NULL) {
28685 SWIG_null_ref("wxCursor");
28686 }
28687 if (SWIG_arg_fail(3)) SWIG_fail;
28688 }
28689 {
28690 PyThreadState* __tstate = wxPyBeginAllowThreads();
28691 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28692
28693 wxPyEndAllowThreads(__tstate);
28694 if (PyErr_Occurred()) SWIG_fail;
28695 }
28696 Py_INCREF(Py_None); resultobj = Py_None;
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj;
28705 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28706 int arg2 = (int) wxDrag_CopyOnly ;
28707 wxDragResult result;
28708 PyObject * obj0 = 0 ;
28709 PyObject * obj1 = 0 ;
28710 char *kwnames[] = {
28711 (char *) "self",(char *) "flags", NULL
28712 };
28713
28714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28716 if (SWIG_arg_fail(1)) SWIG_fail;
28717 if (obj1) {
28718 {
28719 arg2 = (int)(SWIG_As_int(obj1));
28720 if (SWIG_arg_fail(2)) SWIG_fail;
28721 }
28722 }
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28726
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 resultobj = SWIG_From_int((result));
28731 return resultobj;
28732 fail:
28733 return NULL;
28734 }
28735
28736
28737 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28738 PyObject *resultobj;
28739 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28740 wxDragResult arg2 ;
28741 bool result;
28742 PyObject * obj0 = 0 ;
28743 PyObject * obj1 = 0 ;
28744 char *kwnames[] = {
28745 (char *) "self",(char *) "effect", NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(1)) SWIG_fail;
28751 {
28752 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28753 if (SWIG_arg_fail(2)) SWIG_fail;
28754 }
28755 {
28756 PyThreadState* __tstate = wxPyBeginAllowThreads();
28757 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28758
28759 wxPyEndAllowThreads(__tstate);
28760 if (PyErr_Occurred()) SWIG_fail;
28761 }
28762 {
28763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28764 }
28765 return resultobj;
28766 fail:
28767 return NULL;
28768 }
28769
28770
28771 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28772 PyObject *obj;
28773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28774 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28775 Py_INCREF(obj);
28776 return Py_BuildValue((char *)"");
28777 }
28778 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28779 PyObject *resultobj;
28780 wxDataObject *arg1 = (wxDataObject *) NULL ;
28781 wxPyDropTarget *result;
28782 PyObject * obj0 = 0 ;
28783 char *kwnames[] = {
28784 (char *) "dataObject", NULL
28785 };
28786
28787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28788 if (obj0) {
28789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28790 if (SWIG_arg_fail(1)) SWIG_fail;
28791 }
28792 {
28793 PyThreadState* __tstate = wxPyBeginAllowThreads();
28794 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28795
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28807 PyObject *resultobj;
28808 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28809 PyObject *arg2 = (PyObject *) 0 ;
28810 PyObject *arg3 = (PyObject *) 0 ;
28811 PyObject * obj0 = 0 ;
28812 PyObject * obj1 = 0 ;
28813 PyObject * obj2 = 0 ;
28814 char *kwnames[] = {
28815 (char *) "self",(char *) "self",(char *) "_class", NULL
28816 };
28817
28818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28820 if (SWIG_arg_fail(1)) SWIG_fail;
28821 arg2 = obj1;
28822 arg3 = obj2;
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 (arg1)->_setCallbackInfo(arg2,arg3);
28826
28827 wxPyEndAllowThreads(__tstate);
28828 if (PyErr_Occurred()) SWIG_fail;
28829 }
28830 Py_INCREF(Py_None); resultobj = Py_None;
28831 return resultobj;
28832 fail:
28833 return NULL;
28834 }
28835
28836
28837 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28838 PyObject *resultobj;
28839 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28840 PyObject * obj0 = 0 ;
28841 char *kwnames[] = {
28842 (char *) "self", NULL
28843 };
28844
28845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28847 if (SWIG_arg_fail(1)) SWIG_fail;
28848 {
28849 PyThreadState* __tstate = wxPyBeginAllowThreads();
28850 delete arg1;
28851
28852 wxPyEndAllowThreads(__tstate);
28853 if (PyErr_Occurred()) SWIG_fail;
28854 }
28855 Py_INCREF(Py_None); resultobj = Py_None;
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28863 PyObject *resultobj;
28864 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28865 wxDataObject *result;
28866 PyObject * obj0 = 0 ;
28867 char *kwnames[] = {
28868 (char *) "self", NULL
28869 };
28870
28871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28873 if (SWIG_arg_fail(1)) SWIG_fail;
28874 {
28875 PyThreadState* __tstate = wxPyBeginAllowThreads();
28876 result = (wxDataObject *)(arg1)->GetDataObject();
28877
28878 wxPyEndAllowThreads(__tstate);
28879 if (PyErr_Occurred()) SWIG_fail;
28880 }
28881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28882 return resultobj;
28883 fail:
28884 return NULL;
28885 }
28886
28887
28888 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28889 PyObject *resultobj;
28890 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28891 wxDataObject *arg2 = (wxDataObject *) 0 ;
28892 PyObject * obj0 = 0 ;
28893 PyObject * obj1 = 0 ;
28894 char *kwnames[] = {
28895 (char *) "self",(char *) "dataObject", NULL
28896 };
28897
28898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28900 if (SWIG_arg_fail(1)) SWIG_fail;
28901 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28902 if (SWIG_arg_fail(2)) SWIG_fail;
28903 {
28904 PyThreadState* __tstate = wxPyBeginAllowThreads();
28905 (arg1)->SetDataObject(arg2);
28906
28907 wxPyEndAllowThreads(__tstate);
28908 if (PyErr_Occurred()) SWIG_fail;
28909 }
28910 Py_INCREF(Py_None); resultobj = Py_None;
28911 return resultobj;
28912 fail:
28913 return NULL;
28914 }
28915
28916
28917 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28918 PyObject *resultobj;
28919 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28920 int arg2 ;
28921 int arg3 ;
28922 wxDragResult arg4 ;
28923 wxDragResult result;
28924 PyObject * obj0 = 0 ;
28925 PyObject * obj1 = 0 ;
28926 PyObject * obj2 = 0 ;
28927 PyObject * obj3 = 0 ;
28928 char *kwnames[] = {
28929 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28930 };
28931
28932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28934 if (SWIG_arg_fail(1)) SWIG_fail;
28935 {
28936 arg2 = (int)(SWIG_As_int(obj1));
28937 if (SWIG_arg_fail(2)) SWIG_fail;
28938 }
28939 {
28940 arg3 = (int)(SWIG_As_int(obj2));
28941 if (SWIG_arg_fail(3)) SWIG_fail;
28942 }
28943 {
28944 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28945 if (SWIG_arg_fail(4)) SWIG_fail;
28946 }
28947 {
28948 PyThreadState* __tstate = wxPyBeginAllowThreads();
28949 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28950
28951 wxPyEndAllowThreads(__tstate);
28952 if (PyErr_Occurred()) SWIG_fail;
28953 }
28954 resultobj = SWIG_From_int((result));
28955 return resultobj;
28956 fail:
28957 return NULL;
28958 }
28959
28960
28961 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28962 PyObject *resultobj;
28963 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28964 int arg2 ;
28965 int arg3 ;
28966 wxDragResult arg4 ;
28967 wxDragResult result;
28968 PyObject * obj0 = 0 ;
28969 PyObject * obj1 = 0 ;
28970 PyObject * obj2 = 0 ;
28971 PyObject * obj3 = 0 ;
28972 char *kwnames[] = {
28973 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28974 };
28975
28976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28978 if (SWIG_arg_fail(1)) SWIG_fail;
28979 {
28980 arg2 = (int)(SWIG_As_int(obj1));
28981 if (SWIG_arg_fail(2)) SWIG_fail;
28982 }
28983 {
28984 arg3 = (int)(SWIG_As_int(obj2));
28985 if (SWIG_arg_fail(3)) SWIG_fail;
28986 }
28987 {
28988 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28989 if (SWIG_arg_fail(4)) SWIG_fail;
28990 }
28991 {
28992 PyThreadState* __tstate = wxPyBeginAllowThreads();
28993 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28994
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 resultobj = SWIG_From_int((result));
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29006 PyObject *resultobj;
29007 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29008 PyObject * obj0 = 0 ;
29009 char *kwnames[] = {
29010 (char *) "self", NULL
29011 };
29012
29013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29015 if (SWIG_arg_fail(1)) SWIG_fail;
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 (arg1)->base_OnLeave();
29019
29020 wxPyEndAllowThreads(__tstate);
29021 if (PyErr_Occurred()) SWIG_fail;
29022 }
29023 Py_INCREF(Py_None); resultobj = Py_None;
29024 return resultobj;
29025 fail:
29026 return NULL;
29027 }
29028
29029
29030 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj;
29032 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29033 int arg2 ;
29034 int arg3 ;
29035 bool result;
29036 PyObject * obj0 = 0 ;
29037 PyObject * obj1 = 0 ;
29038 PyObject * obj2 = 0 ;
29039 char *kwnames[] = {
29040 (char *) "self",(char *) "x",(char *) "y", NULL
29041 };
29042
29043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29045 if (SWIG_arg_fail(1)) SWIG_fail;
29046 {
29047 arg2 = (int)(SWIG_As_int(obj1));
29048 if (SWIG_arg_fail(2)) SWIG_fail;
29049 }
29050 {
29051 arg3 = (int)(SWIG_As_int(obj2));
29052 if (SWIG_arg_fail(3)) SWIG_fail;
29053 }
29054 {
29055 PyThreadState* __tstate = wxPyBeginAllowThreads();
29056 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29057
29058 wxPyEndAllowThreads(__tstate);
29059 if (PyErr_Occurred()) SWIG_fail;
29060 }
29061 {
29062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29063 }
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29071 PyObject *resultobj;
29072 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29073 bool result;
29074 PyObject * obj0 = 0 ;
29075 char *kwnames[] = {
29076 (char *) "self", NULL
29077 };
29078
29079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29081 if (SWIG_arg_fail(1)) SWIG_fail;
29082 {
29083 PyThreadState* __tstate = wxPyBeginAllowThreads();
29084 result = (bool)(arg1)->GetData();
29085
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 {
29090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29091 }
29092 return resultobj;
29093 fail:
29094 return NULL;
29095 }
29096
29097
29098 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29099 PyObject *obj;
29100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29101 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29102 Py_INCREF(obj);
29103 return Py_BuildValue((char *)"");
29104 }
29105 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29106 PyObject *resultobj;
29107 wxPyTextDropTarget *result;
29108 char *kwnames[] = {
29109 NULL
29110 };
29111
29112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29116
29117 wxPyEndAllowThreads(__tstate);
29118 if (PyErr_Occurred()) SWIG_fail;
29119 }
29120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29121 return resultobj;
29122 fail:
29123 return NULL;
29124 }
29125
29126
29127 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29128 PyObject *resultobj;
29129 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29130 PyObject *arg2 = (PyObject *) 0 ;
29131 PyObject *arg3 = (PyObject *) 0 ;
29132 PyObject * obj0 = 0 ;
29133 PyObject * obj1 = 0 ;
29134 PyObject * obj2 = 0 ;
29135 char *kwnames[] = {
29136 (char *) "self",(char *) "self",(char *) "_class", NULL
29137 };
29138
29139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29141 if (SWIG_arg_fail(1)) SWIG_fail;
29142 arg2 = obj1;
29143 arg3 = obj2;
29144 {
29145 PyThreadState* __tstate = wxPyBeginAllowThreads();
29146 (arg1)->_setCallbackInfo(arg2,arg3);
29147
29148 wxPyEndAllowThreads(__tstate);
29149 if (PyErr_Occurred()) SWIG_fail;
29150 }
29151 Py_INCREF(Py_None); resultobj = Py_None;
29152 return resultobj;
29153 fail:
29154 return NULL;
29155 }
29156
29157
29158 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29159 PyObject *resultobj;
29160 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29161 int arg2 ;
29162 int arg3 ;
29163 wxDragResult arg4 ;
29164 wxDragResult result;
29165 PyObject * obj0 = 0 ;
29166 PyObject * obj1 = 0 ;
29167 PyObject * obj2 = 0 ;
29168 PyObject * obj3 = 0 ;
29169 char *kwnames[] = {
29170 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29171 };
29172
29173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29175 if (SWIG_arg_fail(1)) SWIG_fail;
29176 {
29177 arg2 = (int)(SWIG_As_int(obj1));
29178 if (SWIG_arg_fail(2)) SWIG_fail;
29179 }
29180 {
29181 arg3 = (int)(SWIG_As_int(obj2));
29182 if (SWIG_arg_fail(3)) SWIG_fail;
29183 }
29184 {
29185 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29186 if (SWIG_arg_fail(4)) SWIG_fail;
29187 }
29188 {
29189 PyThreadState* __tstate = wxPyBeginAllowThreads();
29190 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29191
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_From_int((result));
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29203 PyObject *resultobj;
29204 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29205 int arg2 ;
29206 int arg3 ;
29207 wxDragResult arg4 ;
29208 wxDragResult result;
29209 PyObject * obj0 = 0 ;
29210 PyObject * obj1 = 0 ;
29211 PyObject * obj2 = 0 ;
29212 PyObject * obj3 = 0 ;
29213 char *kwnames[] = {
29214 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29215 };
29216
29217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29219 if (SWIG_arg_fail(1)) SWIG_fail;
29220 {
29221 arg2 = (int)(SWIG_As_int(obj1));
29222 if (SWIG_arg_fail(2)) SWIG_fail;
29223 }
29224 {
29225 arg3 = (int)(SWIG_As_int(obj2));
29226 if (SWIG_arg_fail(3)) SWIG_fail;
29227 }
29228 {
29229 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29230 if (SWIG_arg_fail(4)) SWIG_fail;
29231 }
29232 {
29233 PyThreadState* __tstate = wxPyBeginAllowThreads();
29234 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29235
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 resultobj = SWIG_From_int((result));
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29249 PyObject * obj0 = 0 ;
29250 char *kwnames[] = {
29251 (char *) "self", NULL
29252 };
29253
29254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29256 if (SWIG_arg_fail(1)) SWIG_fail;
29257 {
29258 PyThreadState* __tstate = wxPyBeginAllowThreads();
29259 (arg1)->base_OnLeave();
29260
29261 wxPyEndAllowThreads(__tstate);
29262 if (PyErr_Occurred()) SWIG_fail;
29263 }
29264 Py_INCREF(Py_None); resultobj = Py_None;
29265 return resultobj;
29266 fail:
29267 return NULL;
29268 }
29269
29270
29271 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29272 PyObject *resultobj;
29273 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29274 int arg2 ;
29275 int arg3 ;
29276 bool result;
29277 PyObject * obj0 = 0 ;
29278 PyObject * obj1 = 0 ;
29279 PyObject * obj2 = 0 ;
29280 char *kwnames[] = {
29281 (char *) "self",(char *) "x",(char *) "y", NULL
29282 };
29283
29284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29286 if (SWIG_arg_fail(1)) SWIG_fail;
29287 {
29288 arg2 = (int)(SWIG_As_int(obj1));
29289 if (SWIG_arg_fail(2)) SWIG_fail;
29290 }
29291 {
29292 arg3 = (int)(SWIG_As_int(obj2));
29293 if (SWIG_arg_fail(3)) SWIG_fail;
29294 }
29295 {
29296 PyThreadState* __tstate = wxPyBeginAllowThreads();
29297 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29298
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 {
29303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29304 }
29305 return resultobj;
29306 fail:
29307 return NULL;
29308 }
29309
29310
29311 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29312 PyObject *resultobj;
29313 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29314 int arg2 ;
29315 int arg3 ;
29316 wxDragResult arg4 ;
29317 wxDragResult result;
29318 PyObject * obj0 = 0 ;
29319 PyObject * obj1 = 0 ;
29320 PyObject * obj2 = 0 ;
29321 PyObject * obj3 = 0 ;
29322 char *kwnames[] = {
29323 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29324 };
29325
29326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29328 if (SWIG_arg_fail(1)) SWIG_fail;
29329 {
29330 arg2 = (int)(SWIG_As_int(obj1));
29331 if (SWIG_arg_fail(2)) SWIG_fail;
29332 }
29333 {
29334 arg3 = (int)(SWIG_As_int(obj2));
29335 if (SWIG_arg_fail(3)) SWIG_fail;
29336 }
29337 {
29338 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29339 if (SWIG_arg_fail(4)) SWIG_fail;
29340 }
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29344
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 resultobj = SWIG_From_int((result));
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29356 PyObject *obj;
29357 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29358 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29359 Py_INCREF(obj);
29360 return Py_BuildValue((char *)"");
29361 }
29362 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29363 PyObject *resultobj;
29364 wxPyFileDropTarget *result;
29365 char *kwnames[] = {
29366 NULL
29367 };
29368
29369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29370 {
29371 PyThreadState* __tstate = wxPyBeginAllowThreads();
29372 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29373
29374 wxPyEndAllowThreads(__tstate);
29375 if (PyErr_Occurred()) SWIG_fail;
29376 }
29377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29378 return resultobj;
29379 fail:
29380 return NULL;
29381 }
29382
29383
29384 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29385 PyObject *resultobj;
29386 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29387 PyObject *arg2 = (PyObject *) 0 ;
29388 PyObject *arg3 = (PyObject *) 0 ;
29389 PyObject * obj0 = 0 ;
29390 PyObject * obj1 = 0 ;
29391 PyObject * obj2 = 0 ;
29392 char *kwnames[] = {
29393 (char *) "self",(char *) "self",(char *) "_class", NULL
29394 };
29395
29396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29398 if (SWIG_arg_fail(1)) SWIG_fail;
29399 arg2 = obj1;
29400 arg3 = obj2;
29401 {
29402 PyThreadState* __tstate = wxPyBeginAllowThreads();
29403 (arg1)->_setCallbackInfo(arg2,arg3);
29404
29405 wxPyEndAllowThreads(__tstate);
29406 if (PyErr_Occurred()) SWIG_fail;
29407 }
29408 Py_INCREF(Py_None); resultobj = Py_None;
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29416 PyObject *resultobj;
29417 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29418 int arg2 ;
29419 int arg3 ;
29420 wxDragResult arg4 ;
29421 wxDragResult result;
29422 PyObject * obj0 = 0 ;
29423 PyObject * obj1 = 0 ;
29424 PyObject * obj2 = 0 ;
29425 PyObject * obj3 = 0 ;
29426 char *kwnames[] = {
29427 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29428 };
29429
29430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29432 if (SWIG_arg_fail(1)) SWIG_fail;
29433 {
29434 arg2 = (int)(SWIG_As_int(obj1));
29435 if (SWIG_arg_fail(2)) SWIG_fail;
29436 }
29437 {
29438 arg3 = (int)(SWIG_As_int(obj2));
29439 if (SWIG_arg_fail(3)) SWIG_fail;
29440 }
29441 {
29442 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29443 if (SWIG_arg_fail(4)) SWIG_fail;
29444 }
29445 {
29446 PyThreadState* __tstate = wxPyBeginAllowThreads();
29447 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29448
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 resultobj = SWIG_From_int((result));
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj;
29461 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29462 int arg2 ;
29463 int arg3 ;
29464 wxDragResult arg4 ;
29465 wxDragResult result;
29466 PyObject * obj0 = 0 ;
29467 PyObject * obj1 = 0 ;
29468 PyObject * obj2 = 0 ;
29469 PyObject * obj3 = 0 ;
29470 char *kwnames[] = {
29471 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29472 };
29473
29474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29476 if (SWIG_arg_fail(1)) SWIG_fail;
29477 {
29478 arg2 = (int)(SWIG_As_int(obj1));
29479 if (SWIG_arg_fail(2)) SWIG_fail;
29480 }
29481 {
29482 arg3 = (int)(SWIG_As_int(obj2));
29483 if (SWIG_arg_fail(3)) SWIG_fail;
29484 }
29485 {
29486 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29487 if (SWIG_arg_fail(4)) SWIG_fail;
29488 }
29489 {
29490 PyThreadState* __tstate = wxPyBeginAllowThreads();
29491 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29492
29493 wxPyEndAllowThreads(__tstate);
29494 if (PyErr_Occurred()) SWIG_fail;
29495 }
29496 resultobj = SWIG_From_int((result));
29497 return resultobj;
29498 fail:
29499 return NULL;
29500 }
29501
29502
29503 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29504 PyObject *resultobj;
29505 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29506 PyObject * obj0 = 0 ;
29507 char *kwnames[] = {
29508 (char *) "self", NULL
29509 };
29510
29511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29513 if (SWIG_arg_fail(1)) SWIG_fail;
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 (arg1)->base_OnLeave();
29517
29518 wxPyEndAllowThreads(__tstate);
29519 if (PyErr_Occurred()) SWIG_fail;
29520 }
29521 Py_INCREF(Py_None); resultobj = Py_None;
29522 return resultobj;
29523 fail:
29524 return NULL;
29525 }
29526
29527
29528 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29529 PyObject *resultobj;
29530 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29531 int arg2 ;
29532 int arg3 ;
29533 bool result;
29534 PyObject * obj0 = 0 ;
29535 PyObject * obj1 = 0 ;
29536 PyObject * obj2 = 0 ;
29537 char *kwnames[] = {
29538 (char *) "self",(char *) "x",(char *) "y", NULL
29539 };
29540
29541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29543 if (SWIG_arg_fail(1)) SWIG_fail;
29544 {
29545 arg2 = (int)(SWIG_As_int(obj1));
29546 if (SWIG_arg_fail(2)) SWIG_fail;
29547 }
29548 {
29549 arg3 = (int)(SWIG_As_int(obj2));
29550 if (SWIG_arg_fail(3)) SWIG_fail;
29551 }
29552 {
29553 PyThreadState* __tstate = wxPyBeginAllowThreads();
29554 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29555
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 {
29560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29561 }
29562 return resultobj;
29563 fail:
29564 return NULL;
29565 }
29566
29567
29568 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29569 PyObject *resultobj;
29570 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29571 int arg2 ;
29572 int arg3 ;
29573 wxDragResult arg4 ;
29574 wxDragResult result;
29575 PyObject * obj0 = 0 ;
29576 PyObject * obj1 = 0 ;
29577 PyObject * obj2 = 0 ;
29578 PyObject * obj3 = 0 ;
29579 char *kwnames[] = {
29580 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29581 };
29582
29583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29585 if (SWIG_arg_fail(1)) SWIG_fail;
29586 {
29587 arg2 = (int)(SWIG_As_int(obj1));
29588 if (SWIG_arg_fail(2)) SWIG_fail;
29589 }
29590 {
29591 arg3 = (int)(SWIG_As_int(obj2));
29592 if (SWIG_arg_fail(3)) SWIG_fail;
29593 }
29594 {
29595 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29596 if (SWIG_arg_fail(4)) SWIG_fail;
29597 }
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29601
29602 wxPyEndAllowThreads(__tstate);
29603 if (PyErr_Occurred()) SWIG_fail;
29604 }
29605 resultobj = SWIG_From_int((result));
29606 return resultobj;
29607 fail:
29608 return NULL;
29609 }
29610
29611
29612 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29613 PyObject *obj;
29614 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29615 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29616 Py_INCREF(obj);
29617 return Py_BuildValue((char *)"");
29618 }
29619 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29620 PyObject *resultobj;
29621 wxClipboard *result;
29622 char *kwnames[] = {
29623 NULL
29624 };
29625
29626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29627 {
29628 PyThreadState* __tstate = wxPyBeginAllowThreads();
29629 result = (wxClipboard *)new wxClipboard();
29630
29631 wxPyEndAllowThreads(__tstate);
29632 if (PyErr_Occurred()) SWIG_fail;
29633 }
29634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29635 return resultobj;
29636 fail:
29637 return NULL;
29638 }
29639
29640
29641 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29642 PyObject *resultobj;
29643 wxClipboard *arg1 = (wxClipboard *) 0 ;
29644 PyObject * obj0 = 0 ;
29645 char *kwnames[] = {
29646 (char *) "self", NULL
29647 };
29648
29649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29651 if (SWIG_arg_fail(1)) SWIG_fail;
29652 {
29653 PyThreadState* __tstate = wxPyBeginAllowThreads();
29654 delete arg1;
29655
29656 wxPyEndAllowThreads(__tstate);
29657 if (PyErr_Occurred()) SWIG_fail;
29658 }
29659 Py_INCREF(Py_None); resultobj = Py_None;
29660 return resultobj;
29661 fail:
29662 return NULL;
29663 }
29664
29665
29666 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29667 PyObject *resultobj;
29668 wxClipboard *arg1 = (wxClipboard *) 0 ;
29669 bool result;
29670 PyObject * obj0 = 0 ;
29671 char *kwnames[] = {
29672 (char *) "self", NULL
29673 };
29674
29675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29677 if (SWIG_arg_fail(1)) SWIG_fail;
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 result = (bool)(arg1)->Open();
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29687 }
29688 return resultobj;
29689 fail:
29690 return NULL;
29691 }
29692
29693
29694 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29695 PyObject *resultobj;
29696 wxClipboard *arg1 = (wxClipboard *) 0 ;
29697 PyObject * obj0 = 0 ;
29698 char *kwnames[] = {
29699 (char *) "self", NULL
29700 };
29701
29702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29704 if (SWIG_arg_fail(1)) SWIG_fail;
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 (arg1)->Close();
29708
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 Py_INCREF(Py_None); resultobj = Py_None;
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29720 PyObject *resultobj;
29721 wxClipboard *arg1 = (wxClipboard *) 0 ;
29722 bool result;
29723 PyObject * obj0 = 0 ;
29724 char *kwnames[] = {
29725 (char *) "self", NULL
29726 };
29727
29728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29730 if (SWIG_arg_fail(1)) SWIG_fail;
29731 {
29732 PyThreadState* __tstate = wxPyBeginAllowThreads();
29733 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29734
29735 wxPyEndAllowThreads(__tstate);
29736 if (PyErr_Occurred()) SWIG_fail;
29737 }
29738 {
29739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29740 }
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29748 PyObject *resultobj;
29749 wxClipboard *arg1 = (wxClipboard *) 0 ;
29750 wxDataObject *arg2 = (wxDataObject *) 0 ;
29751 bool result;
29752 PyObject * obj0 = 0 ;
29753 PyObject * obj1 = 0 ;
29754 char *kwnames[] = {
29755 (char *) "self",(char *) "data", NULL
29756 };
29757
29758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29760 if (SWIG_arg_fail(1)) SWIG_fail;
29761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29762 if (SWIG_arg_fail(2)) SWIG_fail;
29763 {
29764 PyThreadState* __tstate = wxPyBeginAllowThreads();
29765 result = (bool)(arg1)->AddData(arg2);
29766
29767 wxPyEndAllowThreads(__tstate);
29768 if (PyErr_Occurred()) SWIG_fail;
29769 }
29770 {
29771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29772 }
29773 return resultobj;
29774 fail:
29775 return NULL;
29776 }
29777
29778
29779 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29780 PyObject *resultobj;
29781 wxClipboard *arg1 = (wxClipboard *) 0 ;
29782 wxDataObject *arg2 = (wxDataObject *) 0 ;
29783 bool result;
29784 PyObject * obj0 = 0 ;
29785 PyObject * obj1 = 0 ;
29786 char *kwnames[] = {
29787 (char *) "self",(char *) "data", NULL
29788 };
29789
29790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29792 if (SWIG_arg_fail(1)) SWIG_fail;
29793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29794 if (SWIG_arg_fail(2)) SWIG_fail;
29795 {
29796 PyThreadState* __tstate = wxPyBeginAllowThreads();
29797 result = (bool)(arg1)->SetData(arg2);
29798
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 {
29803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29804 }
29805 return resultobj;
29806 fail:
29807 return NULL;
29808 }
29809
29810
29811 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29812 PyObject *resultobj;
29813 wxClipboard *arg1 = (wxClipboard *) 0 ;
29814 wxDataFormat *arg2 = 0 ;
29815 bool result;
29816 PyObject * obj0 = 0 ;
29817 PyObject * obj1 = 0 ;
29818 char *kwnames[] = {
29819 (char *) "self",(char *) "format", NULL
29820 };
29821
29822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29824 if (SWIG_arg_fail(1)) SWIG_fail;
29825 {
29826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29827 if (SWIG_arg_fail(2)) SWIG_fail;
29828 if (arg2 == NULL) {
29829 SWIG_null_ref("wxDataFormat");
29830 }
29831 if (SWIG_arg_fail(2)) SWIG_fail;
29832 }
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29836
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 {
29841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29842 }
29843 return resultobj;
29844 fail:
29845 return NULL;
29846 }
29847
29848
29849 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29850 PyObject *resultobj;
29851 wxClipboard *arg1 = (wxClipboard *) 0 ;
29852 wxDataObject *arg2 = 0 ;
29853 bool result;
29854 PyObject * obj0 = 0 ;
29855 PyObject * obj1 = 0 ;
29856 char *kwnames[] = {
29857 (char *) "self",(char *) "data", NULL
29858 };
29859
29860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29862 if (SWIG_arg_fail(1)) SWIG_fail;
29863 {
29864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29865 if (SWIG_arg_fail(2)) SWIG_fail;
29866 if (arg2 == NULL) {
29867 SWIG_null_ref("wxDataObject");
29868 }
29869 if (SWIG_arg_fail(2)) SWIG_fail;
29870 }
29871 {
29872 PyThreadState* __tstate = wxPyBeginAllowThreads();
29873 result = (bool)(arg1)->GetData(*arg2);
29874
29875 wxPyEndAllowThreads(__tstate);
29876 if (PyErr_Occurred()) SWIG_fail;
29877 }
29878 {
29879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29880 }
29881 return resultobj;
29882 fail:
29883 return NULL;
29884 }
29885
29886
29887 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29888 PyObject *resultobj;
29889 wxClipboard *arg1 = (wxClipboard *) 0 ;
29890 PyObject * obj0 = 0 ;
29891 char *kwnames[] = {
29892 (char *) "self", NULL
29893 };
29894
29895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29897 if (SWIG_arg_fail(1)) SWIG_fail;
29898 {
29899 PyThreadState* __tstate = wxPyBeginAllowThreads();
29900 (arg1)->Clear();
29901
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 Py_INCREF(Py_None); resultobj = Py_None;
29906 return resultobj;
29907 fail:
29908 return NULL;
29909 }
29910
29911
29912 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29913 PyObject *resultobj;
29914 wxClipboard *arg1 = (wxClipboard *) 0 ;
29915 bool result;
29916 PyObject * obj0 = 0 ;
29917 char *kwnames[] = {
29918 (char *) "self", NULL
29919 };
29920
29921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29923 if (SWIG_arg_fail(1)) SWIG_fail;
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 result = (bool)(arg1)->Flush();
29927
29928 wxPyEndAllowThreads(__tstate);
29929 if (PyErr_Occurred()) SWIG_fail;
29930 }
29931 {
29932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29933 }
29934 return resultobj;
29935 fail:
29936 return NULL;
29937 }
29938
29939
29940 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29941 PyObject *resultobj;
29942 wxClipboard *arg1 = (wxClipboard *) 0 ;
29943 bool arg2 = (bool) true ;
29944 PyObject * obj0 = 0 ;
29945 PyObject * obj1 = 0 ;
29946 char *kwnames[] = {
29947 (char *) "self",(char *) "primary", NULL
29948 };
29949
29950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29952 if (SWIG_arg_fail(1)) SWIG_fail;
29953 if (obj1) {
29954 {
29955 arg2 = (bool)(SWIG_As_bool(obj1));
29956 if (SWIG_arg_fail(2)) SWIG_fail;
29957 }
29958 }
29959 {
29960 PyThreadState* __tstate = wxPyBeginAllowThreads();
29961 (arg1)->UsePrimarySelection(arg2);
29962
29963 wxPyEndAllowThreads(__tstate);
29964 if (PyErr_Occurred()) SWIG_fail;
29965 }
29966 Py_INCREF(Py_None); resultobj = Py_None;
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29974 PyObject *resultobj;
29975 wxClipboard *result;
29976 char *kwnames[] = {
29977 NULL
29978 };
29979
29980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 result = (wxClipboard *)wxClipboard::Get();
29984
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29996 PyObject *obj;
29997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29998 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29999 Py_INCREF(obj);
30000 return Py_BuildValue((char *)"");
30001 }
30002 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30003 PyObject *resultobj;
30004 wxClipboard *arg1 = (wxClipboard *) NULL ;
30005 wxClipboardLocker *result;
30006 PyObject * obj0 = 0 ;
30007 char *kwnames[] = {
30008 (char *) "clipboard", NULL
30009 };
30010
30011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30012 if (obj0) {
30013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30014 if (SWIG_arg_fail(1)) SWIG_fail;
30015 }
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30019
30020 wxPyEndAllowThreads(__tstate);
30021 if (PyErr_Occurred()) SWIG_fail;
30022 }
30023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30024 return resultobj;
30025 fail:
30026 return NULL;
30027 }
30028
30029
30030 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30031 PyObject *resultobj;
30032 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30033 PyObject * obj0 = 0 ;
30034 char *kwnames[] = {
30035 (char *) "self", NULL
30036 };
30037
30038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30040 if (SWIG_arg_fail(1)) SWIG_fail;
30041 {
30042 PyThreadState* __tstate = wxPyBeginAllowThreads();
30043 delete arg1;
30044
30045 wxPyEndAllowThreads(__tstate);
30046 if (PyErr_Occurred()) SWIG_fail;
30047 }
30048 Py_INCREF(Py_None); resultobj = Py_None;
30049 return resultobj;
30050 fail:
30051 return NULL;
30052 }
30053
30054
30055 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30056 PyObject *resultobj;
30057 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30058 bool result;
30059 PyObject * obj0 = 0 ;
30060 char *kwnames[] = {
30061 (char *) "self", NULL
30062 };
30063
30064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30066 if (SWIG_arg_fail(1)) SWIG_fail;
30067 {
30068 PyThreadState* __tstate = wxPyBeginAllowThreads();
30069 result = (bool)wxClipboardLocker___nonzero__(arg1);
30070
30071 wxPyEndAllowThreads(__tstate);
30072 if (PyErr_Occurred()) SWIG_fail;
30073 }
30074 {
30075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30076 }
30077 return resultobj;
30078 fail:
30079 return NULL;
30080 }
30081
30082
30083 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30084 PyObject *obj;
30085 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30086 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30087 Py_INCREF(obj);
30088 return Py_BuildValue((char *)"");
30089 }
30090 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30091 PyObject *resultobj;
30092 int arg1 = (int) 0 ;
30093 int arg2 = (int) 0 ;
30094 int arg3 = (int) 0 ;
30095 int arg4 = (int) 0 ;
30096 wxVideoMode *result;
30097 PyObject * obj0 = 0 ;
30098 PyObject * obj1 = 0 ;
30099 PyObject * obj2 = 0 ;
30100 PyObject * obj3 = 0 ;
30101 char *kwnames[] = {
30102 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30103 };
30104
30105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30106 if (obj0) {
30107 {
30108 arg1 = (int)(SWIG_As_int(obj0));
30109 if (SWIG_arg_fail(1)) SWIG_fail;
30110 }
30111 }
30112 if (obj1) {
30113 {
30114 arg2 = (int)(SWIG_As_int(obj1));
30115 if (SWIG_arg_fail(2)) SWIG_fail;
30116 }
30117 }
30118 if (obj2) {
30119 {
30120 arg3 = (int)(SWIG_As_int(obj2));
30121 if (SWIG_arg_fail(3)) SWIG_fail;
30122 }
30123 }
30124 if (obj3) {
30125 {
30126 arg4 = (int)(SWIG_As_int(obj3));
30127 if (SWIG_arg_fail(4)) SWIG_fail;
30128 }
30129 }
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30133
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30138 return resultobj;
30139 fail:
30140 return NULL;
30141 }
30142
30143
30144 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30145 PyObject *resultobj;
30146 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30147 PyObject * obj0 = 0 ;
30148 char *kwnames[] = {
30149 (char *) "self", NULL
30150 };
30151
30152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30154 if (SWIG_arg_fail(1)) SWIG_fail;
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 delete arg1;
30158
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 Py_INCREF(Py_None); resultobj = Py_None;
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30170 PyObject *resultobj;
30171 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30172 wxVideoMode *arg2 = 0 ;
30173 bool result;
30174 PyObject * obj0 = 0 ;
30175 PyObject * obj1 = 0 ;
30176 char *kwnames[] = {
30177 (char *) "self",(char *) "other", NULL
30178 };
30179
30180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30182 if (SWIG_arg_fail(1)) SWIG_fail;
30183 {
30184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30185 if (SWIG_arg_fail(2)) SWIG_fail;
30186 if (arg2 == NULL) {
30187 SWIG_null_ref("wxVideoMode");
30188 }
30189 if (SWIG_arg_fail(2)) SWIG_fail;
30190 }
30191 {
30192 PyThreadState* __tstate = wxPyBeginAllowThreads();
30193 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30194
30195 wxPyEndAllowThreads(__tstate);
30196 if (PyErr_Occurred()) SWIG_fail;
30197 }
30198 {
30199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30200 }
30201 return resultobj;
30202 fail:
30203 return NULL;
30204 }
30205
30206
30207 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30208 PyObject *resultobj;
30209 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30210 int result;
30211 PyObject * obj0 = 0 ;
30212 char *kwnames[] = {
30213 (char *) "self", NULL
30214 };
30215
30216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30218 if (SWIG_arg_fail(1)) SWIG_fail;
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30222
30223 wxPyEndAllowThreads(__tstate);
30224 if (PyErr_Occurred()) SWIG_fail;
30225 }
30226 {
30227 resultobj = SWIG_From_int((int)(result));
30228 }
30229 return resultobj;
30230 fail:
30231 return NULL;
30232 }
30233
30234
30235 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj;
30237 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30238 int result;
30239 PyObject * obj0 = 0 ;
30240 char *kwnames[] = {
30241 (char *) "self", NULL
30242 };
30243
30244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30246 if (SWIG_arg_fail(1)) SWIG_fail;
30247 {
30248 PyThreadState* __tstate = wxPyBeginAllowThreads();
30249 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30250
30251 wxPyEndAllowThreads(__tstate);
30252 if (PyErr_Occurred()) SWIG_fail;
30253 }
30254 {
30255 resultobj = SWIG_From_int((int)(result));
30256 }
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30264 PyObject *resultobj;
30265 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30266 int result;
30267 PyObject * obj0 = 0 ;
30268 char *kwnames[] = {
30269 (char *) "self", NULL
30270 };
30271
30272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30274 if (SWIG_arg_fail(1)) SWIG_fail;
30275 {
30276 PyThreadState* __tstate = wxPyBeginAllowThreads();
30277 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30278
30279 wxPyEndAllowThreads(__tstate);
30280 if (PyErr_Occurred()) SWIG_fail;
30281 }
30282 {
30283 resultobj = SWIG_From_int((int)(result));
30284 }
30285 return resultobj;
30286 fail:
30287 return NULL;
30288 }
30289
30290
30291 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30292 PyObject *resultobj;
30293 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30294 bool result;
30295 PyObject * obj0 = 0 ;
30296 char *kwnames[] = {
30297 (char *) "self", NULL
30298 };
30299
30300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30302 if (SWIG_arg_fail(1)) SWIG_fail;
30303 {
30304 PyThreadState* __tstate = wxPyBeginAllowThreads();
30305 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30306
30307 wxPyEndAllowThreads(__tstate);
30308 if (PyErr_Occurred()) SWIG_fail;
30309 }
30310 {
30311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30312 }
30313 return resultobj;
30314 fail:
30315 return NULL;
30316 }
30317
30318
30319 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30320 PyObject *resultobj;
30321 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30322 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30323 bool result;
30324 PyObject * obj0 = 0 ;
30325 PyObject * obj1 = 0 ;
30326 char *kwnames[] = {
30327 (char *) "self",(char *) "other", NULL
30328 };
30329
30330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30332 if (SWIG_arg_fail(1)) SWIG_fail;
30333 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30334 if (SWIG_arg_fail(2)) SWIG_fail;
30335 {
30336 PyThreadState* __tstate = wxPyBeginAllowThreads();
30337 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30338
30339 wxPyEndAllowThreads(__tstate);
30340 if (PyErr_Occurred()) SWIG_fail;
30341 }
30342 {
30343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30344 }
30345 return resultobj;
30346 fail:
30347 return NULL;
30348 }
30349
30350
30351 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30352 PyObject *resultobj;
30353 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30354 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30355 bool result;
30356 PyObject * obj0 = 0 ;
30357 PyObject * obj1 = 0 ;
30358 char *kwnames[] = {
30359 (char *) "self",(char *) "other", NULL
30360 };
30361
30362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30364 if (SWIG_arg_fail(1)) SWIG_fail;
30365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30366 if (SWIG_arg_fail(2)) SWIG_fail;
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30370
30371 wxPyEndAllowThreads(__tstate);
30372 if (PyErr_Occurred()) SWIG_fail;
30373 }
30374 {
30375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30376 }
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30384 PyObject *resultobj;
30385 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30386 int arg2 ;
30387 PyObject * obj0 = 0 ;
30388 PyObject * obj1 = 0 ;
30389 char *kwnames[] = {
30390 (char *) "self",(char *) "w", NULL
30391 };
30392
30393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30395 if (SWIG_arg_fail(1)) SWIG_fail;
30396 {
30397 arg2 = (int)(SWIG_As_int(obj1));
30398 if (SWIG_arg_fail(2)) SWIG_fail;
30399 }
30400 if (arg1) (arg1)->w = arg2;
30401
30402 Py_INCREF(Py_None); resultobj = Py_None;
30403 return resultobj;
30404 fail:
30405 return NULL;
30406 }
30407
30408
30409 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30410 PyObject *resultobj;
30411 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30412 int result;
30413 PyObject * obj0 = 0 ;
30414 char *kwnames[] = {
30415 (char *) "self", NULL
30416 };
30417
30418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30420 if (SWIG_arg_fail(1)) SWIG_fail;
30421 result = (int) ((arg1)->w);
30422
30423 {
30424 resultobj = SWIG_From_int((int)(result));
30425 }
30426 return resultobj;
30427 fail:
30428 return NULL;
30429 }
30430
30431
30432 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj;
30434 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30435 int arg2 ;
30436 PyObject * obj0 = 0 ;
30437 PyObject * obj1 = 0 ;
30438 char *kwnames[] = {
30439 (char *) "self",(char *) "h", NULL
30440 };
30441
30442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30444 if (SWIG_arg_fail(1)) SWIG_fail;
30445 {
30446 arg2 = (int)(SWIG_As_int(obj1));
30447 if (SWIG_arg_fail(2)) SWIG_fail;
30448 }
30449 if (arg1) (arg1)->h = arg2;
30450
30451 Py_INCREF(Py_None); resultobj = Py_None;
30452 return resultobj;
30453 fail:
30454 return NULL;
30455 }
30456
30457
30458 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30459 PyObject *resultobj;
30460 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30461 int result;
30462 PyObject * obj0 = 0 ;
30463 char *kwnames[] = {
30464 (char *) "self", NULL
30465 };
30466
30467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30469 if (SWIG_arg_fail(1)) SWIG_fail;
30470 result = (int) ((arg1)->h);
30471
30472 {
30473 resultobj = SWIG_From_int((int)(result));
30474 }
30475 return resultobj;
30476 fail:
30477 return NULL;
30478 }
30479
30480
30481 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30482 PyObject *resultobj;
30483 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30484 int arg2 ;
30485 PyObject * obj0 = 0 ;
30486 PyObject * obj1 = 0 ;
30487 char *kwnames[] = {
30488 (char *) "self",(char *) "bpp", NULL
30489 };
30490
30491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30493 if (SWIG_arg_fail(1)) SWIG_fail;
30494 {
30495 arg2 = (int)(SWIG_As_int(obj1));
30496 if (SWIG_arg_fail(2)) SWIG_fail;
30497 }
30498 if (arg1) (arg1)->bpp = arg2;
30499
30500 Py_INCREF(Py_None); resultobj = Py_None;
30501 return resultobj;
30502 fail:
30503 return NULL;
30504 }
30505
30506
30507 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30508 PyObject *resultobj;
30509 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30510 int result;
30511 PyObject * obj0 = 0 ;
30512 char *kwnames[] = {
30513 (char *) "self", NULL
30514 };
30515
30516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30518 if (SWIG_arg_fail(1)) SWIG_fail;
30519 result = (int) ((arg1)->bpp);
30520
30521 {
30522 resultobj = SWIG_From_int((int)(result));
30523 }
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30531 PyObject *resultobj;
30532 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30533 int arg2 ;
30534 PyObject * obj0 = 0 ;
30535 PyObject * obj1 = 0 ;
30536 char *kwnames[] = {
30537 (char *) "self",(char *) "refresh", NULL
30538 };
30539
30540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30542 if (SWIG_arg_fail(1)) SWIG_fail;
30543 {
30544 arg2 = (int)(SWIG_As_int(obj1));
30545 if (SWIG_arg_fail(2)) SWIG_fail;
30546 }
30547 if (arg1) (arg1)->refresh = arg2;
30548
30549 Py_INCREF(Py_None); resultobj = Py_None;
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30557 PyObject *resultobj;
30558 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30559 int result;
30560 PyObject * obj0 = 0 ;
30561 char *kwnames[] = {
30562 (char *) "self", NULL
30563 };
30564
30565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30567 if (SWIG_arg_fail(1)) SWIG_fail;
30568 result = (int) ((arg1)->refresh);
30569
30570 {
30571 resultobj = SWIG_From_int((int)(result));
30572 }
30573 return resultobj;
30574 fail:
30575 return NULL;
30576 }
30577
30578
30579 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30580 PyObject *obj;
30581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30582 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30583 Py_INCREF(obj);
30584 return Py_BuildValue((char *)"");
30585 }
30586 static int _wrap_DefaultVideoMode_set(PyObject *) {
30587 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30588 return 1;
30589 }
30590
30591
30592 static PyObject *_wrap_DefaultVideoMode_get(void) {
30593 PyObject *pyobj;
30594
30595 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30596 return pyobj;
30597 }
30598
30599
30600 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30601 PyObject *resultobj;
30602 size_t arg1 = (size_t) 0 ;
30603 wxDisplay *result;
30604 PyObject * obj0 = 0 ;
30605 char *kwnames[] = {
30606 (char *) "index", NULL
30607 };
30608
30609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30610 if (obj0) {
30611 {
30612 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30613 if (SWIG_arg_fail(1)) SWIG_fail;
30614 }
30615 }
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 result = (wxDisplay *)new wxDisplay(arg1);
30619
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30624 return resultobj;
30625 fail:
30626 return NULL;
30627 }
30628
30629
30630 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30631 PyObject *resultobj;
30632 wxDisplay *arg1 = (wxDisplay *) 0 ;
30633 PyObject * obj0 = 0 ;
30634 char *kwnames[] = {
30635 (char *) "self", NULL
30636 };
30637
30638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30640 if (SWIG_arg_fail(1)) SWIG_fail;
30641 {
30642 PyThreadState* __tstate = wxPyBeginAllowThreads();
30643 delete arg1;
30644
30645 wxPyEndAllowThreads(__tstate);
30646 if (PyErr_Occurred()) SWIG_fail;
30647 }
30648 Py_INCREF(Py_None); resultobj = Py_None;
30649 return resultobj;
30650 fail:
30651 return NULL;
30652 }
30653
30654
30655 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30656 PyObject *resultobj;
30657 size_t result;
30658 char *kwnames[] = {
30659 NULL
30660 };
30661
30662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 result = (size_t)wxDisplay::GetCount();
30666
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 {
30671 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30672 }
30673 return resultobj;
30674 fail:
30675 return NULL;
30676 }
30677
30678
30679 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30680 PyObject *resultobj;
30681 wxPoint *arg1 = 0 ;
30682 int result;
30683 wxPoint temp1 ;
30684 PyObject * obj0 = 0 ;
30685 char *kwnames[] = {
30686 (char *) "pt", NULL
30687 };
30688
30689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30690 {
30691 arg1 = &temp1;
30692 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30693 }
30694 {
30695 PyThreadState* __tstate = wxPyBeginAllowThreads();
30696 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30697
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 {
30702 resultobj = SWIG_From_int((int)(result));
30703 }
30704 return resultobj;
30705 fail:
30706 return NULL;
30707 }
30708
30709
30710 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30711 PyObject *resultobj;
30712 wxWindow *arg1 = (wxWindow *) 0 ;
30713 int result;
30714 PyObject * obj0 = 0 ;
30715 char *kwnames[] = {
30716 (char *) "window", NULL
30717 };
30718
30719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30721 if (SWIG_arg_fail(1)) SWIG_fail;
30722 {
30723 PyThreadState* __tstate = wxPyBeginAllowThreads();
30724 result = (int)Display_GetFromWindow(arg1);
30725
30726 wxPyEndAllowThreads(__tstate);
30727 if (PyErr_Occurred()) SWIG_fail;
30728 }
30729 {
30730 resultobj = SWIG_From_int((int)(result));
30731 }
30732 return resultobj;
30733 fail:
30734 return NULL;
30735 }
30736
30737
30738 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30739 PyObject *resultobj;
30740 wxDisplay *arg1 = (wxDisplay *) 0 ;
30741 bool result;
30742 PyObject * obj0 = 0 ;
30743 char *kwnames[] = {
30744 (char *) "self", NULL
30745 };
30746
30747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30749 if (SWIG_arg_fail(1)) SWIG_fail;
30750 {
30751 PyThreadState* __tstate = wxPyBeginAllowThreads();
30752 result = (bool)((wxDisplay const *)arg1)->IsOk();
30753
30754 wxPyEndAllowThreads(__tstate);
30755 if (PyErr_Occurred()) SWIG_fail;
30756 }
30757 {
30758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30759 }
30760 return resultobj;
30761 fail:
30762 return NULL;
30763 }
30764
30765
30766 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30767 PyObject *resultobj;
30768 wxDisplay *arg1 = (wxDisplay *) 0 ;
30769 wxRect result;
30770 PyObject * obj0 = 0 ;
30771 char *kwnames[] = {
30772 (char *) "self", NULL
30773 };
30774
30775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30777 if (SWIG_arg_fail(1)) SWIG_fail;
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = ((wxDisplay const *)arg1)->GetGeometry();
30781
30782 wxPyEndAllowThreads(__tstate);
30783 if (PyErr_Occurred()) SWIG_fail;
30784 }
30785 {
30786 wxRect * resultptr;
30787 resultptr = new wxRect((wxRect &)(result));
30788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30789 }
30790 return resultobj;
30791 fail:
30792 return NULL;
30793 }
30794
30795
30796 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30797 PyObject *resultobj;
30798 wxDisplay *arg1 = (wxDisplay *) 0 ;
30799 wxString result;
30800 PyObject * obj0 = 0 ;
30801 char *kwnames[] = {
30802 (char *) "self", NULL
30803 };
30804
30805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30807 if (SWIG_arg_fail(1)) SWIG_fail;
30808 {
30809 PyThreadState* __tstate = wxPyBeginAllowThreads();
30810 result = ((wxDisplay const *)arg1)->GetName();
30811
30812 wxPyEndAllowThreads(__tstate);
30813 if (PyErr_Occurred()) SWIG_fail;
30814 }
30815 {
30816 #if wxUSE_UNICODE
30817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30818 #else
30819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30820 #endif
30821 }
30822 return resultobj;
30823 fail:
30824 return NULL;
30825 }
30826
30827
30828 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30829 PyObject *resultobj;
30830 wxDisplay *arg1 = (wxDisplay *) 0 ;
30831 bool result;
30832 PyObject * obj0 = 0 ;
30833 char *kwnames[] = {
30834 (char *) "self", NULL
30835 };
30836
30837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30839 if (SWIG_arg_fail(1)) SWIG_fail;
30840 {
30841 PyThreadState* __tstate = wxPyBeginAllowThreads();
30842 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30843
30844 wxPyEndAllowThreads(__tstate);
30845 if (PyErr_Occurred()) SWIG_fail;
30846 }
30847 {
30848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30849 }
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30857 PyObject *resultobj;
30858 wxDisplay *arg1 = (wxDisplay *) 0 ;
30859 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30860 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30861 PyObject *result;
30862 PyObject * obj0 = 0 ;
30863 PyObject * obj1 = 0 ;
30864 char *kwnames[] = {
30865 (char *) "self",(char *) "mode", NULL
30866 };
30867
30868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30870 if (SWIG_arg_fail(1)) SWIG_fail;
30871 if (obj1) {
30872 {
30873 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30874 if (SWIG_arg_fail(2)) SWIG_fail;
30875 if (arg2 == NULL) {
30876 SWIG_null_ref("wxVideoMode");
30877 }
30878 if (SWIG_arg_fail(2)) SWIG_fail;
30879 }
30880 }
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30884
30885 wxPyEndAllowThreads(__tstate);
30886 if (PyErr_Occurred()) SWIG_fail;
30887 }
30888 resultobj = result;
30889 return resultobj;
30890 fail:
30891 return NULL;
30892 }
30893
30894
30895 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30896 PyObject *resultobj;
30897 wxDisplay *arg1 = (wxDisplay *) 0 ;
30898 wxVideoMode result;
30899 PyObject * obj0 = 0 ;
30900 char *kwnames[] = {
30901 (char *) "self", NULL
30902 };
30903
30904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30906 if (SWIG_arg_fail(1)) SWIG_fail;
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30910
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 {
30915 wxVideoMode * resultptr;
30916 resultptr = new wxVideoMode((wxVideoMode &)(result));
30917 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30918 }
30919 return resultobj;
30920 fail:
30921 return NULL;
30922 }
30923
30924
30925 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30926 PyObject *resultobj;
30927 wxDisplay *arg1 = (wxDisplay *) 0 ;
30928 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30929 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30930 bool result;
30931 PyObject * obj0 = 0 ;
30932 PyObject * obj1 = 0 ;
30933 char *kwnames[] = {
30934 (char *) "self",(char *) "mode", NULL
30935 };
30936
30937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30939 if (SWIG_arg_fail(1)) SWIG_fail;
30940 if (obj1) {
30941 {
30942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30943 if (SWIG_arg_fail(2)) SWIG_fail;
30944 if (arg2 == NULL) {
30945 SWIG_null_ref("wxVideoMode");
30946 }
30947 if (SWIG_arg_fail(2)) SWIG_fail;
30948 }
30949 }
30950 {
30951 PyThreadState* __tstate = wxPyBeginAllowThreads();
30952 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30953
30954 wxPyEndAllowThreads(__tstate);
30955 if (PyErr_Occurred()) SWIG_fail;
30956 }
30957 {
30958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30959 }
30960 return resultobj;
30961 fail:
30962 return NULL;
30963 }
30964
30965
30966 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30967 PyObject *resultobj;
30968 wxDisplay *arg1 = (wxDisplay *) 0 ;
30969 PyObject * obj0 = 0 ;
30970 char *kwnames[] = {
30971 (char *) "self", NULL
30972 };
30973
30974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30976 if (SWIG_arg_fail(1)) SWIG_fail;
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 (arg1)->ResetMode();
30980
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 Py_INCREF(Py_None); resultobj = Py_None;
30985 return resultobj;
30986 fail:
30987 return NULL;
30988 }
30989
30990
30991 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30992 PyObject *obj;
30993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30994 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30995 Py_INCREF(obj);
30996 return Py_BuildValue((char *)"");
30997 }
30998 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30999 PyObject *resultobj;
31000 wxStandardPaths *result;
31001 char *kwnames[] = {
31002 NULL
31003 };
31004
31005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 result = (wxStandardPaths *)StandardPaths_Get();
31009
31010 wxPyEndAllowThreads(__tstate);
31011 if (PyErr_Occurred()) SWIG_fail;
31012 }
31013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj;
31022 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31023 wxString result;
31024 PyObject * obj0 = 0 ;
31025 char *kwnames[] = {
31026 (char *) "self", NULL
31027 };
31028
31029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31031 if (SWIG_arg_fail(1)) SWIG_fail;
31032 {
31033 PyThreadState* __tstate = wxPyBeginAllowThreads();
31034 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31035
31036 wxPyEndAllowThreads(__tstate);
31037 if (PyErr_Occurred()) SWIG_fail;
31038 }
31039 {
31040 #if wxUSE_UNICODE
31041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31042 #else
31043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31044 #endif
31045 }
31046 return resultobj;
31047 fail:
31048 return NULL;
31049 }
31050
31051
31052 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31053 PyObject *resultobj;
31054 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31055 wxString result;
31056 PyObject * obj0 = 0 ;
31057 char *kwnames[] = {
31058 (char *) "self", NULL
31059 };
31060
31061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31063 if (SWIG_arg_fail(1)) SWIG_fail;
31064 {
31065 PyThreadState* __tstate = wxPyBeginAllowThreads();
31066 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31067
31068 wxPyEndAllowThreads(__tstate);
31069 if (PyErr_Occurred()) SWIG_fail;
31070 }
31071 {
31072 #if wxUSE_UNICODE
31073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31074 #else
31075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31076 #endif
31077 }
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj;
31086 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31087 wxString result;
31088 PyObject * obj0 = 0 ;
31089 char *kwnames[] = {
31090 (char *) "self", NULL
31091 };
31092
31093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31095 if (SWIG_arg_fail(1)) SWIG_fail;
31096 {
31097 PyThreadState* __tstate = wxPyBeginAllowThreads();
31098 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31099
31100 wxPyEndAllowThreads(__tstate);
31101 if (PyErr_Occurred()) SWIG_fail;
31102 }
31103 {
31104 #if wxUSE_UNICODE
31105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31106 #else
31107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31108 #endif
31109 }
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj;
31118 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31119 wxString result;
31120 PyObject * obj0 = 0 ;
31121 char *kwnames[] = {
31122 (char *) "self", NULL
31123 };
31124
31125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31127 if (SWIG_arg_fail(1)) SWIG_fail;
31128 {
31129 PyThreadState* __tstate = wxPyBeginAllowThreads();
31130 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31131
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 {
31136 #if wxUSE_UNICODE
31137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31138 #else
31139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31140 #endif
31141 }
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj;
31150 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31151 wxString result;
31152 PyObject * obj0 = 0 ;
31153 char *kwnames[] = {
31154 (char *) "self", NULL
31155 };
31156
31157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31159 if (SWIG_arg_fail(1)) SWIG_fail;
31160 {
31161 PyThreadState* __tstate = wxPyBeginAllowThreads();
31162 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31163
31164 wxPyEndAllowThreads(__tstate);
31165 if (PyErr_Occurred()) SWIG_fail;
31166 }
31167 {
31168 #if wxUSE_UNICODE
31169 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31170 #else
31171 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31172 #endif
31173 }
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31181 PyObject *resultobj;
31182 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31183 wxString result;
31184 PyObject * obj0 = 0 ;
31185 char *kwnames[] = {
31186 (char *) "self", NULL
31187 };
31188
31189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31191 if (SWIG_arg_fail(1)) SWIG_fail;
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31195
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 {
31200 #if wxUSE_UNICODE
31201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31202 #else
31203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31204 #endif
31205 }
31206 return resultobj;
31207 fail:
31208 return NULL;
31209 }
31210
31211
31212 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31213 PyObject *resultobj;
31214 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31215 wxString result;
31216 PyObject * obj0 = 0 ;
31217 char *kwnames[] = {
31218 (char *) "self", NULL
31219 };
31220
31221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31223 if (SWIG_arg_fail(1)) SWIG_fail;
31224 {
31225 PyThreadState* __tstate = wxPyBeginAllowThreads();
31226 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31227
31228 wxPyEndAllowThreads(__tstate);
31229 if (PyErr_Occurred()) SWIG_fail;
31230 }
31231 {
31232 #if wxUSE_UNICODE
31233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31234 #else
31235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31236 #endif
31237 }
31238 return resultobj;
31239 fail:
31240 return NULL;
31241 }
31242
31243
31244 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31245 PyObject *resultobj;
31246 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31247 wxString *arg2 = 0 ;
31248 bool temp2 = false ;
31249 PyObject * obj0 = 0 ;
31250 PyObject * obj1 = 0 ;
31251 char *kwnames[] = {
31252 (char *) "self",(char *) "prefix", NULL
31253 };
31254
31255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31257 if (SWIG_arg_fail(1)) SWIG_fail;
31258 {
31259 arg2 = wxString_in_helper(obj1);
31260 if (arg2 == NULL) SWIG_fail;
31261 temp2 = true;
31262 }
31263 {
31264 PyThreadState* __tstate = wxPyBeginAllowThreads();
31265 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31266
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 Py_INCREF(Py_None); resultobj = Py_None;
31271 {
31272 if (temp2)
31273 delete arg2;
31274 }
31275 return resultobj;
31276 fail:
31277 {
31278 if (temp2)
31279 delete arg2;
31280 }
31281 return NULL;
31282 }
31283
31284
31285 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj;
31287 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31288 wxString result;
31289 PyObject * obj0 = 0 ;
31290 char *kwnames[] = {
31291 (char *) "self", NULL
31292 };
31293
31294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31296 if (SWIG_arg_fail(1)) SWIG_fail;
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31300
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 {
31305 #if wxUSE_UNICODE
31306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31307 #else
31308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31309 #endif
31310 }
31311 return resultobj;
31312 fail:
31313 return NULL;
31314 }
31315
31316
31317 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31318 PyObject *obj;
31319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31320 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31321 Py_INCREF(obj);
31322 return Py_BuildValue((char *)"");
31323 }
31324 static PyMethodDef SwigMethods[] = {
31325 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31332 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31339 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31403 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31411 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31429 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31432 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31435 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31438 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31444 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31458 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31464 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31470 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31473 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31487 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31490 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31491 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31494 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31521 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31523 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31525 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31527 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31534 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31540 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31554 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31558 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31561 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31578 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31586 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31633 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31651 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31661 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31677 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31693 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31707 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"ArtProvider_GetSize", (PyCFunction) _wrap_ArtProvider_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31717 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31760 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31763 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31766 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31770 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31863 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31864 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31865 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31866 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31883 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31928 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31962 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31970 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31971 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31976 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31985 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31992 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31995 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31998 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32003 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32006 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32010 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32013 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32017 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32018 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32022 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32026 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32028 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32038 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32049 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32057 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32065 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32079 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32083 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32101 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32115 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32126 { NULL, NULL, 0, NULL }
32127 };
32128
32129
32130 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32131
32132 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32133 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32134 }
32135 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32136 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32137 }
32138 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32139 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32140 }
32141 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32142 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32143 }
32144 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32145 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32146 }
32147 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32148 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32149 }
32150 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32151 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32152 }
32153 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32154 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32155 }
32156 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32157 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32158 }
32159 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32160 return (void *)((wxEvent *) ((wxPyEvent *) x));
32161 }
32162 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32163 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32164 }
32165 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32166 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32167 }
32168 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32169 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32170 }
32171 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32172 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32173 }
32174 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32175 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32176 }
32177 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32178 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32179 }
32180 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32181 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32182 }
32183 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32184 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32185 }
32186 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32187 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32188 }
32189 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32190 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32191 }
32192 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32193 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32194 }
32195 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32196 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32197 }
32198 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32199 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32200 }
32201 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32202 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32203 }
32204 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32205 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32206 }
32207 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32208 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32209 }
32210 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32211 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32212 }
32213 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32214 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32215 }
32216 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32217 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32218 }
32219 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32220 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32221 }
32222 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32223 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32224 }
32225 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32226 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32227 }
32228 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32229 return (void *)((wxEvent *) ((wxShowEvent *) x));
32230 }
32231 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32232 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32233 }
32234 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32235 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32236 }
32237 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32238 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32239 }
32240 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32241 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32242 }
32243 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32244 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32245 }
32246 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32247 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32248 }
32249 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32250 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32251 }
32252 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32253 return (void *)((wxConfigBase *) ((wxConfig *) x));
32254 }
32255 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32256 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32257 }
32258 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32259 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32260 }
32261 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32262 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32263 }
32264 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32265 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32266 }
32267 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32268 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32269 }
32270 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32271 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32272 }
32273 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32274 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32275 }
32276 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32277 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32278 }
32279 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32280 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32281 }
32282 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32283 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32284 }
32285 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32286 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32287 }
32288 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32289 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32290 }
32291 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32292 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32293 }
32294 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32295 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32296 }
32297 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32298 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32299 }
32300 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32301 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32302 }
32303 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32304 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32305 }
32306 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32307 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32308 }
32309 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32310 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32311 }
32312 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32313 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32314 }
32315 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32316 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32317 }
32318 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32319 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32320 }
32321 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32322 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32323 }
32324 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32325 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32326 }
32327 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32328 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32329 }
32330 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32331 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32332 }
32333 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32334 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32335 }
32336 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32337 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32338 }
32339 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32340 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32341 }
32342 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32343 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32344 }
32345 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32346 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32347 }
32348 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32349 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32350 }
32351 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32352 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32353 }
32354 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32355 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32356 }
32357 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32358 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32359 }
32360 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32361 return (void *)((wxObject *) ((wxSizerItem *) x));
32362 }
32363 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32364 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32365 }
32366 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32367 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32368 }
32369 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32370 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32371 }
32372 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32373 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32374 }
32375 static void *_p_wxSizerTo_p_wxObject(void *x) {
32376 return (void *)((wxObject *) ((wxSizer *) x));
32377 }
32378 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32379 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32380 }
32381 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32382 return (void *)((wxObject *) ((wxFileHistory *) x));
32383 }
32384 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32385 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32386 }
32387 static void *_p_wxEventTo_p_wxObject(void *x) {
32388 return (void *)((wxObject *) ((wxEvent *) x));
32389 }
32390 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32391 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32392 }
32393 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32394 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32395 }
32396 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32397 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32398 }
32399 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32400 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32401 }
32402 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32403 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32404 }
32405 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32406 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32407 }
32408 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32409 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32410 }
32411 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32412 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32413 }
32414 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32415 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32416 }
32417 static void *_p_wxControlTo_p_wxObject(void *x) {
32418 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32419 }
32420 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32421 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32422 }
32423 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32424 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32425 }
32426 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32427 return (void *)((wxObject *) ((wxFSFile *) x));
32428 }
32429 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32430 return (void *)((wxObject *) ((wxClipboard *) x));
32431 }
32432 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32433 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32434 }
32435 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32436 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32437 }
32438 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32439 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32440 }
32441 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32442 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32443 }
32444 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32445 return (void *)((wxObject *) ((wxToolTip *) x));
32446 }
32447 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32448 return (void *)((wxObject *) ((wxMenuItem *) x));
32449 }
32450 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32451 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32452 }
32453 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32454 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32455 }
32456 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32457 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32458 }
32459 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32460 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32461 }
32462 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32463 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32464 }
32465 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32466 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32467 }
32468 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32469 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32470 }
32471 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32472 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32473 }
32474 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32475 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32476 }
32477 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32478 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32479 }
32480 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32481 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32482 }
32483 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32484 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32485 }
32486 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32487 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32488 }
32489 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32490 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32491 }
32492 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32493 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32494 }
32495 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32496 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32497 }
32498 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32499 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32500 }
32501 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32502 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32503 }
32504 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32505 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32506 }
32507 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32508 return (void *)((wxObject *) ((wxImageHandler *) x));
32509 }
32510 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32511 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32512 }
32513 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32514 return (void *)((wxObject *) ((wxEvtHandler *) x));
32515 }
32516 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32517 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32518 }
32519 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32520 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32521 }
32522 static void *_p_wxImageTo_p_wxObject(void *x) {
32523 return (void *)((wxObject *) ((wxImage *) x));
32524 }
32525 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32526 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32527 }
32528 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32529 return (void *)((wxObject *) ((wxSystemOptions *) x));
32530 }
32531 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32532 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32533 }
32534 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32535 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32536 }
32537 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32538 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32539 }
32540 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32541 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32542 }
32543 static void *_p_wxWindowTo_p_wxObject(void *x) {
32544 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32545 }
32546 static void *_p_wxMenuTo_p_wxObject(void *x) {
32547 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32548 }
32549 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32550 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32551 }
32552 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32553 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32554 }
32555 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32556 return (void *)((wxObject *) ((wxFileSystem *) x));
32557 }
32558 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32559 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32560 }
32561 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32562 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32563 }
32564 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32565 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32566 }
32567 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32568 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32569 }
32570 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32571 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32572 }
32573 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32574 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32575 }
32576 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32577 return (void *)((wxObject *) ((wxBusyInfo *) x));
32578 }
32579 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32580 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32581 }
32582 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32583 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32584 }
32585 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32586 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32587 }
32588 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32589 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32590 }
32591 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32592 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32593 }
32594 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32595 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32596 }
32597 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32598 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32599 }
32600 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32601 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32602 }
32603 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32604 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32605 }
32606 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32607 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32608 }
32609 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32610 return (void *)((wxLog *) ((wxLogStderr *) x));
32611 }
32612 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32613 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32614 }
32615 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32616 return (void *)((wxLog *) ((wxLogWindow *) x));
32617 }
32618 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32619 return (void *)((wxLog *) ((wxLogChain *) x));
32620 }
32621 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32622 return (void *)((wxLog *) ((wxLogGui *) x));
32623 }
32624 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32625 return (void *)((wxLog *) ((wxPyLog *) x));
32626 }
32627 static void *_p_wxControlTo_p_wxWindow(void *x) {
32628 return (void *)((wxWindow *) ((wxControl *) x));
32629 }
32630 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32631 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32632 }
32633 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32634 return (void *)((wxWindow *) ((wxMenuBar *) x));
32635 }
32636 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32637 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32638 }
32639 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32640 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32641 }
32642 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}};
32643 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}};
32644 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}};
32645 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}};
32646 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}};
32647 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32648 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}};
32649 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}};
32650 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}};
32651 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}};
32652 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}};
32653 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}};
32654 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}};
32655 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}};
32656 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}};
32657 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}};
32658 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}};
32659 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}};
32660 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}};
32661 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}};
32662 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}};
32663 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32664 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}};
32665 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}};
32666 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}};
32667 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}};
32668 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}};
32669 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}};
32670 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}};
32671 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}};
32672 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}};
32673 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}};
32674 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}};
32675 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}};
32676 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}};
32677 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}};
32678 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}};
32679 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}};
32680 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}};
32681 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}};
32682 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}};
32683 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}};
32684 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}};
32685 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}};
32686 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}};
32687 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}};
32688 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}};
32689 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}};
32690 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}};
32691 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}};
32692 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}};
32693 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}};
32694 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}};
32695 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}};
32696 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}};
32697 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}};
32698 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}};
32699 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}};
32700 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}};
32701 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}};
32702 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}};
32703 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}};
32704 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}};
32705 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}};
32706 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}};
32707 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}};
32708 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}};
32709 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}};
32710 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}};
32711 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}};
32712 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32713 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}};
32714 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}};
32715 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}};
32716 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}};
32717 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}};
32718 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}};
32719 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}};
32720 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}};
32721 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}};
32722 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}};
32723 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}};
32724 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}};
32725 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}};
32726 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}};
32727 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}};
32728 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}};
32729 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}};
32730 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}};
32731 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}};
32732 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}};
32733 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}};
32734 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}};
32735 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}};
32736 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}};
32737 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}};
32738
32739 static swig_type_info *swig_types_initial[] = {
32740 _swigt__p_wxLogChain,
32741 _swigt__p_wxMutexGuiLocker,
32742 _swigt__p_wxFileHistory,
32743 _swigt__p_wxLog,
32744 _swigt__p_wxMenu,
32745 _swigt__p_wxEvent,
32746 _swigt__p_wxDateTime__TimeZone,
32747 _swigt__p_wxConfigBase,
32748 _swigt__p_wxDisplay,
32749 _swigt__p_wxFileType,
32750 _swigt__p_wxLogGui,
32751 _swigt__p_wxFont,
32752 _swigt__p_wxDataFormat,
32753 _swigt__p_wxTimerEvent,
32754 _swigt__p_wxCaret,
32755 _swigt__ptrdiff_t,
32756 _swigt__std__ptrdiff_t,
32757 _swigt__p_int,
32758 _swigt__p_wxSize,
32759 _swigt__p_wxClipboard,
32760 _swigt__p_wxStopWatch,
32761 _swigt__p_wxDC,
32762 _swigt__p_wxClipboardLocker,
32763 _swigt__p_wxIcon,
32764 _swigt__p_wxLogStderr,
32765 _swigt__p_wxLogTextCtrl,
32766 _swigt__p_wxTextCtrl,
32767 _swigt__p_wxBusyCursor,
32768 _swigt__p_wxBitmapDataObject,
32769 _swigt__p_wxTextDataObject,
32770 _swigt__p_wxDataObject,
32771 _swigt__p_wxPyTextDataObject,
32772 _swigt__p_wxPyBitmapDataObject,
32773 _swigt__p_wxFileDataObject,
32774 _swigt__p_wxCustomDataObject,
32775 _swigt__p_wxURLDataObject,
32776 _swigt__p_wxMetafileDataObject,
32777 _swigt__p_wxSound,
32778 _swigt__p_wxTimerRunner,
32779 _swigt__p_wxLogWindow,
32780 _swigt__p_wxTimeSpan,
32781 _swigt__p_wxArrayString,
32782 _swigt__p_wxWindowDisabler,
32783 _swigt__p_form_ops_t,
32784 _swigt__p_wxToolTip,
32785 _swigt__p_wxDataObjectComposite,
32786 _swigt__p_wxSystemSettings,
32787 _swigt__p_wxFileConfig,
32788 _swigt__p_wxVideoMode,
32789 _swigt__p_wxDataObjectSimple,
32790 _swigt__p_wxPyDataObjectSimple,
32791 _swigt__p_wxDuplexMode,
32792 _swigt__p_wxEvtHandler,
32793 _swigt__p_wxRect,
32794 _swigt__p_char,
32795 _swigt__p_wxSingleInstanceChecker,
32796 _swigt__p_wxStandardPaths,
32797 _swigt__p_wxFileTypeInfo,
32798 _swigt__p_wxFrame,
32799 _swigt__p_wxTimer,
32800 _swigt__p_wxPaperSize,
32801 _swigt__p_wxMimeTypesManager,
32802 _swigt__p_wxPyArtProvider,
32803 _swigt__p_wxPyTipProvider,
32804 _swigt__p_wxTipProvider,
32805 _swigt__p_wxJoystick,
32806 _swigt__p_wxSystemOptions,
32807 _swigt__p_wxPoint,
32808 _swigt__p_wxJoystickEvent,
32809 _swigt__p_wxCursor,
32810 _swigt__p_wxObject,
32811 _swigt__p_wxOutputStream,
32812 _swigt__p_wxDateTime,
32813 _swigt__p_wxPyDropSource,
32814 _swigt__p_unsigned_long,
32815 _swigt__p_wxKillError,
32816 _swigt__p_wxWindow,
32817 _swigt__p_wxString,
32818 _swigt__p_wxPyProcess,
32819 _swigt__p_wxBitmap,
32820 _swigt__p_wxConfig,
32821 _swigt__unsigned_int,
32822 _swigt__p_unsigned_int,
32823 _swigt__p_unsigned_char,
32824 _swigt__p_wxChar,
32825 _swigt__p_wxBusyInfo,
32826 _swigt__p_wxPyDropTarget,
32827 _swigt__p_wxPyTextDropTarget,
32828 _swigt__p_wxPyFileDropTarget,
32829 _swigt__p_wxProcessEvent,
32830 _swigt__p_wxPyLog,
32831 _swigt__p_wxLogNull,
32832 _swigt__p_wxColour,
32833 _swigt__p_wxPyTimer,
32834 _swigt__p_wxConfigPathChanger,
32835 _swigt__p_wxDateSpan,
32836 0
32837 };
32838
32839
32840 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32841
32842 static swig_const_info swig_const_table[] = {
32843 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32844 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32845 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32846 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32847 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32848 {0, 0, 0, 0.0, 0, 0}};
32849
32850 #ifdef __cplusplus
32851 }
32852 #endif
32853
32854
32855 #ifdef __cplusplus
32856 extern "C" {
32857 #endif
32858
32859 /* Python-specific SWIG API */
32860 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32861 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32862 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32863
32864 /* -----------------------------------------------------------------------------
32865 * global variable support code.
32866 * ----------------------------------------------------------------------------- */
32867
32868 typedef struct swig_globalvar {
32869 char *name; /* Name of global variable */
32870 PyObject *(*get_attr)(); /* Return the current value */
32871 int (*set_attr)(PyObject *); /* Set the value */
32872 struct swig_globalvar *next;
32873 } swig_globalvar;
32874
32875 typedef struct swig_varlinkobject {
32876 PyObject_HEAD
32877 swig_globalvar *vars;
32878 } swig_varlinkobject;
32879
32880 static PyObject *
32881 swig_varlink_repr(swig_varlinkobject *v) {
32882 v = v;
32883 return PyString_FromString("<Swig global variables>");
32884 }
32885
32886 static int
32887 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32888 swig_globalvar *var;
32889 flags = flags;
32890 fprintf(fp,"Swig global variables { ");
32891 for (var = v->vars; var; var=var->next) {
32892 fprintf(fp,"%s", var->name);
32893 if (var->next) fprintf(fp,", ");
32894 }
32895 fprintf(fp," }\n");
32896 return 0;
32897 }
32898
32899 static PyObject *
32900 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32901 swig_globalvar *var = v->vars;
32902 while (var) {
32903 if (strcmp(var->name,n) == 0) {
32904 return (*var->get_attr)();
32905 }
32906 var = var->next;
32907 }
32908 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32909 return NULL;
32910 }
32911
32912 static int
32913 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32914 swig_globalvar *var = v->vars;
32915 while (var) {
32916 if (strcmp(var->name,n) == 0) {
32917 return (*var->set_attr)(p);
32918 }
32919 var = var->next;
32920 }
32921 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32922 return 1;
32923 }
32924
32925 static PyTypeObject varlinktype = {
32926 PyObject_HEAD_INIT(0)
32927 0, /* Number of items in variable part (ob_size) */
32928 (char *)"swigvarlink", /* Type name (tp_name) */
32929 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32930 0, /* Itemsize (tp_itemsize) */
32931 0, /* Deallocator (tp_dealloc) */
32932 (printfunc) swig_varlink_print, /* Print (tp_print) */
32933 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32934 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32935 0, /* tp_compare */
32936 (reprfunc) swig_varlink_repr, /* tp_repr */
32937 0, /* tp_as_number */
32938 0, /* tp_as_sequence */
32939 0, /* tp_as_mapping */
32940 0, /* tp_hash */
32941 0, /* tp_call */
32942 0, /* tp_str */
32943 0, /* tp_getattro */
32944 0, /* tp_setattro */
32945 0, /* tp_as_buffer */
32946 0, /* tp_flags */
32947 0, /* tp_doc */
32948 #if PY_VERSION_HEX >= 0x02000000
32949 0, /* tp_traverse */
32950 0, /* tp_clear */
32951 #endif
32952 #if PY_VERSION_HEX >= 0x02010000
32953 0, /* tp_richcompare */
32954 0, /* tp_weaklistoffset */
32955 #endif
32956 #if PY_VERSION_HEX >= 0x02020000
32957 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32958 #endif
32959 #if PY_VERSION_HEX >= 0x02030000
32960 0, /* tp_del */
32961 #endif
32962 #ifdef COUNT_ALLOCS
32963 0,0,0,0 /* tp_alloc -> tp_next */
32964 #endif
32965 };
32966
32967 /* Create a variable linking object for use later */
32968 static PyObject *
32969 SWIG_Python_newvarlink(void) {
32970 swig_varlinkobject *result = 0;
32971 result = PyMem_NEW(swig_varlinkobject,1);
32972 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32973 result->ob_type = &varlinktype;
32974 result->vars = 0;
32975 result->ob_refcnt = 0;
32976 Py_XINCREF((PyObject *) result);
32977 return ((PyObject*) result);
32978 }
32979
32980 static void
32981 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32982 swig_varlinkobject *v;
32983 swig_globalvar *gv;
32984 v= (swig_varlinkobject *) p;
32985 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32986 gv->name = (char *) malloc(strlen(name)+1);
32987 strcpy(gv->name,name);
32988 gv->get_attr = get_attr;
32989 gv->set_attr = set_attr;
32990 gv->next = v->vars;
32991 v->vars = gv;
32992 }
32993
32994 /* -----------------------------------------------------------------------------
32995 * constants/methods manipulation
32996 * ----------------------------------------------------------------------------- */
32997
32998 /* Install Constants */
32999 static void
33000 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33001 PyObject *obj = 0;
33002 size_t i;
33003 for (i = 0; constants[i].type; i++) {
33004 switch(constants[i].type) {
33005 case SWIG_PY_INT:
33006 obj = PyInt_FromLong(constants[i].lvalue);
33007 break;
33008 case SWIG_PY_FLOAT:
33009 obj = PyFloat_FromDouble(constants[i].dvalue);
33010 break;
33011 case SWIG_PY_STRING:
33012 if (constants[i].pvalue) {
33013 obj = PyString_FromString((char *) constants[i].pvalue);
33014 } else {
33015 Py_INCREF(Py_None);
33016 obj = Py_None;
33017 }
33018 break;
33019 case SWIG_PY_POINTER:
33020 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33021 break;
33022 case SWIG_PY_BINARY:
33023 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33024 break;
33025 default:
33026 obj = 0;
33027 break;
33028 }
33029 if (obj) {
33030 PyDict_SetItemString(d,constants[i].name,obj);
33031 Py_DECREF(obj);
33032 }
33033 }
33034 }
33035
33036 /* -----------------------------------------------------------------------------*/
33037 /* Fix SwigMethods to carry the callback ptrs when needed */
33038 /* -----------------------------------------------------------------------------*/
33039
33040 static void
33041 SWIG_Python_FixMethods(PyMethodDef *methods,
33042 swig_const_info *const_table,
33043 swig_type_info **types,
33044 swig_type_info **types_initial) {
33045 size_t i;
33046 for (i = 0; methods[i].ml_name; ++i) {
33047 char *c = methods[i].ml_doc;
33048 if (c && (c = strstr(c, "swig_ptr: "))) {
33049 int j;
33050 swig_const_info *ci = 0;
33051 char *name = c + 10;
33052 for (j = 0; const_table[j].type; j++) {
33053 if (strncmp(const_table[j].name, name,
33054 strlen(const_table[j].name)) == 0) {
33055 ci = &(const_table[j]);
33056 break;
33057 }
33058 }
33059 if (ci) {
33060 size_t shift = (ci->ptype) - types;
33061 swig_type_info *ty = types_initial[shift];
33062 size_t ldoc = (c - methods[i].ml_doc);
33063 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33064 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33065 char *buff = ndoc;
33066 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33067 strncpy(buff, methods[i].ml_doc, ldoc);
33068 buff += ldoc;
33069 strncpy(buff, "swig_ptr: ", 10);
33070 buff += 10;
33071 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33072 methods[i].ml_doc = ndoc;
33073 }
33074 }
33075 }
33076 }
33077
33078 /* -----------------------------------------------------------------------------*
33079 * Initialize type list
33080 * -----------------------------------------------------------------------------*/
33081
33082 #if PY_MAJOR_VERSION < 2
33083 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33084 is copied out of Python/modsupport.c in python version 2.3.4 */
33085 static int
33086 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33087 {
33088 PyObject *dict;
33089 if (!PyModule_Check(m)) {
33090 PyErr_SetString(PyExc_TypeError,
33091 "PyModule_AddObject() needs module as first arg");
33092 return -1;
33093 }
33094 if (!o) {
33095 PyErr_SetString(PyExc_TypeError,
33096 "PyModule_AddObject() needs non-NULL value");
33097 return -1;
33098 }
33099
33100 dict = PyModule_GetDict(m);
33101 if (dict == NULL) {
33102 /* Internal error -- modules must have a dict! */
33103 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33104 PyModule_GetName(m));
33105 return -1;
33106 }
33107 if (PyDict_SetItemString(dict, name, o))
33108 return -1;
33109 Py_DECREF(o);
33110 return 0;
33111 }
33112 #endif
33113
33114 static swig_type_info **
33115 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33116 static PyMethodDef swig_empty_runtime_method_table[] = {
33117 {
33118 NULL, NULL, 0, NULL
33119 }
33120 };/* Sentinel */
33121
33122 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33123 swig_empty_runtime_method_table);
33124 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33125 if (pointer && module) {
33126 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33127 }
33128 return type_list_handle;
33129 }
33130
33131 static swig_type_info **
33132 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33133 swig_type_info **type_pointer;
33134
33135 /* first check if module already created */
33136 type_pointer = SWIG_Python_GetTypeListHandle();
33137 if (type_pointer) {
33138 return type_pointer;
33139 } else {
33140 /* create a new module and variable */
33141 return SWIG_Python_SetTypeListHandle(type_list_handle);
33142 }
33143 }
33144
33145 #ifdef __cplusplus
33146 }
33147 #endif
33148
33149 /* -----------------------------------------------------------------------------*
33150 * Partial Init method
33151 * -----------------------------------------------------------------------------*/
33152
33153 #ifdef SWIG_LINK_RUNTIME
33154 #ifdef __cplusplus
33155 extern "C"
33156 #endif
33157 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33158 #endif
33159
33160 #ifdef __cplusplus
33161 extern "C"
33162 #endif
33163 SWIGEXPORT(void) SWIG_init(void) {
33164 static PyObject *SWIG_globals = 0;
33165 static int typeinit = 0;
33166 PyObject *m, *d;
33167 int i;
33168 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33169
33170 /* Fix SwigMethods to carry the callback ptrs when needed */
33171 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33172
33173 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33174 d = PyModule_GetDict(m);
33175
33176 if (!typeinit) {
33177 #ifdef SWIG_LINK_RUNTIME
33178 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33179 #else
33180 # ifndef SWIG_STATIC_RUNTIME
33181 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33182 # endif
33183 #endif
33184 for (i = 0; swig_types_initial[i]; i++) {
33185 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33186 }
33187 typeinit = 1;
33188 }
33189 SWIG_InstallConstants(d,swig_const_table);
33190
33191 {
33192 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33193 }
33194 {
33195 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33196 }
33197 {
33198 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33199 }
33200 {
33201 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33202 }
33203 {
33204 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33205 }
33206 {
33207 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33208 }
33209 {
33210 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33256 }
33257 {
33258 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33259 }
33260 {
33261 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33262 }
33263 {
33264 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33265 }
33266 {
33267 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33268 }
33269 {
33270 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33277 }
33278 {
33279 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33286 }
33287 {
33288 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33289 }
33290 {
33291 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33292 }
33293 {
33294 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33295 }
33296 {
33297 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33298 }
33299 {
33300 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33301 }
33302 {
33303 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33304 }
33305 {
33306 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33307 }
33308 {
33309 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33310 }
33311 {
33312 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33313 }
33314 {
33315 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33316 }
33317 {
33318 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33319 }
33320 {
33321 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33322 }
33323 {
33324 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33325 }
33326 {
33327 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33328 }
33329 {
33330 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33331 }
33332 {
33333 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33334 }
33335 {
33336 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33355 }
33356 {
33357 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33358 }
33359 {
33360 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33463 }
33464 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33465 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33466 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33467 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33468 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33469 {
33470 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33480 }
33481 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33482
33483 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33484
33485 {
33486 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33517 }
33518 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33519 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33520 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33521 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33522 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33523 {
33524 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33546 }
33547 {
33548 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33615 }
33616 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33617 {
33618 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33631 }
33632
33633 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33634
33635 {
33636 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33655 }
33656 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33657 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33658 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33659 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33660 {
33661 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33683 }
33684 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33685 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33686 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33687 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33688 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33689 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33690 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33691 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33692 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33693 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33694 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33695 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33696 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33697 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33698 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33699 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33700 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33701 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33702 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33703 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33704 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33705 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33706 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33707 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33708 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33709 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33710 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33711 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33712 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33713 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33714 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33715 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33716 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33717 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33718 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33719 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33720 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33721 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33722 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33723 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33724 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33725 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33726 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33727 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33728 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33729 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33730 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33731 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33732 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33733 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33734 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33735 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33736 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33737 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33738 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33739 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33740
33741 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33742
33743 {
33744 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33769 }
33770 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33771 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33772 {
33773 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33780 }
33781 {
33782 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33783 }
33784 {
33785 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33789 }
33790 {
33791 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33792 }
33793 {
33794 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33795 }
33796 {
33797 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33798 }
33799 {
33800 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33801 }
33802 {
33803 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33804 }
33805 {
33806 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33807 }
33808 {
33809 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33822 }
33823 {
33824 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33825 }
33826 {
33827 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33831 }
33832 {
33833 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33834 }
33835 {
33836 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33837 }
33838 {
33839 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33840 }
33841 {
33842 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33843 }
33844 {
33845 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33888 }
33889 {
33890 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34236 }
34237 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34238 {
34239 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34246 }
34247 {
34248 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34249 }
34250 {
34251 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34252 }
34253 {
34254 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34255 }
34256 {
34257 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34258 }
34259 {
34260 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34261 }
34262 {
34263 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34264 }
34265 {
34266 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34267 }
34268 {
34269 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34297 }
34298 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34299 {
34300 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34334 }
34335
34336 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34337 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34338 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34339 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34340
34341 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34342 }
34343
wxWidgets (Impactor)