]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added a test to check how exception handling works with Win32 SEH; corrected copyright
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxDC swig_types[22]
1364 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1365 #define SWIGTYPE_p_wxIcon swig_types[24]
1366 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1367 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1369 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1370 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1379 #define SWIGTYPE_p_wxSound swig_types[38]
1380 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1381 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1382 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1383 #define SWIGTYPE_p_wxArrayString swig_types[42]
1384 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxToolTip swig_types[45]
1387 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1390 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1391 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1393 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1394 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1395 #define SWIGTYPE_p_wxRect swig_types[54]
1396 #define SWIGTYPE_p_char swig_types[55]
1397 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1398 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1399 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1400 #define SWIGTYPE_p_wxFrame swig_types[59]
1401 #define SWIGTYPE_p_wxTimer swig_types[60]
1402 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1403 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1404 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1405 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1407 #define SWIGTYPE_p_wxJoystick swig_types[66]
1408 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1409 #define SWIGTYPE_p_wxPoint swig_types[68]
1410 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1411 #define SWIGTYPE_p_wxCursor swig_types[70]
1412 #define SWIGTYPE_p_wxObject swig_types[71]
1413 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1414 #define SWIGTYPE_p_wxDateTime swig_types[73]
1415 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1416 #define SWIGTYPE_p_unsigned_long swig_types[75]
1417 #define SWIGTYPE_p_wxKillError swig_types[76]
1418 #define SWIGTYPE_p_wxWindow swig_types[77]
1419 #define SWIGTYPE_p_wxString swig_types[78]
1420 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1421 #define SWIGTYPE_p_wxBitmap swig_types[80]
1422 #define SWIGTYPE_p_wxConfig swig_types[81]
1423 #define SWIGTYPE_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_int swig_types[83]
1425 #define SWIGTYPE_p_unsigned_char swig_types[84]
1426 #define SWIGTYPE_p_wxChar swig_types[85]
1427 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1428 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1431 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPyLog swig_types[91]
1433 #define SWIGTYPE_p_wxLogNull swig_types[92]
1434 #define SWIGTYPE_p_wxColour swig_types[93]
1435 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1436 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1437 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1438 static swig_type_info *swig_types[98];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444 @(target):= _misc_.so
1445 ------------------------------------------------*/
1446 #define SWIG_init init_misc_
1447
1448 #define SWIG_name "_misc_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452 #include "wx/wxPython/pyistream.h"
1453
1454 static const wxString wxPyEmptyString(wxEmptyString);
1455
1456
1457
1458 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1459 #define SWIG_From_int PyInt_FromLong
1460 /*@@*/
1461
1462
1463 #include <limits.h>
1464
1465
1466 SWIGINTERN int
1467 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1468 const char *errmsg)
1469 {
1470 if (value < min_value) {
1471 if (errmsg) {
1472 PyErr_Format(PyExc_OverflowError,
1473 "value %ld is less than '%s' minimum %ld",
1474 value, errmsg, min_value);
1475 }
1476 return 0;
1477 } else if (value > max_value) {
1478 if (errmsg) {
1479 PyErr_Format(PyExc_OverflowError,
1480 "value %ld is greater than '%s' maximum %ld",
1481 value, errmsg, max_value);
1482 }
1483 return 0;
1484 }
1485 return 1;
1486 }
1487
1488
1489 SWIGINTERN int
1490 SWIG_AsVal_long(PyObject* obj, long* val)
1491 {
1492 if (PyNumber_Check(obj)) {
1493 if (val) *val = PyInt_AsLong(obj);
1494 return 1;
1495 }
1496 else {
1497 SWIG_type_error("number", obj);
1498 }
1499 return 0;
1500 }
1501
1502
1503 #if INT_MAX != LONG_MAX
1504 SWIGINTERN int
1505 SWIG_AsVal_int(PyObject *obj, int *val)
1506 {
1507 const char* errmsg = val ? "int" : (char*)0;
1508 long v;
1509 if (SWIG_AsVal_long(obj, &v)) {
1510 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1511 if (val) *val = (int)(v);
1512 return 1;
1513 } else {
1514 return 0;
1515 }
1516 } else {
1517 PyErr_Clear();
1518 }
1519 if (val) {
1520 SWIG_type_error(errmsg, obj);
1521 }
1522 return 0;
1523 }
1524 #else
1525 SWIGINTERNSHORT int
1526 SWIG_AsVal_int(PyObject *obj, int *val)
1527 {
1528 return SWIG_AsVal_long(obj,(long*)val);
1529 }
1530 #endif
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_As_int(PyObject* obj)
1535 {
1536 int v;
1537 if (!SWIG_AsVal_int(obj, &v)) {
1538 /*
1539 this is needed to make valgrind/purify happier.
1540 */
1541 memset((void*)&v, 0, sizeof(int));
1542 }
1543 return v;
1544 }
1545
1546
1547 SWIGINTERNSHORT int
1548 SWIG_Check_int(PyObject* obj)
1549 {
1550 return SWIG_AsVal_int(obj, (int*)0);
1551 }
1552
1553 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1554
1555 #include <wx/stockitem.h>
1556
1557 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1558 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1559 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1560
1561 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1562 #define SWIG_From_long PyInt_FromLong
1563 /*@@*/
1564
1565
1566 SWIGINTERNSHORT long
1567 SWIG_As_long(PyObject* obj)
1568 {
1569 long v;
1570 if (!SWIG_AsVal_long(obj, &v)) {
1571 /*
1572 this is needed to make valgrind/purify happier.
1573 */
1574 memset((void*)&v, 0, sizeof(long));
1575 }
1576 return v;
1577 }
1578
1579
1580 SWIGINTERNSHORT int
1581 SWIG_Check_long(PyObject* obj)
1582 {
1583 return SWIG_AsVal_long(obj, (long*)0);
1584 }
1585
1586
1587 SWIGINTERN int
1588 SWIG_AsVal_bool(PyObject *obj, bool *val)
1589 {
1590 if (obj == Py_True) {
1591 if (val) *val = true;
1592 return 1;
1593 }
1594 if (obj == Py_False) {
1595 if (val) *val = false;
1596 return 1;
1597 }
1598 int res = 0;
1599 if (SWIG_AsVal_int(obj, &res)) {
1600 if (val) *val = res ? true : false;
1601 return 1;
1602 } else {
1603 PyErr_Clear();
1604 }
1605 if (val) {
1606 SWIG_type_error("bool", obj);
1607 }
1608 return 0;
1609 }
1610
1611
1612 SWIGINTERNSHORT bool
1613 SWIG_As_bool(PyObject* obj)
1614 {
1615 bool v;
1616 if (!SWIG_AsVal_bool(obj, &v)) {
1617 /*
1618 this is needed to make valgrind/purify happier.
1619 */
1620 memset((void*)&v, 0, sizeof(bool));
1621 }
1622 return v;
1623 }
1624
1625
1626 SWIGINTERNSHORT int
1627 SWIG_Check_bool(PyObject* obj)
1628 {
1629 return SWIG_AsVal_bool(obj, (bool*)0);
1630 }
1631
1632
1633 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1634 PyObject* o2;
1635 PyObject* o3;
1636
1637 if (!target) {
1638 target = o;
1639 } else if (target == Py_None) {
1640 Py_DECREF(Py_None);
1641 target = o;
1642 } else {
1643 if (!PyTuple_Check(target)) {
1644 o2 = target;
1645 target = PyTuple_New(1);
1646 PyTuple_SetItem(target, 0, o2);
1647 }
1648 o3 = PyTuple_New(1);
1649 PyTuple_SetItem(o3, 0, o);
1650
1651 o2 = target;
1652 target = PySequence_Concat(o2, o3);
1653 Py_DECREF(o2);
1654 Py_DECREF(o3);
1655 }
1656 return target;
1657 }
1658
1659
1660
1661 SWIGINTERN int
1662 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1663 {
1664 long v = 0;
1665 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1666 SWIG_type_error("unsigned number", obj);
1667 }
1668 else if (val)
1669 *val = (unsigned long)v;
1670 return 1;
1671 }
1672
1673
1674 SWIGINTERNSHORT unsigned long
1675 SWIG_As_unsigned_SS_long(PyObject* obj)
1676 {
1677 unsigned long v;
1678 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1679 /*
1680 this is needed to make valgrind/purify happier.
1681 */
1682 memset((void*)&v, 0, sizeof(unsigned long));
1683 }
1684 return v;
1685 }
1686
1687
1688 SWIGINTERNSHORT int
1689 SWIG_Check_unsigned_SS_long(PyObject* obj)
1690 {
1691 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1692 }
1693
1694
1695 SWIGINTERNSHORT PyObject*
1696 SWIG_From_unsigned_SS_long(unsigned long value)
1697 {
1698 return (value > LONG_MAX) ?
1699 PyLong_FromUnsignedLong(value)
1700 : PyInt_FromLong((long)(value));
1701 }
1702
1703
1704 bool wxThread_IsMain() {
1705 #ifdef WXP_WITH_THREAD
1706 return wxThread::IsMain();
1707 #else
1708 return true;
1709 #endif
1710 }
1711
1712
1713 int wxCaret_GetBlinkTime() {
1714 return wxCaret::GetBlinkTime();
1715 }
1716
1717 void wxCaret_SetBlinkTime(int milliseconds) {
1718 wxCaret::SetBlinkTime(milliseconds);
1719 }
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 void wxDrawWindowOnDC(wxWindow* window, const wxDC& dc, int method)
1733 {
1734 #ifdef __WXMSW__
1735
1736 switch (method)
1737 {
1738 case 1:
1739 // This one only partially works. Appears to be an undocumented
1740 // "standard" convention that not all widgets adhear to. For
1741 // example, for some widgets backgrounds or non-client areas may
1742 // not be painted.
1743 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1744 break;
1745
1746 case 2:
1747 // This one works much better, except for on XP. On Win2k nearly
1748 // all widgets and their children are captured correctly[**]. On
1749 // XP with Themes activated most native widgets draw only
1750 // partially, if at all. Without themes it works just like on
1751 // Win2k.
1752 //
1753 // ** For example the radio buttons in a wxRadioBox are not its
1754 // children by default, but you can capture it via the panel
1755 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1756 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1757 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1758 PRF_ERASEBKGND | PRF_OWNED );
1759 break;
1760
1761 case 3:
1762 // This one is only defined in the latest SDK and is only
1763 // available on XP. MSDN says it is similar to sending WM_PRINT
1764 // so I expect that it will work similar to the above. Since it
1765 // is avaialble only on XP, it can't be compiled like this and
1766 // will have to be loaded dynamically.
1767 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1768
1769 // fall through
1770
1771 case 4:
1772 // Use PrintWindow if available, or fallback to WM_PRINT
1773 // otherwise. Unfortunately using PrintWindow is even worse than
1774 // WM_PRINT. For most native widgets nothing is drawn to the dc
1775 // at all, with or without Themes.
1776 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1777 static bool s_triedToLoad = false;
1778 static PrintWindow_t pfnPrintWindow = NULL;
1779 if ( !s_triedToLoad )
1780 {
1781
1782 s_triedToLoad = true;
1783 wxDynamicLibrary dllUser32(_T("user32.dll"));
1784 if ( dllUser32.IsLoaded() )
1785 {
1786 wxLogNull nolog; // Don't report errors here
1787 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1788 }
1789 }
1790 if (pfnPrintWindow)
1791 {
1792 printf("Using PrintWindow\n");
1793 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1794 }
1795 else
1796 {
1797 printf("Using WM_PRINT\n");
1798 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1799 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN | PRF_ERASEBKGND | PRF_OWNED );
1800 }
1801 }
1802 #endif
1803 }
1804
1805
1806
1807 #include <wx/tipdlg.h>
1808
1809
1810 class wxPyTipProvider : public wxTipProvider {
1811 public:
1812 wxPyTipProvider(size_t currentTip)
1813 : wxTipProvider(currentTip) {}
1814
1815 DEC_PYCALLBACK_STRING__pure(GetTip);
1816 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1817 PYPRIVATE;
1818 };
1819
1820 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1821 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1822
1823
1824 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1825
1826 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1827
1828 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1829 : wxTimer(owner, id)
1830 {
1831 if (owner == NULL) SetOwner(this);
1832 }
1833
1834
1835 void wxPyTimer::Notify() {
1836 bool found;
1837 bool blocked = wxPyBeginBlockThreads();
1838 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1839 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1840 wxPyEndBlockThreads(blocked);
1841 if (! found)
1842 wxTimer::Notify();
1843 }
1844 void wxPyTimer::base_Notify() {
1845 wxTimer::Notify();
1846 }
1847
1848
1849
1850 SWIGINTERN PyObject *
1851 SWIG_FromCharPtr(const char* cptr)
1852 {
1853 if (cptr) {
1854 size_t size = strlen(cptr);
1855 if (size > INT_MAX) {
1856 return SWIG_NewPointerObj((char*)(cptr),
1857 SWIG_TypeQuery("char *"), 0);
1858 } else {
1859 if (size != 0) {
1860 return PyString_FromStringAndSize(cptr, size);
1861 } else {
1862 return PyString_FromString(cptr);
1863 }
1864 }
1865 }
1866 Py_INCREF(Py_None);
1867 return Py_None;
1868 }
1869
1870
1871 SWIGINTERNSHORT int
1872 SWIG_CheckUnsignedLongInRange(unsigned long value,
1873 unsigned long max_value,
1874 const char *errmsg)
1875 {
1876 if (value > max_value) {
1877 if (errmsg) {
1878 PyErr_Format(PyExc_OverflowError,
1879 "value %lu is greater than '%s' minimum %lu",
1880 value, errmsg, max_value);
1881 }
1882 return 0;
1883 }
1884 return 1;
1885 }
1886
1887
1888 #if UINT_MAX != ULONG_MAX
1889 SWIGINTERN int
1890 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1891 {
1892 const char* errmsg = val ? "unsigned int" : (char*)0;
1893 unsigned long v;
1894 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1895 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1896 if (val) *val = (unsigned int)(v);
1897 return 1;
1898 }
1899 } else {
1900 PyErr_Clear();
1901 }
1902 if (val) {
1903 SWIG_type_error(errmsg, obj);
1904 }
1905 return 0;
1906 }
1907 #else
1908 SWIGINTERNSHORT unsigned int
1909 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1910 {
1911 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1912 }
1913 #endif
1914
1915
1916 SWIGINTERNSHORT unsigned int
1917 SWIG_As_unsigned_SS_int(PyObject* obj)
1918 {
1919 unsigned int v;
1920 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1921 /*
1922 this is needed to make valgrind/purify happier.
1923 */
1924 memset((void*)&v, 0, sizeof(unsigned int));
1925 }
1926 return v;
1927 }
1928
1929
1930 SWIGINTERNSHORT int
1931 SWIG_Check_unsigned_SS_int(PyObject* obj)
1932 {
1933 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1934 }
1935
1936 static wxString Log_TimeStamp(){
1937 wxString msg;
1938 wxLog::TimeStamp(&msg);
1939 return msg;
1940 }
1941 static void wxLog_Destroy(wxLog *self){ delete self; }
1942 // Make somce wrappers that double any % signs so they are 'escaped'
1943 void wxPyLogFatalError(const wxString& msg)
1944 {
1945 wxString m(msg);
1946 m.Replace(wxT("%"), wxT("%%"));
1947 wxLogFatalError(m);
1948 }
1949
1950 void wxPyLogError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogError(m);
1955 }
1956
1957 void wxPyLogWarning(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogWarning(m);
1962 }
1963
1964 void wxPyLogMessage(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogMessage(m);
1969 }
1970
1971 void wxPyLogInfo(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogInfo(m);
1976 }
1977
1978 void wxPyLogDebug(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogDebug(m);
1983 }
1984
1985 void wxPyLogVerbose(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogVerbose(m);
1990 }
1991
1992 void wxPyLogStatus(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogStatus(m);
1997 }
1998
1999 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(pFrame, m);
2004 }
2005
2006 void wxPyLogSysError(const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogSysError(m);
2011 }
2012
2013 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogGeneric(level, m);
2018 }
2019
2020 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogTrace(mask, m);
2025 }
2026
2027 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034
2035
2036 // A wxLog class that can be derived from in wxPython
2037 class wxPyLog : public wxLog {
2038 public:
2039 wxPyLog() : wxLog() {}
2040
2041 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2042 bool found;
2043 bool blocked = wxPyBeginBlockThreads();
2044 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2045 PyObject* s = wx2PyString(szString);
2046 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2047 Py_DECREF(s);
2048 }
2049 wxPyEndBlockThreads(blocked);
2050 if (! found)
2051 wxLog::DoLog(level, szString, t);
2052 }
2053
2054 virtual void DoLogString(const wxChar *szString, time_t t) {
2055 bool found;
2056 bool blocked = wxPyBeginBlockThreads();
2057 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2058 PyObject* s = wx2PyString(szString);
2059 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2060 Py_DECREF(s);
2061 }
2062 wxPyEndBlockThreads(blocked);
2063 if (! found)
2064 wxLog::DoLogString(szString, t);
2065 }
2066
2067 PYPRIVATE;
2068 };
2069
2070
2071
2072
2073 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2074
2075
2076 #include <wx/joystick.h>
2077
2078
2079 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2080 // A C++ stub class for wxJoystick for platforms that don't have it.
2081 class wxJoystick : public wxObject {
2082 public:
2083 wxJoystick(int joystick = wxJOYSTICK1) {
2084 bool blocked = wxPyBeginBlockThreads();
2085 PyErr_SetString(PyExc_NotImplementedError,
2086 "wxJoystick is not available on this platform.");
2087 wxPyEndBlockThreads(blocked);
2088 }
2089 wxPoint GetPosition() { return wxPoint(-1,-1); }
2090 int GetZPosition() { return -1; }
2091 int GetButtonState() { return -1; }
2092 int GetPOVPosition() { return -1; }
2093 int GetPOVCTSPosition() { return -1; }
2094 int GetRudderPosition() { return -1; }
2095 int GetUPosition() { return -1; }
2096 int GetVPosition() { return -1; }
2097 int GetMovementThreshold() { return -1; }
2098 void SetMovementThreshold(int threshold) {}
2099
2100 bool IsOk(void) { return false; }
2101 int GetNumberJoysticks() { return -1; }
2102 int GetManufacturerId() { return -1; }
2103 int GetProductId() { return -1; }
2104 wxString GetProductName() { return wxEmptyString; }
2105 int GetXMin() { return -1; }
2106 int GetYMin() { return -1; }
2107 int GetZMin() { return -1; }
2108 int GetXMax() { return -1; }
2109 int GetYMax() { return -1; }
2110 int GetZMax() { return -1; }
2111 int GetNumberButtons() { return -1; }
2112 int GetNumberAxes() { return -1; }
2113 int GetMaxButtons() { return -1; }
2114 int GetMaxAxes() { return -1; }
2115 int GetPollingMin() { return -1; }
2116 int GetPollingMax() { return -1; }
2117 int GetRudderMin() { return -1; }
2118 int GetRudderMax() { return -1; }
2119 int GetUMin() { return -1; }
2120 int GetUMax() { return -1; }
2121 int GetVMin() { return -1; }
2122 int GetVMax() { return -1; }
2123
2124 bool HasRudder() { return false; }
2125 bool HasZ() { return false; }
2126 bool HasU() { return false; }
2127 bool HasV() { return false; }
2128 bool HasPOV() { return false; }
2129 bool HasPOV4Dir() { return false; }
2130 bool HasPOVCTS() { return false; }
2131
2132 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2133 bool ReleaseCapture() { return false; }
2134 };
2135 #endif
2136
2137
2138 #include <wx/sound.h>
2139
2140
2141 #if !wxUSE_SOUND
2142 // A C++ stub class for wxWave for platforms that don't have it.
2143 class wxSound : public wxObject
2144 {
2145 public:
2146 wxSound() {
2147 bool blocked = wxPyBeginBlockThreads();
2148 PyErr_SetString(PyExc_NotImplementedError,
2149 "wxSound is not available on this platform.");
2150 wxPyEndBlockThreads(blocked);
2151 }
2152 wxSound(const wxString&/*, bool*/) {
2153 bool blocked = wxPyBeginBlockThreads();
2154 PyErr_SetString(PyExc_NotImplementedError,
2155 "wxSound is not available on this platform.");
2156 wxPyEndBlockThreads(blocked);
2157 }
2158 wxSound(int, const wxByte*) {
2159 bool blocked = wxPyBeginBlockThreads();
2160 PyErr_SetString(PyExc_NotImplementedError,
2161 "wxSound is not available on this platform.");
2162 wxPyEndBlockThreads(blocked);
2163 }
2164
2165 ~wxSound() {};
2166
2167 bool Create(const wxString&/*, bool*/) { return false; }
2168 bool Create(int, const wxByte*) { return false; };
2169 bool IsOk() { return false; };
2170 bool Play(unsigned) const { return false; }
2171 static bool Play(const wxString&, unsigned) { return false; }
2172 static void Stop() {}
2173 };
2174
2175 #endif
2176
2177 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2178 if (fileName.Length() == 0)
2179 return new wxSound;
2180 else
2181 return new wxSound(fileName);
2182 }
2183 static wxSound *new_wxSound(PyObject *data){
2184 unsigned char* buffer; int size;
2185 wxSound *sound = NULL;
2186
2187 bool blocked = wxPyBeginBlockThreads();
2188 if (!PyArg_Parse(data, "t#", &buffer, &size))
2189 goto done;
2190 sound = new wxSound(size, buffer);
2191 done:
2192 wxPyEndBlockThreads(blocked);
2193 return sound;
2194 }
2195 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2196 #ifndef __WXMAC__
2197 unsigned char* buffer;
2198 int size;
2199 bool rv = false;
2200
2201 bool blocked = wxPyBeginBlockThreads();
2202 if (!PyArg_Parse(data, "t#", &buffer, &size))
2203 goto done;
2204 rv = self->Create(size, buffer);
2205 done:
2206 wxPyEndBlockThreads(blocked);
2207 return rv;
2208 #else
2209 bool blocked = wxPyBeginBlockThreads();
2210 PyErr_SetString(PyExc_NotImplementedError,
2211 "Create from data is not available on this platform.");
2212 wxPyEndBlockThreads(blocked);
2213 return false;
2214 #endif
2215 }
2216 static void Sound_Stop(){ wxPyRaiseNotImplemented(); }
2217
2218 #include <wx/mimetype.h>
2219
2220 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2221 wxString str;
2222 if (self->GetMimeType(&str))
2223 return wx2PyString(str);
2224 else
2225 RETURN_NONE();
2226 }
2227 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2228 wxArrayString arr;
2229 if (self->GetMimeTypes(arr))
2230 return wxArrayString2PyList_helper(arr);
2231 else
2232 RETURN_NONE();
2233 }
2234 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2235 wxArrayString arr;
2236 if (self->GetExtensions(arr))
2237 return wxArrayString2PyList_helper(arr);
2238 else
2239 RETURN_NONE();
2240 }
2241 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2242 wxIconLocation loc;
2243 if (self->GetIcon(&loc))
2244 return new wxIcon(loc);
2245 else
2246 return NULL;
2247 }
2248 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2249 wxIconLocation loc;
2250 if (self->GetIcon(&loc)) {
2251 wxString iconFile = loc.GetFileName();
2252 int iconIndex = -1;
2253
2254
2255
2256 // Make a tuple and put the values in it
2257 bool blocked = wxPyBeginBlockThreads();
2258 PyObject* tuple = PyTuple_New(3);
2259 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2260 wxT("wxIcon"), true));
2261 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2262 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2263 wxPyEndBlockThreads(blocked);
2264 return tuple;
2265 }
2266 else
2267 RETURN_NONE();
2268 }
2269 static PyObject *wxFileType_GetDescription(wxFileType *self){
2270 wxString str;
2271 if (self->GetDescription(&str))
2272 return wx2PyString(str);
2273 else
2274 RETURN_NONE();
2275 }
2276 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2277 wxString str;
2278 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2279 return wx2PyString(str);
2280 else
2281 RETURN_NONE();
2282 }
2283 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2284 wxString str;
2285 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2286 return wx2PyString(str);
2287 else
2288 RETURN_NONE();
2289 }
2290 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2291 wxArrayString verbs;
2292 wxArrayString commands;
2293 if (self->GetAllCommands(&verbs, &commands,
2294 wxFileType::MessageParameters(filename, mimetype))) {
2295 bool blocked = wxPyBeginBlockThreads();
2296 PyObject* tuple = PyTuple_New(2);
2297 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2298 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2299 wxPyEndBlockThreads(blocked);
2300 return tuple;
2301 }
2302 else
2303 RETURN_NONE();
2304 }
2305 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2306 return wxFileType::ExpandCommand(command,
2307 wxFileType::MessageParameters(filename, mimetype));
2308 }
2309 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2310 wxArrayString arr;
2311 self->EnumAllFileTypes(arr);
2312 return wxArrayString2PyList_helper(arr);
2313 }
2314
2315 #include <wx/artprov.h>
2316
2317 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2318 static const wxString wxPyART_MENU(wxART_MENU);
2319 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2320 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2321 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2322 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2323 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2324 static const wxString wxPyART_OTHER(wxART_OTHER);
2325 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2326 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2327 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2328 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2329 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2330 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2331 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2332 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2333 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2334 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2335 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2336 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2337 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2338 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2339 static const wxString wxPyART_PRINT(wxART_PRINT);
2340 static const wxString wxPyART_HELP(wxART_HELP);
2341 static const wxString wxPyART_TIP(wxART_TIP);
2342 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2343 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2344 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2345 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2346 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2347 static const wxString wxPyART_CDROM(wxART_CDROM);
2348 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2349 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2350 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2351 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2352 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2353 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2354 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2355 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2356 static const wxString wxPyART_ERROR(wxART_ERROR);
2357 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2358 static const wxString wxPyART_WARNING(wxART_WARNING);
2359 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2360 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2361 // Python aware wxArtProvider
2362 class wxPyArtProvider : public wxArtProvider {
2363 public:
2364
2365 virtual wxBitmap CreateBitmap(const wxArtID& id,
2366 const wxArtClient& client,
2367 const wxSize& size) {
2368 wxBitmap rval = wxNullBitmap;
2369 bool blocked = wxPyBeginBlockThreads();
2370 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2371 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2372 PyObject* ro;
2373 wxBitmap* ptr;
2374 PyObject* s1, *s2;
2375 s1 = wx2PyString(id);
2376 s2 = wx2PyString(client);
2377 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2378 Py_DECREF(so);
2379 Py_DECREF(s1);
2380 Py_DECREF(s2);
2381 if (ro) {
2382 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2383 rval = *ptr;
2384 Py_DECREF(ro);
2385 }
2386 }
2387 wxPyEndBlockThreads(blocked);
2388 return rval;
2389 }
2390
2391 PYPRIVATE;
2392 };
2393
2394 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2395
2396
2397
2398 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2399 PyObject* ret = PyTuple_New(3);
2400 if (ret) {
2401 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2402 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2403 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2404 }
2405 return ret;
2406 }
2407
2408 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2409 bool cont;
2410 long index = 0;
2411 wxString value;
2412
2413 cont = self->GetFirstGroup(value, index);
2414 return __EnumerationHelper(cont, value, index);
2415 }
2416 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2417 bool cont;
2418 wxString value;
2419
2420 cont = self->GetNextGroup(value, index);
2421 return __EnumerationHelper(cont, value, index);
2422 }
2423 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2424 bool cont;
2425 long index = 0;
2426 wxString value;
2427
2428 cont = self->GetFirstEntry(value, index);
2429 return __EnumerationHelper(cont, value, index);
2430 }
2431 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2432 bool cont;
2433 wxString value;
2434
2435 cont = self->GetNextEntry(value, index);
2436 return __EnumerationHelper(cont, value, index);
2437 }
2438 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2439 long rv;
2440 self->Read(key, &rv, defaultVal);
2441 return rv;
2442 }
2443
2444 SWIGINTERN int
2445 SWIG_AsVal_double(PyObject *obj, double* val)
2446 {
2447 if (PyNumber_Check(obj)) {
2448 if (val) *val = PyFloat_AsDouble(obj);
2449 return 1;
2450 }
2451 else {
2452 SWIG_type_error("number", obj);
2453 }
2454 return 0;
2455 }
2456
2457
2458 SWIGINTERNSHORT double
2459 SWIG_As_double(PyObject* obj)
2460 {
2461 double v;
2462 if (!SWIG_AsVal_double(obj, &v)) {
2463 /*
2464 this is needed to make valgrind/purify happier.
2465 */
2466 memset((void*)&v, 0, sizeof(double));
2467 }
2468 return v;
2469 }
2470
2471
2472 SWIGINTERNSHORT int
2473 SWIG_Check_double(PyObject* obj)
2474 {
2475 return SWIG_AsVal_double(obj, (double*)0);
2476 }
2477
2478 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2479 double rv;
2480 self->Read(key, &rv, defaultVal);
2481 return rv;
2482 }
2483
2484 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2485 #define SWIG_From_double PyFloat_FromDouble
2486 /*@@*/
2487
2488 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2489 bool rv;
2490 self->Read(key, &rv, defaultVal);
2491 return rv;
2492 }
2493
2494 #include <wx/datetime.h>
2495
2496
2497 static const wxString wxPyDateFormatStr(wxT("%c"));
2498 static const wxString wxPyTimeSpanFormatStr(wxT("%H:%M:%S"));
2499
2500 #define LOCAL_TZ wxDateTime::Local
2501
2502
2503 #if UINT_MAX < LONG_MAX
2504 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2505 #define SWIG_From_unsigned_SS_int SWIG_From_long
2506 /*@@*/
2507 #else
2508 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2509 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2510 /*@@*/
2511 #endif
2512
2513 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2514 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2515 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2516 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2517 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2518 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2519 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2520 return (*self < *other);
2521 }
2522 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2523 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2524 return (*self <= *other);
2525 }
2526 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2527 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2528 return (*self > *other);
2529 }
2530 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2531 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2532 return (*self >= *other);
2533 }
2534 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2535 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2536 return (*self == *other);
2537 }
2538 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2539 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2540 return (*self != *other);
2541 }
2542 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2543 const wxChar* rv;
2544 const wxChar* _date = date;
2545 rv = self->ParseRfc822Date(_date);
2546 if (rv == NULL) return -1;
2547 return rv - _date;
2548 }
2549 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDateFormatStr,wxDateTime const &dateDef=wxDefaultDateTime){
2550 const wxChar* rv;
2551 const wxChar* _date = date;
2552 rv = self->ParseFormat(_date, format, dateDef);
2553 if (rv == NULL) return -1;
2554 return rv - _date;
2555 }
2556 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2557 const wxChar* rv;
2558 const wxChar* _datetime = datetime;
2559 rv = self->ParseDateTime(_datetime);
2560 if (rv == NULL) return -1;
2561 return rv - _datetime;
2562 }
2563 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2564 const wxChar* rv;
2565 const wxChar* _date = date;
2566 rv = self->ParseDate(_date);
2567 if (rv == NULL) return -1;
2568 return rv - _date;
2569 }
2570 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2571 const wxChar* rv;
2572 const wxChar* _time = time;
2573 rv = self->ParseTime(_time);
2574 if (rv == NULL) return -1;
2575 return rv - _time;
2576 }
2577 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2578 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2579 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2580 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2581 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2582 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2583 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2584 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2585 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2586 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2587 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2588 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2589 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2590 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2591 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2592 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2593
2594 #include <wx/dataobj.h>
2595
2596 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2597 size_t count = self->GetFormatCount(dir);
2598 wxDataFormat* formats = new wxDataFormat[count];
2599 self->GetAllFormats(formats, dir);
2600
2601 bool blocked = wxPyBeginBlockThreads();
2602 PyObject* list = PyList_New(count);
2603 for (size_t i=0; i<count; i++) {
2604 wxDataFormat* format = new wxDataFormat(formats[i]);
2605 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2606 PyList_Append(list, obj);
2607 Py_DECREF(obj);
2608 }
2609 wxPyEndBlockThreads(blocked);
2610 delete [] formats;
2611 return list;
2612 }
2613 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2614 PyObject* rval = NULL;
2615 size_t size = self->GetDataSize(format);
2616 bool blocked = wxPyBeginBlockThreads();
2617 if (size) {
2618 char* buf = new char[size];
2619 if (self->GetDataHere(format, buf))
2620 rval = PyString_FromStringAndSize(buf, size);
2621 delete [] buf;
2622 }
2623 if (! rval) {
2624 rval = Py_None;
2625 Py_INCREF(rval);
2626 }
2627 wxPyEndBlockThreads(blocked);
2628 return rval;
2629 }
2630 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2631 bool rval;
2632 bool blocked = wxPyBeginBlockThreads();
2633 if (PyString_Check(data)) {
2634 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2635 }
2636 else {
2637 // raise a TypeError if not a string
2638 PyErr_SetString(PyExc_TypeError, "String expected.");
2639 rval = false;
2640 }
2641 wxPyEndBlockThreads(blocked);
2642 return rval;
2643 }
2644 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2645 PyObject* rval = NULL;
2646 size_t size = self->GetDataSize();
2647 bool blocked = wxPyBeginBlockThreads();
2648 if (size) {
2649 char* buf = new char[size];
2650 if (self->GetDataHere(buf))
2651 rval = PyString_FromStringAndSize(buf, size);
2652 delete [] buf;
2653 }
2654 if (! rval) {
2655 rval = Py_None;
2656 Py_INCREF(rval);
2657 }
2658 wxPyEndBlockThreads(blocked);
2659 return rval;
2660 }
2661 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2662 bool rval;
2663 bool blocked = wxPyBeginBlockThreads();
2664 if (PyString_Check(data)) {
2665 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2666 }
2667 else {
2668 // raise a TypeError if not a string
2669 PyErr_SetString(PyExc_TypeError, "String expected.");
2670 rval = false;
2671 }
2672 wxPyEndBlockThreads(blocked);
2673 return rval;
2674 }
2675 // Create a new class for wxPython to use
2676 class wxPyDataObjectSimple : public wxDataObjectSimple {
2677 public:
2678 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2679 : wxDataObjectSimple(format) {}
2680
2681 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2682 bool GetDataHere(void *buf) const;
2683 bool SetData(size_t len, const void *buf) const;
2684 PYPRIVATE;
2685 };
2686
2687 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2688
2689 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2690 // We need to get the data for this object and write it to buf. I think
2691 // the best way to do this for wxPython is to have the Python method
2692 // return either a string or None and then act appropriately with the
2693 // C++ version.
2694
2695 bool rval = false;
2696 bool blocked = wxPyBeginBlockThreads();
2697 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2698 PyObject* ro;
2699 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2700 if (ro) {
2701 rval = (ro != Py_None && PyString_Check(ro));
2702 if (rval)
2703 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2704 Py_DECREF(ro);
2705 }
2706 }
2707 wxPyEndBlockThreads(blocked);
2708 return rval;
2709 }
2710
2711 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2712 // For this one we simply need to make a string from buf and len
2713 // and send it to the Python method.
2714 bool rval = false;
2715 bool blocked = wxPyBeginBlockThreads();
2716 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2717 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2718 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2719 Py_DECREF(data);
2720 }
2721 wxPyEndBlockThreads(blocked);
2722 return rval;
2723 }
2724
2725 // Create a new class for wxPython to use
2726 class wxPyTextDataObject : public wxTextDataObject {
2727 public:
2728 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2729 : wxTextDataObject(text) {}
2730
2731 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2732 DEC_PYCALLBACK_STRING__const(GetText);
2733 DEC_PYCALLBACK__STRING(SetText);
2734 PYPRIVATE;
2735 };
2736
2737 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2738 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2739 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2740
2741
2742 // Create a new class for wxPython to use
2743 class wxPyBitmapDataObject : public wxBitmapDataObject {
2744 public:
2745 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2746 : wxBitmapDataObject(bitmap) {}
2747
2748 wxBitmap GetBitmap() const;
2749 void SetBitmap(const wxBitmap& bitmap);
2750 PYPRIVATE;
2751 };
2752
2753 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2754 wxBitmap* rval = &wxNullBitmap;
2755 bool blocked = wxPyBeginBlockThreads();
2756 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2757 PyObject* ro;
2758 wxBitmap* ptr;
2759 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2760 if (ro) {
2761 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2762 rval = ptr;
2763 Py_DECREF(ro);
2764 }
2765 }
2766 wxPyEndBlockThreads(blocked);
2767 return *rval;
2768 }
2769
2770 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2771 bool blocked = wxPyBeginBlockThreads();
2772 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2773 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2774 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2775 Py_DECREF(bo);
2776 }
2777 wxPyEndBlockThreads(blocked);
2778 }
2779
2780 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2781 bool rval;
2782 bool blocked = wxPyBeginBlockThreads();
2783 if (PyString_Check(data)) {
2784 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2785 }
2786 else {
2787 // raise a TypeError if not a string
2788 PyErr_SetString(PyExc_TypeError, "String expected.");
2789 rval = false;
2790 }
2791 wxPyEndBlockThreads(blocked);
2792 return rval;
2793 }
2794 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2795 PyObject* obj;
2796 bool blocked = wxPyBeginBlockThreads();
2797 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2798 wxPyEndBlockThreads(blocked);
2799 return obj;
2800 }
2801
2802 #include <wx/metafile.h>
2803
2804
2805 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2806
2807
2808 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2809 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2810 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2811 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2812 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2813
2814
2815 class wxPyTextDropTarget : public wxTextDropTarget {
2816 public:
2817 wxPyTextDropTarget() {}
2818
2819 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2820
2821 DEC_PYCALLBACK__(OnLeave);
2822 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2823 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2824 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2825 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2826
2827 PYPRIVATE;
2828 };
2829
2830 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2831 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2832 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2833 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2834 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2835 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2836
2837
2838
2839 class wxPyFileDropTarget : public wxFileDropTarget {
2840 public:
2841 wxPyFileDropTarget() {}
2842
2843 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2844
2845 DEC_PYCALLBACK__(OnLeave);
2846 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2847 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2848 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2849 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2850
2851 PYPRIVATE;
2852 };
2853
2854 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2855 const wxArrayString& filenames) {
2856 bool rval = false;
2857 bool blocked = wxPyBeginBlockThreads();
2858 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2859 PyObject* list = wxArrayString2PyList_helper(filenames);
2860 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2861 Py_DECREF(list);
2862 }
2863 wxPyEndBlockThreads(blocked);
2864 return rval;
2865 }
2866
2867
2868
2869 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2870 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2871 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2872 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2873 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2874
2875
2876
2877
2878 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2879
2880 #include <wx/display.h>
2881
2882 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2883 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2884
2885 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2886 #if !wxUSE_DISPLAY
2887 #include <wx/dynarray.h>
2888 #include <wx/vidmode.h>
2889
2890 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2891 #include "wx/arrimpl.cpp"
2892 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2893 const wxVideoMode wxDefaultVideoMode;
2894
2895 class wxDisplay
2896 {
2897 public:
2898 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2899 ~wxDisplay() {}
2900
2901 static size_t GetCount()
2902 { wxPyRaiseNotImplemented(); return 0; }
2903
2904 static int GetFromPoint(const wxPoint& pt)
2905 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2906 static int GetFromWindow(wxWindow *window)
2907 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2908
2909 virtual bool IsOk() const { return false; }
2910 virtual wxRect GetGeometry() const { wxRect r; return r; }
2911 virtual wxString GetName() const { return wxEmptyString; }
2912 bool IsPrimary() const { return false; }
2913
2914 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2915 { wxArrayVideoModes a; return a; }
2916
2917 virtual wxVideoMode GetCurrentMode() const
2918 { return wxDefaultVideoMode; }
2919
2920 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2921 { return false; }
2922
2923 void ResetMode() {}
2924 };
2925 #endif
2926
2927 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2928 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2929 PyObject* pyList = NULL;
2930 wxArrayVideoModes arr = self->GetModes(mode);
2931 bool blocked = wxPyBeginBlockThreads();
2932 pyList = PyList_New(0);
2933 for (int i=0; i < arr.GetCount(); i++) {
2934 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2935 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2936 PyList_Append(pyList, pyObj);
2937 Py_DECREF(pyObj);
2938 }
2939 wxPyEndBlockThreads(blocked);
2940 return pyList;
2941 }
2942
2943 #include <wx/stdpaths.h>
2944
2945 static wxStandardPaths *StandardPaths_Get(){
2946 return (wxStandardPaths*) &wxStandardPaths::Get();
2947 }
2948 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2949 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2950 #ifdef __cplusplus
2951 extern "C" {
2952 #endif
2953 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2954 PyObject *resultobj;
2955 wxSystemColour arg1 ;
2956 wxColour result;
2957 PyObject * obj0 = 0 ;
2958 char *kwnames[] = {
2959 (char *) "index", NULL
2960 };
2961
2962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2963 {
2964 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2965 if (SWIG_arg_fail(1)) SWIG_fail;
2966 }
2967 {
2968 if (!wxPyCheckForApp()) SWIG_fail;
2969 PyThreadState* __tstate = wxPyBeginAllowThreads();
2970 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2971
2972 wxPyEndAllowThreads(__tstate);
2973 if (PyErr_Occurred()) SWIG_fail;
2974 }
2975 {
2976 wxColour * resultptr;
2977 resultptr = new wxColour((wxColour &)(result));
2978 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2979 }
2980 return resultobj;
2981 fail:
2982 return NULL;
2983 }
2984
2985
2986 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2987 PyObject *resultobj;
2988 wxSystemFont arg1 ;
2989 wxFont result;
2990 PyObject * obj0 = 0 ;
2991 char *kwnames[] = {
2992 (char *) "index", NULL
2993 };
2994
2995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2996 {
2997 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2998 if (SWIG_arg_fail(1)) SWIG_fail;
2999 }
3000 {
3001 if (!wxPyCheckForApp()) SWIG_fail;
3002 PyThreadState* __tstate = wxPyBeginAllowThreads();
3003 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3004
3005 wxPyEndAllowThreads(__tstate);
3006 if (PyErr_Occurred()) SWIG_fail;
3007 }
3008 {
3009 wxFont * resultptr;
3010 resultptr = new wxFont((wxFont &)(result));
3011 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3012 }
3013 return resultobj;
3014 fail:
3015 return NULL;
3016 }
3017
3018
3019 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3020 PyObject *resultobj;
3021 wxSystemMetric arg1 ;
3022 int result;
3023 PyObject * obj0 = 0 ;
3024 char *kwnames[] = {
3025 (char *) "index", NULL
3026 };
3027
3028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3029 {
3030 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3031 if (SWIG_arg_fail(1)) SWIG_fail;
3032 }
3033 {
3034 if (!wxPyCheckForApp()) SWIG_fail;
3035 PyThreadState* __tstate = wxPyBeginAllowThreads();
3036 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3037
3038 wxPyEndAllowThreads(__tstate);
3039 if (PyErr_Occurred()) SWIG_fail;
3040 }
3041 {
3042 resultobj = SWIG_From_int((int)(result));
3043 }
3044 return resultobj;
3045 fail:
3046 return NULL;
3047 }
3048
3049
3050 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3051 PyObject *resultobj;
3052 wxSystemFeature arg1 ;
3053 bool result;
3054 PyObject * obj0 = 0 ;
3055 char *kwnames[] = {
3056 (char *) "index", NULL
3057 };
3058
3059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3060 {
3061 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3062 if (SWIG_arg_fail(1)) SWIG_fail;
3063 }
3064 {
3065 if (!wxPyCheckForApp()) SWIG_fail;
3066 PyThreadState* __tstate = wxPyBeginAllowThreads();
3067 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3068
3069 wxPyEndAllowThreads(__tstate);
3070 if (PyErr_Occurred()) SWIG_fail;
3071 }
3072 {
3073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3074 }
3075 return resultobj;
3076 fail:
3077 return NULL;
3078 }
3079
3080
3081 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3082 PyObject *resultobj;
3083 wxSystemScreenType result;
3084 char *kwnames[] = {
3085 NULL
3086 };
3087
3088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3089 {
3090 if (!wxPyCheckForApp()) SWIG_fail;
3091 PyThreadState* __tstate = wxPyBeginAllowThreads();
3092 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3093
3094 wxPyEndAllowThreads(__tstate);
3095 if (PyErr_Occurred()) SWIG_fail;
3096 }
3097 resultobj = SWIG_From_int((result));
3098 return resultobj;
3099 fail:
3100 return NULL;
3101 }
3102
3103
3104 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3105 PyObject *resultobj;
3106 wxSystemScreenType arg1 ;
3107 PyObject * obj0 = 0 ;
3108 char *kwnames[] = {
3109 (char *) "screen", NULL
3110 };
3111
3112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3113 {
3114 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3115 if (SWIG_arg_fail(1)) SWIG_fail;
3116 }
3117 {
3118 if (!wxPyCheckForApp()) SWIG_fail;
3119 PyThreadState* __tstate = wxPyBeginAllowThreads();
3120 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3121
3122 wxPyEndAllowThreads(__tstate);
3123 if (PyErr_Occurred()) SWIG_fail;
3124 }
3125 Py_INCREF(Py_None); resultobj = Py_None;
3126 return resultobj;
3127 fail:
3128 return NULL;
3129 }
3130
3131
3132 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3133 PyObject *obj;
3134 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3135 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3136 Py_INCREF(obj);
3137 return Py_BuildValue((char *)"");
3138 }
3139 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3140 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3141 return 1;
3142 }
3143
3144
3145 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3146 PyObject *pyobj;
3147
3148 {
3149 #if wxUSE_UNICODE
3150 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3151 #else
3152 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3153 #endif
3154 }
3155 return pyobj;
3156 }
3157
3158
3159 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3160 PyObject *resultobj;
3161 wxSystemOptions *result;
3162 char *kwnames[] = {
3163 NULL
3164 };
3165
3166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3167 {
3168 PyThreadState* __tstate = wxPyBeginAllowThreads();
3169 result = (wxSystemOptions *)new wxSystemOptions();
3170
3171 wxPyEndAllowThreads(__tstate);
3172 if (PyErr_Occurred()) SWIG_fail;
3173 }
3174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3175 return resultobj;
3176 fail:
3177 return NULL;
3178 }
3179
3180
3181 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3182 PyObject *resultobj;
3183 wxString *arg1 = 0 ;
3184 wxString *arg2 = 0 ;
3185 bool temp1 = false ;
3186 bool temp2 = false ;
3187 PyObject * obj0 = 0 ;
3188 PyObject * obj1 = 0 ;
3189 char *kwnames[] = {
3190 (char *) "name",(char *) "value", NULL
3191 };
3192
3193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3194 {
3195 arg1 = wxString_in_helper(obj0);
3196 if (arg1 == NULL) SWIG_fail;
3197 temp1 = true;
3198 }
3199 {
3200 arg2 = wxString_in_helper(obj1);
3201 if (arg2 == NULL) SWIG_fail;
3202 temp2 = true;
3203 }
3204 {
3205 PyThreadState* __tstate = wxPyBeginAllowThreads();
3206 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3207
3208 wxPyEndAllowThreads(__tstate);
3209 if (PyErr_Occurred()) SWIG_fail;
3210 }
3211 Py_INCREF(Py_None); resultobj = Py_None;
3212 {
3213 if (temp1)
3214 delete arg1;
3215 }
3216 {
3217 if (temp2)
3218 delete arg2;
3219 }
3220 return resultobj;
3221 fail:
3222 {
3223 if (temp1)
3224 delete arg1;
3225 }
3226 {
3227 if (temp2)
3228 delete arg2;
3229 }
3230 return NULL;
3231 }
3232
3233
3234 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3235 PyObject *resultobj;
3236 wxString *arg1 = 0 ;
3237 int arg2 ;
3238 bool temp1 = false ;
3239 PyObject * obj0 = 0 ;
3240 PyObject * obj1 = 0 ;
3241 char *kwnames[] = {
3242 (char *) "name",(char *) "value", NULL
3243 };
3244
3245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3246 {
3247 arg1 = wxString_in_helper(obj0);
3248 if (arg1 == NULL) SWIG_fail;
3249 temp1 = true;
3250 }
3251 {
3252 arg2 = (int)(SWIG_As_int(obj1));
3253 if (SWIG_arg_fail(2)) SWIG_fail;
3254 }
3255 {
3256 PyThreadState* __tstate = wxPyBeginAllowThreads();
3257 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3258
3259 wxPyEndAllowThreads(__tstate);
3260 if (PyErr_Occurred()) SWIG_fail;
3261 }
3262 Py_INCREF(Py_None); resultobj = Py_None;
3263 {
3264 if (temp1)
3265 delete arg1;
3266 }
3267 return resultobj;
3268 fail:
3269 {
3270 if (temp1)
3271 delete arg1;
3272 }
3273 return NULL;
3274 }
3275
3276
3277 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3278 PyObject *resultobj;
3279 wxString *arg1 = 0 ;
3280 wxString result;
3281 bool temp1 = false ;
3282 PyObject * obj0 = 0 ;
3283 char *kwnames[] = {
3284 (char *) "name", NULL
3285 };
3286
3287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3288 {
3289 arg1 = wxString_in_helper(obj0);
3290 if (arg1 == NULL) SWIG_fail;
3291 temp1 = true;
3292 }
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 {
3301 #if wxUSE_UNICODE
3302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3303 #else
3304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3305 #endif
3306 }
3307 {
3308 if (temp1)
3309 delete arg1;
3310 }
3311 return resultobj;
3312 fail:
3313 {
3314 if (temp1)
3315 delete arg1;
3316 }
3317 return NULL;
3318 }
3319
3320
3321 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3322 PyObject *resultobj;
3323 wxString *arg1 = 0 ;
3324 int result;
3325 bool temp1 = false ;
3326 PyObject * obj0 = 0 ;
3327 char *kwnames[] = {
3328 (char *) "name", NULL
3329 };
3330
3331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3332 {
3333 arg1 = wxString_in_helper(obj0);
3334 if (arg1 == NULL) SWIG_fail;
3335 temp1 = true;
3336 }
3337 {
3338 PyThreadState* __tstate = wxPyBeginAllowThreads();
3339 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3340
3341 wxPyEndAllowThreads(__tstate);
3342 if (PyErr_Occurred()) SWIG_fail;
3343 }
3344 {
3345 resultobj = SWIG_From_int((int)(result));
3346 }
3347 {
3348 if (temp1)
3349 delete arg1;
3350 }
3351 return resultobj;
3352 fail:
3353 {
3354 if (temp1)
3355 delete arg1;
3356 }
3357 return NULL;
3358 }
3359
3360
3361 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3362 PyObject *resultobj;
3363 wxString *arg1 = 0 ;
3364 bool result;
3365 bool temp1 = false ;
3366 PyObject * obj0 = 0 ;
3367 char *kwnames[] = {
3368 (char *) "name", NULL
3369 };
3370
3371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3372 {
3373 arg1 = wxString_in_helper(obj0);
3374 if (arg1 == NULL) SWIG_fail;
3375 temp1 = true;
3376 }
3377 {
3378 PyThreadState* __tstate = wxPyBeginAllowThreads();
3379 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3380
3381 wxPyEndAllowThreads(__tstate);
3382 if (PyErr_Occurred()) SWIG_fail;
3383 }
3384 {
3385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3386 }
3387 {
3388 if (temp1)
3389 delete arg1;
3390 }
3391 return resultobj;
3392 fail:
3393 {
3394 if (temp1)
3395 delete arg1;
3396 }
3397 return NULL;
3398 }
3399
3400
3401 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3402 PyObject *obj;
3403 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3404 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3405 Py_INCREF(obj);
3406 return Py_BuildValue((char *)"");
3407 }
3408 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3409 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3410 return 1;
3411 }
3412
3413
3414 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3415 PyObject *pyobj;
3416
3417 {
3418 #if wxUSE_UNICODE
3419 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3420 #else
3421 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3422 #endif
3423 }
3424 return pyobj;
3425 }
3426
3427
3428 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3429 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3430 return 1;
3431 }
3432
3433
3434 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3435 PyObject *pyobj;
3436
3437 {
3438 #if wxUSE_UNICODE
3439 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3440 #else
3441 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3442 #endif
3443 }
3444 return pyobj;
3445 }
3446
3447
3448 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3449 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3450 return 1;
3451 }
3452
3453
3454 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3455 PyObject *pyobj;
3456
3457 {
3458 #if wxUSE_UNICODE
3459 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3460 #else
3461 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3462 #endif
3463 }
3464 return pyobj;
3465 }
3466
3467
3468 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3469 PyObject *resultobj;
3470 long result;
3471 char *kwnames[] = {
3472 NULL
3473 };
3474
3475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3476 {
3477 PyThreadState* __tstate = wxPyBeginAllowThreads();
3478 result = (long)wxNewId();
3479
3480 wxPyEndAllowThreads(__tstate);
3481 if (PyErr_Occurred()) SWIG_fail;
3482 }
3483 {
3484 resultobj = SWIG_From_long((long)(result));
3485 }
3486 return resultobj;
3487 fail:
3488 return NULL;
3489 }
3490
3491
3492 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3493 PyObject *resultobj;
3494 long arg1 ;
3495 PyObject * obj0 = 0 ;
3496 char *kwnames[] = {
3497 (char *) "id", NULL
3498 };
3499
3500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3501 {
3502 arg1 = (long)(SWIG_As_long(obj0));
3503 if (SWIG_arg_fail(1)) SWIG_fail;
3504 }
3505 {
3506 PyThreadState* __tstate = wxPyBeginAllowThreads();
3507 wxRegisterId(arg1);
3508
3509 wxPyEndAllowThreads(__tstate);
3510 if (PyErr_Occurred()) SWIG_fail;
3511 }
3512 Py_INCREF(Py_None); resultobj = Py_None;
3513 return resultobj;
3514 fail:
3515 return NULL;
3516 }
3517
3518
3519 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3520 PyObject *resultobj;
3521 long result;
3522 char *kwnames[] = {
3523 NULL
3524 };
3525
3526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3527 {
3528 PyThreadState* __tstate = wxPyBeginAllowThreads();
3529 result = (long)wxGetCurrentId();
3530
3531 wxPyEndAllowThreads(__tstate);
3532 if (PyErr_Occurred()) SWIG_fail;
3533 }
3534 {
3535 resultobj = SWIG_From_long((long)(result));
3536 }
3537 return resultobj;
3538 fail:
3539 return NULL;
3540 }
3541
3542
3543 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3544 PyObject *resultobj;
3545 int arg1 ;
3546 bool result;
3547 PyObject * obj0 = 0 ;
3548 char *kwnames[] = {
3549 (char *) "id", NULL
3550 };
3551
3552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3553 {
3554 arg1 = (int)(SWIG_As_int(obj0));
3555 if (SWIG_arg_fail(1)) SWIG_fail;
3556 }
3557 {
3558 PyThreadState* __tstate = wxPyBeginAllowThreads();
3559 result = (bool)wxIsStockID(arg1);
3560
3561 wxPyEndAllowThreads(__tstate);
3562 if (PyErr_Occurred()) SWIG_fail;
3563 }
3564 {
3565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3566 }
3567 return resultobj;
3568 fail:
3569 return NULL;
3570 }
3571
3572
3573 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3574 PyObject *resultobj;
3575 int arg1 ;
3576 wxString *arg2 = 0 ;
3577 bool result;
3578 bool temp2 = false ;
3579 PyObject * obj0 = 0 ;
3580 PyObject * obj1 = 0 ;
3581 char *kwnames[] = {
3582 (char *) "id",(char *) "label", NULL
3583 };
3584
3585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3586 {
3587 arg1 = (int)(SWIG_As_int(obj0));
3588 if (SWIG_arg_fail(1)) SWIG_fail;
3589 }
3590 {
3591 arg2 = wxString_in_helper(obj1);
3592 if (arg2 == NULL) SWIG_fail;
3593 temp2 = true;
3594 }
3595 {
3596 PyThreadState* __tstate = wxPyBeginAllowThreads();
3597 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3598
3599 wxPyEndAllowThreads(__tstate);
3600 if (PyErr_Occurred()) SWIG_fail;
3601 }
3602 {
3603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3604 }
3605 {
3606 if (temp2)
3607 delete arg2;
3608 }
3609 return resultobj;
3610 fail:
3611 {
3612 if (temp2)
3613 delete arg2;
3614 }
3615 return NULL;
3616 }
3617
3618
3619 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3620 PyObject *resultobj;
3621 int arg1 ;
3622 wxString result;
3623 PyObject * obj0 = 0 ;
3624 char *kwnames[] = {
3625 (char *) "id", NULL
3626 };
3627
3628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetStockLabel",kwnames,&obj0)) goto fail;
3629 {
3630 arg1 = (int)(SWIG_As_int(obj0));
3631 if (SWIG_arg_fail(1)) SWIG_fail;
3632 }
3633 {
3634 PyThreadState* __tstate = wxPyBeginAllowThreads();
3635 result = wxGetStockLabel(arg1);
3636
3637 wxPyEndAllowThreads(__tstate);
3638 if (PyErr_Occurred()) SWIG_fail;
3639 }
3640 {
3641 #if wxUSE_UNICODE
3642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3643 #else
3644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3645 #endif
3646 }
3647 return resultobj;
3648 fail:
3649 return NULL;
3650 }
3651
3652
3653 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3654 PyObject *resultobj;
3655 char *kwnames[] = {
3656 NULL
3657 };
3658
3659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3660 {
3661 if (!wxPyCheckForApp()) SWIG_fail;
3662 PyThreadState* __tstate = wxPyBeginAllowThreads();
3663 wxBell();
3664
3665 wxPyEndAllowThreads(__tstate);
3666 if (PyErr_Occurred()) SWIG_fail;
3667 }
3668 Py_INCREF(Py_None); resultobj = Py_None;
3669 return resultobj;
3670 fail:
3671 return NULL;
3672 }
3673
3674
3675 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3676 PyObject *resultobj;
3677 char *kwnames[] = {
3678 NULL
3679 };
3680
3681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3682 {
3683 if (!wxPyCheckForApp()) SWIG_fail;
3684 PyThreadState* __tstate = wxPyBeginAllowThreads();
3685 wxEndBusyCursor();
3686
3687 wxPyEndAllowThreads(__tstate);
3688 if (PyErr_Occurred()) SWIG_fail;
3689 }
3690 Py_INCREF(Py_None); resultobj = Py_None;
3691 return resultobj;
3692 fail:
3693 return NULL;
3694 }
3695
3696
3697 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3698 PyObject *resultobj;
3699 bool arg1 = (bool) true ;
3700 long result;
3701 PyObject * obj0 = 0 ;
3702 char *kwnames[] = {
3703 (char *) "resetTimer", NULL
3704 };
3705
3706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3707 if (obj0) {
3708 {
3709 arg1 = (bool)(SWIG_As_bool(obj0));
3710 if (SWIG_arg_fail(1)) SWIG_fail;
3711 }
3712 }
3713 {
3714 PyThreadState* __tstate = wxPyBeginAllowThreads();
3715 result = (long)wxGetElapsedTime(arg1);
3716
3717 wxPyEndAllowThreads(__tstate);
3718 if (PyErr_Occurred()) SWIG_fail;
3719 }
3720 {
3721 resultobj = SWIG_From_long((long)(result));
3722 }
3723 return resultobj;
3724 fail:
3725 return NULL;
3726 }
3727
3728
3729 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3730 PyObject *resultobj;
3731 int *arg1 = (int *) 0 ;
3732 int *arg2 = (int *) 0 ;
3733 int temp1 ;
3734 int res1 = 0 ;
3735 int temp2 ;
3736 int res2 = 0 ;
3737 char *kwnames[] = {
3738 NULL
3739 };
3740
3741 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3742 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3744 {
3745 if (!wxPyCheckForApp()) SWIG_fail;
3746 PyThreadState* __tstate = wxPyBeginAllowThreads();
3747 wxGetMousePosition(arg1,arg2);
3748
3749 wxPyEndAllowThreads(__tstate);
3750 if (PyErr_Occurred()) SWIG_fail;
3751 }
3752 Py_INCREF(Py_None); resultobj = Py_None;
3753 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3754 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3755 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3756 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3757 return resultobj;
3758 fail:
3759 return NULL;
3760 }
3761
3762
3763 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3764 PyObject *resultobj;
3765 bool result;
3766 char *kwnames[] = {
3767 NULL
3768 };
3769
3770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3771 {
3772 PyThreadState* __tstate = wxPyBeginAllowThreads();
3773 result = (bool)wxIsBusy();
3774
3775 wxPyEndAllowThreads(__tstate);
3776 if (PyErr_Occurred()) SWIG_fail;
3777 }
3778 {
3779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3780 }
3781 return resultobj;
3782 fail:
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3788 PyObject *resultobj;
3789 wxString result;
3790 char *kwnames[] = {
3791 NULL
3792 };
3793
3794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3795 {
3796 PyThreadState* __tstate = wxPyBeginAllowThreads();
3797 result = wxNow();
3798
3799 wxPyEndAllowThreads(__tstate);
3800 if (PyErr_Occurred()) SWIG_fail;
3801 }
3802 {
3803 #if wxUSE_UNICODE
3804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3805 #else
3806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3807 #endif
3808 }
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj;
3817 wxString const &arg1_defvalue = wxPyEmptyString ;
3818 wxString *arg1 = (wxString *) &arg1_defvalue ;
3819 bool result;
3820 bool temp1 = false ;
3821 PyObject * obj0 = 0 ;
3822 char *kwnames[] = {
3823 (char *) "command", NULL
3824 };
3825
3826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3827 if (obj0) {
3828 {
3829 arg1 = wxString_in_helper(obj0);
3830 if (arg1 == NULL) SWIG_fail;
3831 temp1 = true;
3832 }
3833 }
3834 {
3835 PyThreadState* __tstate = wxPyBeginAllowThreads();
3836 result = (bool)wxShell((wxString const &)*arg1);
3837
3838 wxPyEndAllowThreads(__tstate);
3839 if (PyErr_Occurred()) SWIG_fail;
3840 }
3841 {
3842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3843 }
3844 {
3845 if (temp1)
3846 delete arg1;
3847 }
3848 return resultobj;
3849 fail:
3850 {
3851 if (temp1)
3852 delete arg1;
3853 }
3854 return NULL;
3855 }
3856
3857
3858 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3859 PyObject *resultobj;
3860 char *kwnames[] = {
3861 NULL
3862 };
3863
3864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3865 {
3866 PyThreadState* __tstate = wxPyBeginAllowThreads();
3867 wxStartTimer();
3868
3869 wxPyEndAllowThreads(__tstate);
3870 if (PyErr_Occurred()) SWIG_fail;
3871 }
3872 Py_INCREF(Py_None); resultobj = Py_None;
3873 return resultobj;
3874 fail:
3875 return NULL;
3876 }
3877
3878
3879 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3880 PyObject *resultobj;
3881 int *arg1 = (int *) 0 ;
3882 int *arg2 = (int *) 0 ;
3883 int result;
3884 int temp1 ;
3885 int res1 = 0 ;
3886 int temp2 ;
3887 int res2 = 0 ;
3888 char *kwnames[] = {
3889 NULL
3890 };
3891
3892 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3893 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3895 {
3896 PyThreadState* __tstate = wxPyBeginAllowThreads();
3897 result = (int)wxGetOsVersion(arg1,arg2);
3898
3899 wxPyEndAllowThreads(__tstate);
3900 if (PyErr_Occurred()) SWIG_fail;
3901 }
3902 {
3903 resultobj = SWIG_From_int((int)(result));
3904 }
3905 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3906 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3907 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3908 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3909 return resultobj;
3910 fail:
3911 return NULL;
3912 }
3913
3914
3915 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3916 PyObject *resultobj;
3917 wxString result;
3918 char *kwnames[] = {
3919 NULL
3920 };
3921
3922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3923 {
3924 PyThreadState* __tstate = wxPyBeginAllowThreads();
3925 result = wxGetOsDescription();
3926
3927 wxPyEndAllowThreads(__tstate);
3928 if (PyErr_Occurred()) SWIG_fail;
3929 }
3930 {
3931 #if wxUSE_UNICODE
3932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3933 #else
3934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3935 #endif
3936 }
3937 return resultobj;
3938 fail:
3939 return NULL;
3940 }
3941
3942
3943 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3944 PyObject *resultobj;
3945 long result;
3946 char *kwnames[] = {
3947 NULL
3948 };
3949
3950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3951 {
3952 PyThreadState* __tstate = wxPyBeginAllowThreads();
3953 result = (long)wxGetFreeMemory();
3954
3955 wxPyEndAllowThreads(__tstate);
3956 if (PyErr_Occurred()) SWIG_fail;
3957 }
3958 {
3959 resultobj = SWIG_From_long((long)(result));
3960 }
3961 return resultobj;
3962 fail:
3963 return NULL;
3964 }
3965
3966
3967 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3968 PyObject *resultobj;
3969 wxShutdownFlags arg1 ;
3970 bool result;
3971 PyObject * obj0 = 0 ;
3972 char *kwnames[] = {
3973 (char *) "wFlags", NULL
3974 };
3975
3976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3977 {
3978 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3979 if (SWIG_arg_fail(1)) SWIG_fail;
3980 }
3981 {
3982 if (!wxPyCheckForApp()) SWIG_fail;
3983 PyThreadState* __tstate = wxPyBeginAllowThreads();
3984 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3985
3986 wxPyEndAllowThreads(__tstate);
3987 if (PyErr_Occurred()) SWIG_fail;
3988 }
3989 {
3990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3991 }
3992 return resultobj;
3993 fail:
3994 return NULL;
3995 }
3996
3997
3998 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3999 PyObject *resultobj;
4000 int arg1 ;
4001 PyObject * obj0 = 0 ;
4002 char *kwnames[] = {
4003 (char *) "secs", NULL
4004 };
4005
4006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4007 {
4008 arg1 = (int)(SWIG_As_int(obj0));
4009 if (SWIG_arg_fail(1)) SWIG_fail;
4010 }
4011 {
4012 PyThreadState* __tstate = wxPyBeginAllowThreads();
4013 wxSleep(arg1);
4014
4015 wxPyEndAllowThreads(__tstate);
4016 if (PyErr_Occurred()) SWIG_fail;
4017 }
4018 Py_INCREF(Py_None); resultobj = Py_None;
4019 return resultobj;
4020 fail:
4021 return NULL;
4022 }
4023
4024
4025 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4026 PyObject *resultobj;
4027 unsigned long arg1 ;
4028 PyObject * obj0 = 0 ;
4029 char *kwnames[] = {
4030 (char *) "milliseconds", NULL
4031 };
4032
4033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4034 {
4035 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4036 if (SWIG_arg_fail(1)) SWIG_fail;
4037 }
4038 {
4039 PyThreadState* __tstate = wxPyBeginAllowThreads();
4040 wxMilliSleep(arg1);
4041
4042 wxPyEndAllowThreads(__tstate);
4043 if (PyErr_Occurred()) SWIG_fail;
4044 }
4045 Py_INCREF(Py_None); resultobj = Py_None;
4046 return resultobj;
4047 fail:
4048 return NULL;
4049 }
4050
4051
4052 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4053 PyObject *resultobj;
4054 unsigned long arg1 ;
4055 PyObject * obj0 = 0 ;
4056 char *kwnames[] = {
4057 (char *) "microseconds", NULL
4058 };
4059
4060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4061 {
4062 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4063 if (SWIG_arg_fail(1)) SWIG_fail;
4064 }
4065 {
4066 PyThreadState* __tstate = wxPyBeginAllowThreads();
4067 wxMicroSleep(arg1);
4068
4069 wxPyEndAllowThreads(__tstate);
4070 if (PyErr_Occurred()) SWIG_fail;
4071 }
4072 Py_INCREF(Py_None); resultobj = Py_None;
4073 return resultobj;
4074 fail:
4075 return NULL;
4076 }
4077
4078
4079 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4080 PyObject *resultobj;
4081 bool arg1 ;
4082 PyObject * obj0 = 0 ;
4083 char *kwnames[] = {
4084 (char *) "enable", NULL
4085 };
4086
4087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4088 {
4089 arg1 = (bool)(SWIG_As_bool(obj0));
4090 if (SWIG_arg_fail(1)) SWIG_fail;
4091 }
4092 {
4093 PyThreadState* __tstate = wxPyBeginAllowThreads();
4094 wxEnableTopLevelWindows(arg1);
4095
4096 wxPyEndAllowThreads(__tstate);
4097 if (PyErr_Occurred()) SWIG_fail;
4098 }
4099 Py_INCREF(Py_None); resultobj = Py_None;
4100 return resultobj;
4101 fail:
4102 return NULL;
4103 }
4104
4105
4106 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj;
4108 wxString *arg1 = 0 ;
4109 wxString result;
4110 bool temp1 = false ;
4111 PyObject * obj0 = 0 ;
4112 char *kwnames[] = {
4113 (char *) "in", NULL
4114 };
4115
4116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4117 {
4118 arg1 = wxString_in_helper(obj0);
4119 if (arg1 == NULL) SWIG_fail;
4120 temp1 = true;
4121 }
4122 {
4123 PyThreadState* __tstate = wxPyBeginAllowThreads();
4124 result = wxStripMenuCodes((wxString const &)*arg1);
4125
4126 wxPyEndAllowThreads(__tstate);
4127 if (PyErr_Occurred()) SWIG_fail;
4128 }
4129 {
4130 #if wxUSE_UNICODE
4131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4132 #else
4133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4134 #endif
4135 }
4136 {
4137 if (temp1)
4138 delete arg1;
4139 }
4140 return resultobj;
4141 fail:
4142 {
4143 if (temp1)
4144 delete arg1;
4145 }
4146 return NULL;
4147 }
4148
4149
4150 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4151 PyObject *resultobj;
4152 wxString result;
4153 char *kwnames[] = {
4154 NULL
4155 };
4156
4157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4158 {
4159 PyThreadState* __tstate = wxPyBeginAllowThreads();
4160 result = wxGetEmailAddress();
4161
4162 wxPyEndAllowThreads(__tstate);
4163 if (PyErr_Occurred()) SWIG_fail;
4164 }
4165 {
4166 #if wxUSE_UNICODE
4167 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4168 #else
4169 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4170 #endif
4171 }
4172 return resultobj;
4173 fail:
4174 return NULL;
4175 }
4176
4177
4178 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4179 PyObject *resultobj;
4180 wxString result;
4181 char *kwnames[] = {
4182 NULL
4183 };
4184
4185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4186 {
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 result = wxGetHostName();
4189
4190 wxPyEndAllowThreads(__tstate);
4191 if (PyErr_Occurred()) SWIG_fail;
4192 }
4193 {
4194 #if wxUSE_UNICODE
4195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4196 #else
4197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4198 #endif
4199 }
4200 return resultobj;
4201 fail:
4202 return NULL;
4203 }
4204
4205
4206 static PyObject *_wrap_GetFullHostName(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 *)":GetFullHostName",kwnames)) goto fail;
4214 {
4215 PyThreadState* __tstate = wxPyBeginAllowThreads();
4216 result = wxGetFullHostName();
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_GetUserId(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 *)":GetUserId",kwnames)) goto fail;
4242 {
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = wxGetUserId();
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_GetUserName(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 *)":GetUserName",kwnames)) goto fail;
4270 {
4271 PyThreadState* __tstate = wxPyBeginAllowThreads();
4272 result = wxGetUserName();
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_GetHomeDir(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 *)":GetHomeDir",kwnames)) goto fail;
4298 {
4299 PyThreadState* __tstate = wxPyBeginAllowThreads();
4300 result = wxGetHomeDir();
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_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj;
4320 wxString const &arg1_defvalue = wxPyEmptyString ;
4321 wxString *arg1 = (wxString *) &arg1_defvalue ;
4322 wxString result;
4323 bool temp1 = false ;
4324 PyObject * obj0 = 0 ;
4325 char *kwnames[] = {
4326 (char *) "user", NULL
4327 };
4328
4329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4330 if (obj0) {
4331 {
4332 arg1 = wxString_in_helper(obj0);
4333 if (arg1 == NULL) SWIG_fail;
4334 temp1 = true;
4335 }
4336 }
4337 {
4338 PyThreadState* __tstate = wxPyBeginAllowThreads();
4339 result = wxGetUserHome((wxString const &)*arg1);
4340
4341 wxPyEndAllowThreads(__tstate);
4342 if (PyErr_Occurred()) SWIG_fail;
4343 }
4344 {
4345 #if wxUSE_UNICODE
4346 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4347 #else
4348 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4349 #endif
4350 }
4351 {
4352 if (temp1)
4353 delete arg1;
4354 }
4355 return resultobj;
4356 fail:
4357 {
4358 if (temp1)
4359 delete arg1;
4360 }
4361 return NULL;
4362 }
4363
4364
4365 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj;
4367 unsigned long result;
4368 char *kwnames[] = {
4369 NULL
4370 };
4371
4372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4373 {
4374 PyThreadState* __tstate = wxPyBeginAllowThreads();
4375 result = (unsigned long)wxGetProcessId();
4376
4377 wxPyEndAllowThreads(__tstate);
4378 if (PyErr_Occurred()) SWIG_fail;
4379 }
4380 {
4381 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4382 }
4383 return resultobj;
4384 fail:
4385 return NULL;
4386 }
4387
4388
4389 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4390 PyObject *resultobj;
4391 char *kwnames[] = {
4392 NULL
4393 };
4394
4395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4396 {
4397 PyThreadState* __tstate = wxPyBeginAllowThreads();
4398 wxTrap();
4399
4400 wxPyEndAllowThreads(__tstate);
4401 if (PyErr_Occurred()) SWIG_fail;
4402 }
4403 Py_INCREF(Py_None); resultobj = Py_None;
4404 return resultobj;
4405 fail:
4406 return NULL;
4407 }
4408
4409
4410 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4411 PyObject *resultobj;
4412 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4413 wxString *arg1 = (wxString *) &arg1_defvalue ;
4414 wxString const &arg2_defvalue = wxPyEmptyString ;
4415 wxString *arg2 = (wxString *) &arg2_defvalue ;
4416 wxString const &arg3_defvalue = wxPyEmptyString ;
4417 wxString *arg3 = (wxString *) &arg3_defvalue ;
4418 wxString const &arg4_defvalue = wxPyEmptyString ;
4419 wxString *arg4 = (wxString *) &arg4_defvalue ;
4420 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4421 wxString *arg5 = (wxString *) &arg5_defvalue ;
4422 int arg6 = (int) 0 ;
4423 wxWindow *arg7 = (wxWindow *) NULL ;
4424 int arg8 = (int) -1 ;
4425 int arg9 = (int) -1 ;
4426 wxString result;
4427 bool temp1 = false ;
4428 bool temp2 = false ;
4429 bool temp3 = false ;
4430 bool temp4 = false ;
4431 bool temp5 = false ;
4432 PyObject * obj0 = 0 ;
4433 PyObject * obj1 = 0 ;
4434 PyObject * obj2 = 0 ;
4435 PyObject * obj3 = 0 ;
4436 PyObject * obj4 = 0 ;
4437 PyObject * obj5 = 0 ;
4438 PyObject * obj6 = 0 ;
4439 PyObject * obj7 = 0 ;
4440 PyObject * obj8 = 0 ;
4441 char *kwnames[] = {
4442 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4443 };
4444
4445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4446 if (obj0) {
4447 {
4448 arg1 = wxString_in_helper(obj0);
4449 if (arg1 == NULL) SWIG_fail;
4450 temp1 = true;
4451 }
4452 }
4453 if (obj1) {
4454 {
4455 arg2 = wxString_in_helper(obj1);
4456 if (arg2 == NULL) SWIG_fail;
4457 temp2 = true;
4458 }
4459 }
4460 if (obj2) {
4461 {
4462 arg3 = wxString_in_helper(obj2);
4463 if (arg3 == NULL) SWIG_fail;
4464 temp3 = true;
4465 }
4466 }
4467 if (obj3) {
4468 {
4469 arg4 = wxString_in_helper(obj3);
4470 if (arg4 == NULL) SWIG_fail;
4471 temp4 = true;
4472 }
4473 }
4474 if (obj4) {
4475 {
4476 arg5 = wxString_in_helper(obj4);
4477 if (arg5 == NULL) SWIG_fail;
4478 temp5 = true;
4479 }
4480 }
4481 if (obj5) {
4482 {
4483 arg6 = (int)(SWIG_As_int(obj5));
4484 if (SWIG_arg_fail(6)) SWIG_fail;
4485 }
4486 }
4487 if (obj6) {
4488 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4489 if (SWIG_arg_fail(7)) SWIG_fail;
4490 }
4491 if (obj7) {
4492 {
4493 arg8 = (int)(SWIG_As_int(obj7));
4494 if (SWIG_arg_fail(8)) SWIG_fail;
4495 }
4496 }
4497 if (obj8) {
4498 {
4499 arg9 = (int)(SWIG_As_int(obj8));
4500 if (SWIG_arg_fail(9)) SWIG_fail;
4501 }
4502 }
4503 {
4504 if (!wxPyCheckForApp()) SWIG_fail;
4505 PyThreadState* __tstate = wxPyBeginAllowThreads();
4506 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4507
4508 wxPyEndAllowThreads(__tstate);
4509 if (PyErr_Occurred()) SWIG_fail;
4510 }
4511 {
4512 #if wxUSE_UNICODE
4513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4514 #else
4515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4516 #endif
4517 }
4518 {
4519 if (temp1)
4520 delete arg1;
4521 }
4522 {
4523 if (temp2)
4524 delete arg2;
4525 }
4526 {
4527 if (temp3)
4528 delete arg3;
4529 }
4530 {
4531 if (temp4)
4532 delete arg4;
4533 }
4534 {
4535 if (temp5)
4536 delete arg5;
4537 }
4538 return resultobj;
4539 fail:
4540 {
4541 if (temp1)
4542 delete arg1;
4543 }
4544 {
4545 if (temp2)
4546 delete arg2;
4547 }
4548 {
4549 if (temp3)
4550 delete arg3;
4551 }
4552 {
4553 if (temp4)
4554 delete arg4;
4555 }
4556 {
4557 if (temp5)
4558 delete arg5;
4559 }
4560 return NULL;
4561 }
4562
4563
4564 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4565 PyObject *resultobj;
4566 wxString *arg1 = 0 ;
4567 wxString *arg2 = 0 ;
4568 wxString const &arg3_defvalue = wxPyEmptyString ;
4569 wxString *arg3 = (wxString *) &arg3_defvalue ;
4570 wxWindow *arg4 = (wxWindow *) NULL ;
4571 wxString result;
4572 bool temp1 = false ;
4573 bool temp2 = false ;
4574 bool temp3 = false ;
4575 PyObject * obj0 = 0 ;
4576 PyObject * obj1 = 0 ;
4577 PyObject * obj2 = 0 ;
4578 PyObject * obj3 = 0 ;
4579 char *kwnames[] = {
4580 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4581 };
4582
4583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4584 {
4585 arg1 = wxString_in_helper(obj0);
4586 if (arg1 == NULL) SWIG_fail;
4587 temp1 = true;
4588 }
4589 {
4590 arg2 = wxString_in_helper(obj1);
4591 if (arg2 == NULL) SWIG_fail;
4592 temp2 = true;
4593 }
4594 if (obj2) {
4595 {
4596 arg3 = wxString_in_helper(obj2);
4597 if (arg3 == NULL) SWIG_fail;
4598 temp3 = true;
4599 }
4600 }
4601 if (obj3) {
4602 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4603 if (SWIG_arg_fail(4)) SWIG_fail;
4604 }
4605 {
4606 if (!wxPyCheckForApp()) SWIG_fail;
4607 PyThreadState* __tstate = wxPyBeginAllowThreads();
4608 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4609
4610 wxPyEndAllowThreads(__tstate);
4611 if (PyErr_Occurred()) SWIG_fail;
4612 }
4613 {
4614 #if wxUSE_UNICODE
4615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4616 #else
4617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4618 #endif
4619 }
4620 {
4621 if (temp1)
4622 delete arg1;
4623 }
4624 {
4625 if (temp2)
4626 delete arg2;
4627 }
4628 {
4629 if (temp3)
4630 delete arg3;
4631 }
4632 return resultobj;
4633 fail:
4634 {
4635 if (temp1)
4636 delete arg1;
4637 }
4638 {
4639 if (temp2)
4640 delete arg2;
4641 }
4642 {
4643 if (temp3)
4644 delete arg3;
4645 }
4646 return NULL;
4647 }
4648
4649
4650 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4651 PyObject *resultobj;
4652 wxString *arg1 = 0 ;
4653 wxString *arg2 = 0 ;
4654 wxString const &arg3_defvalue = wxPyEmptyString ;
4655 wxString *arg3 = (wxString *) &arg3_defvalue ;
4656 wxWindow *arg4 = (wxWindow *) NULL ;
4657 wxString result;
4658 bool temp1 = false ;
4659 bool temp2 = false ;
4660 bool temp3 = false ;
4661 PyObject * obj0 = 0 ;
4662 PyObject * obj1 = 0 ;
4663 PyObject * obj2 = 0 ;
4664 PyObject * obj3 = 0 ;
4665 char *kwnames[] = {
4666 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4667 };
4668
4669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4670 {
4671 arg1 = wxString_in_helper(obj0);
4672 if (arg1 == NULL) SWIG_fail;
4673 temp1 = true;
4674 }
4675 {
4676 arg2 = wxString_in_helper(obj1);
4677 if (arg2 == NULL) SWIG_fail;
4678 temp2 = true;
4679 }
4680 if (obj2) {
4681 {
4682 arg3 = wxString_in_helper(obj2);
4683 if (arg3 == NULL) SWIG_fail;
4684 temp3 = true;
4685 }
4686 }
4687 if (obj3) {
4688 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4689 if (SWIG_arg_fail(4)) SWIG_fail;
4690 }
4691 {
4692 if (!wxPyCheckForApp()) SWIG_fail;
4693 PyThreadState* __tstate = wxPyBeginAllowThreads();
4694 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4695
4696 wxPyEndAllowThreads(__tstate);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 {
4700 #if wxUSE_UNICODE
4701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4702 #else
4703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4704 #endif
4705 }
4706 {
4707 if (temp1)
4708 delete arg1;
4709 }
4710 {
4711 if (temp2)
4712 delete arg2;
4713 }
4714 {
4715 if (temp3)
4716 delete arg3;
4717 }
4718 return resultobj;
4719 fail:
4720 {
4721 if (temp1)
4722 delete arg1;
4723 }
4724 {
4725 if (temp2)
4726 delete arg2;
4727 }
4728 {
4729 if (temp3)
4730 delete arg3;
4731 }
4732 return NULL;
4733 }
4734
4735
4736 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4737 PyObject *resultobj;
4738 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4739 wxString *arg1 = (wxString *) &arg1_defvalue ;
4740 wxString const &arg2_defvalue = wxPyEmptyString ;
4741 wxString *arg2 = (wxString *) &arg2_defvalue ;
4742 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4743 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4744 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4745 wxWindow *arg5 = (wxWindow *) NULL ;
4746 wxString result;
4747 bool temp1 = false ;
4748 bool temp2 = false ;
4749 wxPoint temp4 ;
4750 PyObject * obj0 = 0 ;
4751 PyObject * obj1 = 0 ;
4752 PyObject * obj2 = 0 ;
4753 PyObject * obj3 = 0 ;
4754 PyObject * obj4 = 0 ;
4755 char *kwnames[] = {
4756 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4757 };
4758
4759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4760 if (obj0) {
4761 {
4762 arg1 = wxString_in_helper(obj0);
4763 if (arg1 == NULL) SWIG_fail;
4764 temp1 = true;
4765 }
4766 }
4767 if (obj1) {
4768 {
4769 arg2 = wxString_in_helper(obj1);
4770 if (arg2 == NULL) SWIG_fail;
4771 temp2 = true;
4772 }
4773 }
4774 if (obj2) {
4775 {
4776 arg3 = (long)(SWIG_As_long(obj2));
4777 if (SWIG_arg_fail(3)) SWIG_fail;
4778 }
4779 }
4780 if (obj3) {
4781 {
4782 arg4 = &temp4;
4783 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4784 }
4785 }
4786 if (obj4) {
4787 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4788 if (SWIG_arg_fail(5)) SWIG_fail;
4789 }
4790 {
4791 if (!wxPyCheckForApp()) SWIG_fail;
4792 PyThreadState* __tstate = wxPyBeginAllowThreads();
4793 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4794
4795 wxPyEndAllowThreads(__tstate);
4796 if (PyErr_Occurred()) SWIG_fail;
4797 }
4798 {
4799 #if wxUSE_UNICODE
4800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4801 #else
4802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4803 #endif
4804 }
4805 {
4806 if (temp1)
4807 delete arg1;
4808 }
4809 {
4810 if (temp2)
4811 delete arg2;
4812 }
4813 return resultobj;
4814 fail:
4815 {
4816 if (temp1)
4817 delete arg1;
4818 }
4819 {
4820 if (temp2)
4821 delete arg2;
4822 }
4823 return NULL;
4824 }
4825
4826
4827 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4828 PyObject *resultobj;
4829 wxString *arg1 = 0 ;
4830 wxString const &arg2_defvalue = wxPyEmptyString ;
4831 wxString *arg2 = (wxString *) &arg2_defvalue ;
4832 wxString const &arg3_defvalue = wxPyEmptyString ;
4833 wxString *arg3 = (wxString *) &arg3_defvalue ;
4834 wxWindow *arg4 = (wxWindow *) NULL ;
4835 int arg5 = (int) -1 ;
4836 int arg6 = (int) -1 ;
4837 bool arg7 = (bool) true ;
4838 wxString result;
4839 bool temp1 = false ;
4840 bool temp2 = false ;
4841 bool temp3 = false ;
4842 PyObject * obj0 = 0 ;
4843 PyObject * obj1 = 0 ;
4844 PyObject * obj2 = 0 ;
4845 PyObject * obj3 = 0 ;
4846 PyObject * obj4 = 0 ;
4847 PyObject * obj5 = 0 ;
4848 PyObject * obj6 = 0 ;
4849 char *kwnames[] = {
4850 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4851 };
4852
4853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4854 {
4855 arg1 = wxString_in_helper(obj0);
4856 if (arg1 == NULL) SWIG_fail;
4857 temp1 = true;
4858 }
4859 if (obj1) {
4860 {
4861 arg2 = wxString_in_helper(obj1);
4862 if (arg2 == NULL) SWIG_fail;
4863 temp2 = true;
4864 }
4865 }
4866 if (obj2) {
4867 {
4868 arg3 = wxString_in_helper(obj2);
4869 if (arg3 == NULL) SWIG_fail;
4870 temp3 = true;
4871 }
4872 }
4873 if (obj3) {
4874 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4875 if (SWIG_arg_fail(4)) SWIG_fail;
4876 }
4877 if (obj4) {
4878 {
4879 arg5 = (int)(SWIG_As_int(obj4));
4880 if (SWIG_arg_fail(5)) SWIG_fail;
4881 }
4882 }
4883 if (obj5) {
4884 {
4885 arg6 = (int)(SWIG_As_int(obj5));
4886 if (SWIG_arg_fail(6)) SWIG_fail;
4887 }
4888 }
4889 if (obj6) {
4890 {
4891 arg7 = (bool)(SWIG_As_bool(obj6));
4892 if (SWIG_arg_fail(7)) SWIG_fail;
4893 }
4894 }
4895 {
4896 if (!wxPyCheckForApp()) SWIG_fail;
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 {
4904 #if wxUSE_UNICODE
4905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4906 #else
4907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4908 #endif
4909 }
4910 {
4911 if (temp1)
4912 delete arg1;
4913 }
4914 {
4915 if (temp2)
4916 delete arg2;
4917 }
4918 {
4919 if (temp3)
4920 delete arg3;
4921 }
4922 return resultobj;
4923 fail:
4924 {
4925 if (temp1)
4926 delete arg1;
4927 }
4928 {
4929 if (temp2)
4930 delete arg2;
4931 }
4932 {
4933 if (temp3)
4934 delete arg3;
4935 }
4936 return NULL;
4937 }
4938
4939
4940 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4941 PyObject *resultobj;
4942 wxString *arg1 = 0 ;
4943 wxString const &arg2_defvalue = wxPyEmptyString ;
4944 wxString *arg2 = (wxString *) &arg2_defvalue ;
4945 wxString const &arg3_defvalue = wxPyEmptyString ;
4946 wxString *arg3 = (wxString *) &arg3_defvalue ;
4947 wxWindow *arg4 = (wxWindow *) NULL ;
4948 wxString result;
4949 bool temp1 = false ;
4950 bool temp2 = false ;
4951 bool temp3 = false ;
4952 PyObject * obj0 = 0 ;
4953 PyObject * obj1 = 0 ;
4954 PyObject * obj2 = 0 ;
4955 PyObject * obj3 = 0 ;
4956 char *kwnames[] = {
4957 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4958 };
4959
4960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4961 {
4962 arg1 = wxString_in_helper(obj0);
4963 if (arg1 == NULL) SWIG_fail;
4964 temp1 = true;
4965 }
4966 if (obj1) {
4967 {
4968 arg2 = wxString_in_helper(obj1);
4969 if (arg2 == NULL) SWIG_fail;
4970 temp2 = true;
4971 }
4972 }
4973 if (obj2) {
4974 {
4975 arg3 = wxString_in_helper(obj2);
4976 if (arg3 == NULL) SWIG_fail;
4977 temp3 = true;
4978 }
4979 }
4980 if (obj3) {
4981 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4982 if (SWIG_arg_fail(4)) SWIG_fail;
4983 }
4984 {
4985 if (!wxPyCheckForApp()) SWIG_fail;
4986 PyThreadState* __tstate = wxPyBeginAllowThreads();
4987 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4988
4989 wxPyEndAllowThreads(__tstate);
4990 if (PyErr_Occurred()) SWIG_fail;
4991 }
4992 {
4993 #if wxUSE_UNICODE
4994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4995 #else
4996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4997 #endif
4998 }
4999 {
5000 if (temp1)
5001 delete arg1;
5002 }
5003 {
5004 if (temp2)
5005 delete arg2;
5006 }
5007 {
5008 if (temp3)
5009 delete arg3;
5010 }
5011 return resultobj;
5012 fail:
5013 {
5014 if (temp1)
5015 delete arg1;
5016 }
5017 {
5018 if (temp2)
5019 delete arg2;
5020 }
5021 {
5022 if (temp3)
5023 delete arg3;
5024 }
5025 return NULL;
5026 }
5027
5028
5029 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5030 PyObject *resultobj;
5031 wxString *arg1 = 0 ;
5032 wxString *arg2 = 0 ;
5033 int arg3 ;
5034 wxString *arg4 = (wxString *) 0 ;
5035 wxWindow *arg5 = (wxWindow *) NULL ;
5036 int arg6 = (int) -1 ;
5037 int arg7 = (int) -1 ;
5038 bool arg8 = (bool) true ;
5039 int arg9 = (int) 150 ;
5040 int arg10 = (int) 200 ;
5041 wxString result;
5042 bool temp1 = false ;
5043 bool temp2 = false ;
5044 PyObject * obj0 = 0 ;
5045 PyObject * obj1 = 0 ;
5046 PyObject * obj2 = 0 ;
5047 PyObject * obj3 = 0 ;
5048 PyObject * obj4 = 0 ;
5049 PyObject * obj5 = 0 ;
5050 PyObject * obj6 = 0 ;
5051 PyObject * obj7 = 0 ;
5052 PyObject * obj8 = 0 ;
5053 char *kwnames[] = {
5054 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5055 };
5056
5057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5058 {
5059 arg1 = wxString_in_helper(obj0);
5060 if (arg1 == NULL) SWIG_fail;
5061 temp1 = true;
5062 }
5063 {
5064 arg2 = wxString_in_helper(obj1);
5065 if (arg2 == NULL) SWIG_fail;
5066 temp2 = true;
5067 }
5068 {
5069 arg3 = PyList_Size(obj2);
5070 arg4 = wxString_LIST_helper(obj2);
5071 if (arg4 == NULL) SWIG_fail;
5072 }
5073 if (obj3) {
5074 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5075 if (SWIG_arg_fail(5)) SWIG_fail;
5076 }
5077 if (obj4) {
5078 {
5079 arg6 = (int)(SWIG_As_int(obj4));
5080 if (SWIG_arg_fail(6)) SWIG_fail;
5081 }
5082 }
5083 if (obj5) {
5084 {
5085 arg7 = (int)(SWIG_As_int(obj5));
5086 if (SWIG_arg_fail(7)) SWIG_fail;
5087 }
5088 }
5089 if (obj6) {
5090 {
5091 arg8 = (bool)(SWIG_As_bool(obj6));
5092 if (SWIG_arg_fail(8)) SWIG_fail;
5093 }
5094 }
5095 if (obj7) {
5096 {
5097 arg9 = (int)(SWIG_As_int(obj7));
5098 if (SWIG_arg_fail(9)) SWIG_fail;
5099 }
5100 }
5101 if (obj8) {
5102 {
5103 arg10 = (int)(SWIG_As_int(obj8));
5104 if (SWIG_arg_fail(10)) SWIG_fail;
5105 }
5106 }
5107 {
5108 if (!wxPyCheckForApp()) SWIG_fail;
5109 PyThreadState* __tstate = wxPyBeginAllowThreads();
5110 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5111
5112 wxPyEndAllowThreads(__tstate);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 {
5116 #if wxUSE_UNICODE
5117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5118 #else
5119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5120 #endif
5121 }
5122 {
5123 if (temp1)
5124 delete arg1;
5125 }
5126 {
5127 if (temp2)
5128 delete arg2;
5129 }
5130 {
5131 if (arg4) delete [] arg4;
5132 }
5133 return resultobj;
5134 fail:
5135 {
5136 if (temp1)
5137 delete arg1;
5138 }
5139 {
5140 if (temp2)
5141 delete arg2;
5142 }
5143 {
5144 if (arg4) delete [] arg4;
5145 }
5146 return NULL;
5147 }
5148
5149
5150 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5151 PyObject *resultobj;
5152 wxString *arg1 = 0 ;
5153 wxString *arg2 = 0 ;
5154 int arg3 ;
5155 wxString *arg4 = (wxString *) 0 ;
5156 wxWindow *arg5 = (wxWindow *) NULL ;
5157 int arg6 = (int) -1 ;
5158 int arg7 = (int) -1 ;
5159 bool arg8 = (bool) true ;
5160 int arg9 = (int) 150 ;
5161 int arg10 = (int) 200 ;
5162 int result;
5163 bool temp1 = false ;
5164 bool temp2 = false ;
5165 PyObject * obj0 = 0 ;
5166 PyObject * obj1 = 0 ;
5167 PyObject * obj2 = 0 ;
5168 PyObject * obj3 = 0 ;
5169 PyObject * obj4 = 0 ;
5170 PyObject * obj5 = 0 ;
5171 PyObject * obj6 = 0 ;
5172 PyObject * obj7 = 0 ;
5173 PyObject * obj8 = 0 ;
5174 char *kwnames[] = {
5175 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5176 };
5177
5178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5179 {
5180 arg1 = wxString_in_helper(obj0);
5181 if (arg1 == NULL) SWIG_fail;
5182 temp1 = true;
5183 }
5184 {
5185 arg2 = wxString_in_helper(obj1);
5186 if (arg2 == NULL) SWIG_fail;
5187 temp2 = true;
5188 }
5189 {
5190 arg3 = PyList_Size(obj2);
5191 arg4 = wxString_LIST_helper(obj2);
5192 if (arg4 == NULL) SWIG_fail;
5193 }
5194 if (obj3) {
5195 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5196 if (SWIG_arg_fail(5)) SWIG_fail;
5197 }
5198 if (obj4) {
5199 {
5200 arg6 = (int)(SWIG_As_int(obj4));
5201 if (SWIG_arg_fail(6)) SWIG_fail;
5202 }
5203 }
5204 if (obj5) {
5205 {
5206 arg7 = (int)(SWIG_As_int(obj5));
5207 if (SWIG_arg_fail(7)) SWIG_fail;
5208 }
5209 }
5210 if (obj6) {
5211 {
5212 arg8 = (bool)(SWIG_As_bool(obj6));
5213 if (SWIG_arg_fail(8)) SWIG_fail;
5214 }
5215 }
5216 if (obj7) {
5217 {
5218 arg9 = (int)(SWIG_As_int(obj7));
5219 if (SWIG_arg_fail(9)) SWIG_fail;
5220 }
5221 }
5222 if (obj8) {
5223 {
5224 arg10 = (int)(SWIG_As_int(obj8));
5225 if (SWIG_arg_fail(10)) SWIG_fail;
5226 }
5227 }
5228 {
5229 if (!wxPyCheckForApp()) SWIG_fail;
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5232
5233 wxPyEndAllowThreads(__tstate);
5234 if (PyErr_Occurred()) SWIG_fail;
5235 }
5236 {
5237 resultobj = SWIG_From_int((int)(result));
5238 }
5239 {
5240 if (temp1)
5241 delete arg1;
5242 }
5243 {
5244 if (temp2)
5245 delete arg2;
5246 }
5247 {
5248 if (arg4) delete [] arg4;
5249 }
5250 return resultobj;
5251 fail:
5252 {
5253 if (temp1)
5254 delete arg1;
5255 }
5256 {
5257 if (temp2)
5258 delete arg2;
5259 }
5260 {
5261 if (arg4) delete [] arg4;
5262 }
5263 return NULL;
5264 }
5265
5266
5267 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5268 PyObject *resultobj;
5269 wxString *arg1 = 0 ;
5270 wxString const &arg2_defvalue = wxPyEmptyString ;
5271 wxString *arg2 = (wxString *) &arg2_defvalue ;
5272 int arg3 = (int) wxOK|wxCENTRE ;
5273 wxWindow *arg4 = (wxWindow *) NULL ;
5274 int arg5 = (int) -1 ;
5275 int arg6 = (int) -1 ;
5276 int result;
5277 bool temp1 = false ;
5278 bool temp2 = false ;
5279 PyObject * obj0 = 0 ;
5280 PyObject * obj1 = 0 ;
5281 PyObject * obj2 = 0 ;
5282 PyObject * obj3 = 0 ;
5283 PyObject * obj4 = 0 ;
5284 PyObject * obj5 = 0 ;
5285 char *kwnames[] = {
5286 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5287 };
5288
5289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5290 {
5291 arg1 = wxString_in_helper(obj0);
5292 if (arg1 == NULL) SWIG_fail;
5293 temp1 = true;
5294 }
5295 if (obj1) {
5296 {
5297 arg2 = wxString_in_helper(obj1);
5298 if (arg2 == NULL) SWIG_fail;
5299 temp2 = true;
5300 }
5301 }
5302 if (obj2) {
5303 {
5304 arg3 = (int)(SWIG_As_int(obj2));
5305 if (SWIG_arg_fail(3)) SWIG_fail;
5306 }
5307 }
5308 if (obj3) {
5309 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5310 if (SWIG_arg_fail(4)) SWIG_fail;
5311 }
5312 if (obj4) {
5313 {
5314 arg5 = (int)(SWIG_As_int(obj4));
5315 if (SWIG_arg_fail(5)) SWIG_fail;
5316 }
5317 }
5318 if (obj5) {
5319 {
5320 arg6 = (int)(SWIG_As_int(obj5));
5321 if (SWIG_arg_fail(6)) SWIG_fail;
5322 }
5323 }
5324 {
5325 if (!wxPyCheckForApp()) SWIG_fail;
5326 PyThreadState* __tstate = wxPyBeginAllowThreads();
5327 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5328
5329 wxPyEndAllowThreads(__tstate);
5330 if (PyErr_Occurred()) SWIG_fail;
5331 }
5332 {
5333 resultobj = SWIG_From_int((int)(result));
5334 }
5335 {
5336 if (temp1)
5337 delete arg1;
5338 }
5339 {
5340 if (temp2)
5341 delete arg2;
5342 }
5343 return resultobj;
5344 fail:
5345 {
5346 if (temp1)
5347 delete arg1;
5348 }
5349 {
5350 if (temp2)
5351 delete arg2;
5352 }
5353 return NULL;
5354 }
5355
5356
5357 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5358 PyObject *resultobj;
5359 wxString *arg1 = 0 ;
5360 wxString *arg2 = 0 ;
5361 wxString *arg3 = 0 ;
5362 long arg4 ;
5363 long arg5 = (long) 0 ;
5364 long arg6 = (long) 100 ;
5365 wxWindow *arg7 = (wxWindow *) NULL ;
5366 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5367 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5368 long result;
5369 bool temp1 = false ;
5370 bool temp2 = false ;
5371 bool temp3 = false ;
5372 wxPoint temp8 ;
5373 PyObject * obj0 = 0 ;
5374 PyObject * obj1 = 0 ;
5375 PyObject * obj2 = 0 ;
5376 PyObject * obj3 = 0 ;
5377 PyObject * obj4 = 0 ;
5378 PyObject * obj5 = 0 ;
5379 PyObject * obj6 = 0 ;
5380 PyObject * obj7 = 0 ;
5381 char *kwnames[] = {
5382 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5383 };
5384
5385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5386 {
5387 arg1 = wxString_in_helper(obj0);
5388 if (arg1 == NULL) SWIG_fail;
5389 temp1 = true;
5390 }
5391 {
5392 arg2 = wxString_in_helper(obj1);
5393 if (arg2 == NULL) SWIG_fail;
5394 temp2 = true;
5395 }
5396 {
5397 arg3 = wxString_in_helper(obj2);
5398 if (arg3 == NULL) SWIG_fail;
5399 temp3 = true;
5400 }
5401 {
5402 arg4 = (long)(SWIG_As_long(obj3));
5403 if (SWIG_arg_fail(4)) SWIG_fail;
5404 }
5405 if (obj4) {
5406 {
5407 arg5 = (long)(SWIG_As_long(obj4));
5408 if (SWIG_arg_fail(5)) SWIG_fail;
5409 }
5410 }
5411 if (obj5) {
5412 {
5413 arg6 = (long)(SWIG_As_long(obj5));
5414 if (SWIG_arg_fail(6)) SWIG_fail;
5415 }
5416 }
5417 if (obj6) {
5418 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5419 if (SWIG_arg_fail(7)) SWIG_fail;
5420 }
5421 if (obj7) {
5422 {
5423 arg8 = &temp8;
5424 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5425 }
5426 }
5427 {
5428 if (!wxPyCheckForApp()) SWIG_fail;
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5431
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = SWIG_From_long((long)(result));
5437 }
5438 {
5439 if (temp1)
5440 delete arg1;
5441 }
5442 {
5443 if (temp2)
5444 delete arg2;
5445 }
5446 {
5447 if (temp3)
5448 delete arg3;
5449 }
5450 return resultobj;
5451 fail:
5452 {
5453 if (temp1)
5454 delete arg1;
5455 }
5456 {
5457 if (temp2)
5458 delete arg2;
5459 }
5460 {
5461 if (temp3)
5462 delete arg3;
5463 }
5464 return NULL;
5465 }
5466
5467
5468 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5469 PyObject *resultobj;
5470 bool result;
5471 char *kwnames[] = {
5472 NULL
5473 };
5474
5475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5476 {
5477 if (!wxPyCheckForApp()) SWIG_fail;
5478 PyThreadState* __tstate = wxPyBeginAllowThreads();
5479 result = (bool)wxColourDisplay();
5480
5481 wxPyEndAllowThreads(__tstate);
5482 if (PyErr_Occurred()) SWIG_fail;
5483 }
5484 {
5485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5486 }
5487 return resultobj;
5488 fail:
5489 return NULL;
5490 }
5491
5492
5493 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5494 PyObject *resultobj;
5495 int result;
5496 char *kwnames[] = {
5497 NULL
5498 };
5499
5500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5501 {
5502 if (!wxPyCheckForApp()) SWIG_fail;
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 result = (int)wxDisplayDepth();
5505
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 {
5510 resultobj = SWIG_From_int((int)(result));
5511 }
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj;
5520 int result;
5521 char *kwnames[] = {
5522 NULL
5523 };
5524
5525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5526 {
5527 if (!wxPyCheckForApp()) SWIG_fail;
5528 PyThreadState* __tstate = wxPyBeginAllowThreads();
5529 result = (int)wxGetDisplayDepth();
5530
5531 wxPyEndAllowThreads(__tstate);
5532 if (PyErr_Occurred()) SWIG_fail;
5533 }
5534 {
5535 resultobj = SWIG_From_int((int)(result));
5536 }
5537 return resultobj;
5538 fail:
5539 return NULL;
5540 }
5541
5542
5543 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5544 PyObject *resultobj;
5545 int *arg1 = (int *) 0 ;
5546 int *arg2 = (int *) 0 ;
5547 int temp1 ;
5548 int res1 = 0 ;
5549 int temp2 ;
5550 int res2 = 0 ;
5551 char *kwnames[] = {
5552 NULL
5553 };
5554
5555 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5556 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5558 {
5559 if (!wxPyCheckForApp()) SWIG_fail;
5560 PyThreadState* __tstate = wxPyBeginAllowThreads();
5561 wxDisplaySize(arg1,arg2);
5562
5563 wxPyEndAllowThreads(__tstate);
5564 if (PyErr_Occurred()) SWIG_fail;
5565 }
5566 Py_INCREF(Py_None); resultobj = Py_None;
5567 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5568 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5569 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5570 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5578 PyObject *resultobj;
5579 wxSize result;
5580 char *kwnames[] = {
5581 NULL
5582 };
5583
5584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5585 {
5586 if (!wxPyCheckForApp()) SWIG_fail;
5587 PyThreadState* __tstate = wxPyBeginAllowThreads();
5588 result = wxGetDisplaySize();
5589
5590 wxPyEndAllowThreads(__tstate);
5591 if (PyErr_Occurred()) SWIG_fail;
5592 }
5593 {
5594 wxSize * resultptr;
5595 resultptr = new wxSize((wxSize &)(result));
5596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5597 }
5598 return resultobj;
5599 fail:
5600 return NULL;
5601 }
5602
5603
5604 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5605 PyObject *resultobj;
5606 int *arg1 = (int *) 0 ;
5607 int *arg2 = (int *) 0 ;
5608 int temp1 ;
5609 int res1 = 0 ;
5610 int temp2 ;
5611 int res2 = 0 ;
5612 char *kwnames[] = {
5613 NULL
5614 };
5615
5616 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5617 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5619 {
5620 if (!wxPyCheckForApp()) SWIG_fail;
5621 PyThreadState* __tstate = wxPyBeginAllowThreads();
5622 wxDisplaySizeMM(arg1,arg2);
5623
5624 wxPyEndAllowThreads(__tstate);
5625 if (PyErr_Occurred()) SWIG_fail;
5626 }
5627 Py_INCREF(Py_None); resultobj = Py_None;
5628 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5629 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5630 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5631 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj;
5640 wxSize result;
5641 char *kwnames[] = {
5642 NULL
5643 };
5644
5645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5646 {
5647 if (!wxPyCheckForApp()) SWIG_fail;
5648 PyThreadState* __tstate = wxPyBeginAllowThreads();
5649 result = wxGetDisplaySizeMM();
5650
5651 wxPyEndAllowThreads(__tstate);
5652 if (PyErr_Occurred()) SWIG_fail;
5653 }
5654 {
5655 wxSize * resultptr;
5656 resultptr = new wxSize((wxSize &)(result));
5657 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5658 }
5659 return resultobj;
5660 fail:
5661 return NULL;
5662 }
5663
5664
5665 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5666 PyObject *resultobj;
5667 int *arg1 = (int *) 0 ;
5668 int *arg2 = (int *) 0 ;
5669 int *arg3 = (int *) 0 ;
5670 int *arg4 = (int *) 0 ;
5671 int temp1 ;
5672 int res1 = 0 ;
5673 int temp2 ;
5674 int res2 = 0 ;
5675 int temp3 ;
5676 int res3 = 0 ;
5677 int temp4 ;
5678 int res4 = 0 ;
5679 char *kwnames[] = {
5680 NULL
5681 };
5682
5683 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5684 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5685 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5686 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5688 {
5689 if (!wxPyCheckForApp()) SWIG_fail;
5690 PyThreadState* __tstate = wxPyBeginAllowThreads();
5691 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5692
5693 wxPyEndAllowThreads(__tstate);
5694 if (PyErr_Occurred()) SWIG_fail;
5695 }
5696 Py_INCREF(Py_None); resultobj = Py_None;
5697 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5698 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5699 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5700 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5701 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5702 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5703 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5704 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5712 PyObject *resultobj;
5713 wxRect result;
5714 char *kwnames[] = {
5715 NULL
5716 };
5717
5718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5719 {
5720 if (!wxPyCheckForApp()) SWIG_fail;
5721 PyThreadState* __tstate = wxPyBeginAllowThreads();
5722 result = wxGetClientDisplayRect();
5723
5724 wxPyEndAllowThreads(__tstate);
5725 if (PyErr_Occurred()) SWIG_fail;
5726 }
5727 {
5728 wxRect * resultptr;
5729 resultptr = new wxRect((wxRect &)(result));
5730 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5731 }
5732 return resultobj;
5733 fail:
5734 return NULL;
5735 }
5736
5737
5738 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5739 PyObject *resultobj;
5740 wxCursor *arg1 = 0 ;
5741 PyObject * obj0 = 0 ;
5742 char *kwnames[] = {
5743 (char *) "cursor", NULL
5744 };
5745
5746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5747 {
5748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5749 if (SWIG_arg_fail(1)) SWIG_fail;
5750 if (arg1 == NULL) {
5751 SWIG_null_ref("wxCursor");
5752 }
5753 if (SWIG_arg_fail(1)) SWIG_fail;
5754 }
5755 {
5756 if (!wxPyCheckForApp()) SWIG_fail;
5757 PyThreadState* __tstate = wxPyBeginAllowThreads();
5758 wxSetCursor(*arg1);
5759
5760 wxPyEndAllowThreads(__tstate);
5761 if (PyErr_Occurred()) SWIG_fail;
5762 }
5763 Py_INCREF(Py_None); resultobj = Py_None;
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj;
5772 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5773 PyObject * obj0 = 0 ;
5774 char *kwnames[] = {
5775 (char *) "cursor", NULL
5776 };
5777
5778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5779 if (obj0) {
5780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5781 if (SWIG_arg_fail(1)) SWIG_fail;
5782 }
5783 {
5784 if (!wxPyCheckForApp()) SWIG_fail;
5785 PyThreadState* __tstate = wxPyBeginAllowThreads();
5786 wxBeginBusyCursor(arg1);
5787
5788 wxPyEndAllowThreads(__tstate);
5789 if (PyErr_Occurred()) SWIG_fail;
5790 }
5791 Py_INCREF(Py_None); resultobj = Py_None;
5792 return resultobj;
5793 fail:
5794 return NULL;
5795 }
5796
5797
5798 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5799 PyObject *resultobj;
5800 wxWindow *result;
5801 char *kwnames[] = {
5802 NULL
5803 };
5804
5805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5806 {
5807 if (!wxPyCheckForApp()) SWIG_fail;
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 result = (wxWindow *)wxGetActiveWindow();
5810
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 {
5815 resultobj = wxPyMake_wxObject(result, 0);
5816 }
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5824 PyObject *resultobj;
5825 wxPoint *arg1 = 0 ;
5826 wxWindow *result;
5827 wxPoint temp1 ;
5828 PyObject * obj0 = 0 ;
5829 char *kwnames[] = {
5830 (char *) "pt", NULL
5831 };
5832
5833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5834 {
5835 arg1 = &temp1;
5836 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5837 }
5838 {
5839 if (!wxPyCheckForApp()) SWIG_fail;
5840 PyThreadState* __tstate = wxPyBeginAllowThreads();
5841 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5842
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 {
5847 resultobj = wxPyMake_wxObject(result, 0);
5848 }
5849 return resultobj;
5850 fail:
5851 return NULL;
5852 }
5853
5854
5855 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5856 PyObject *resultobj;
5857 wxPoint *arg1 = 0 ;
5858 wxWindow *result;
5859 wxPoint temp1 ;
5860 PyObject * obj0 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "pt", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5866 {
5867 arg1 = &temp1;
5868 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5869 }
5870 {
5871 if (!wxPyCheckForApp()) SWIG_fail;
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5874
5875 wxPyEndAllowThreads(__tstate);
5876 if (PyErr_Occurred()) SWIG_fail;
5877 }
5878 {
5879 resultobj = wxPyMake_wxObject(result, 0);
5880 }
5881 return resultobj;
5882 fail:
5883 return NULL;
5884 }
5885
5886
5887 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5888 PyObject *resultobj;
5889 wxWindow *arg1 = (wxWindow *) 0 ;
5890 wxWindow *result;
5891 PyObject * obj0 = 0 ;
5892 char *kwnames[] = {
5893 (char *) "win", NULL
5894 };
5895
5896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5898 if (SWIG_arg_fail(1)) SWIG_fail;
5899 {
5900 if (!wxPyCheckForApp()) SWIG_fail;
5901 PyThreadState* __tstate = wxPyBeginAllowThreads();
5902 result = (wxWindow *)wxGetTopLevelParent(arg1);
5903
5904 wxPyEndAllowThreads(__tstate);
5905 if (PyErr_Occurred()) SWIG_fail;
5906 }
5907 {
5908 resultobj = wxPyMake_wxObject(result, 0);
5909 }
5910 return resultobj;
5911 fail:
5912 return NULL;
5913 }
5914
5915
5916 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5917 PyObject *resultobj;
5918 wxKeyCode arg1 ;
5919 bool result;
5920 PyObject * obj0 = 0 ;
5921 char *kwnames[] = {
5922 (char *) "key", NULL
5923 };
5924
5925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5926 {
5927 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5928 if (SWIG_arg_fail(1)) SWIG_fail;
5929 }
5930 {
5931 if (!wxPyCheckForApp()) SWIG_fail;
5932 PyThreadState* __tstate = wxPyBeginAllowThreads();
5933 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5934
5935 wxPyEndAllowThreads(__tstate);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 {
5939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5940 }
5941 return resultobj;
5942 fail:
5943 return NULL;
5944 }
5945
5946
5947 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5948 PyObject *resultobj;
5949 char *kwnames[] = {
5950 NULL
5951 };
5952
5953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5954 {
5955 if (!wxPyCheckForApp()) SWIG_fail;
5956 PyThreadState* __tstate = wxPyBeginAllowThreads();
5957 wxWakeUpMainThread();
5958
5959 wxPyEndAllowThreads(__tstate);
5960 if (PyErr_Occurred()) SWIG_fail;
5961 }
5962 Py_INCREF(Py_None); resultobj = Py_None;
5963 return resultobj;
5964 fail:
5965 return NULL;
5966 }
5967
5968
5969 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5970 PyObject *resultobj;
5971 char *kwnames[] = {
5972 NULL
5973 };
5974
5975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5976 {
5977 if (!wxPyCheckForApp()) SWIG_fail;
5978 PyThreadState* __tstate = wxPyBeginAllowThreads();
5979 wxMutexGuiEnter();
5980
5981 wxPyEndAllowThreads(__tstate);
5982 if (PyErr_Occurred()) SWIG_fail;
5983 }
5984 Py_INCREF(Py_None); resultobj = Py_None;
5985 return resultobj;
5986 fail:
5987 return NULL;
5988 }
5989
5990
5991 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5992 PyObject *resultobj;
5993 char *kwnames[] = {
5994 NULL
5995 };
5996
5997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5998 {
5999 if (!wxPyCheckForApp()) SWIG_fail;
6000 PyThreadState* __tstate = wxPyBeginAllowThreads();
6001 wxMutexGuiLeave();
6002
6003 wxPyEndAllowThreads(__tstate);
6004 if (PyErr_Occurred()) SWIG_fail;
6005 }
6006 Py_INCREF(Py_None); resultobj = Py_None;
6007 return resultobj;
6008 fail:
6009 return NULL;
6010 }
6011
6012
6013 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6014 PyObject *resultobj;
6015 wxMutexGuiLocker *result;
6016 char *kwnames[] = {
6017 NULL
6018 };
6019
6020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6021 {
6022 if (!wxPyCheckForApp()) SWIG_fail;
6023 PyThreadState* __tstate = wxPyBeginAllowThreads();
6024 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6025
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6030 return resultobj;
6031 fail:
6032 return NULL;
6033 }
6034
6035
6036 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6037 PyObject *resultobj;
6038 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6039 PyObject * obj0 = 0 ;
6040 char *kwnames[] = {
6041 (char *) "self", NULL
6042 };
6043
6044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6046 if (SWIG_arg_fail(1)) SWIG_fail;
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 delete arg1;
6050
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 Py_INCREF(Py_None); resultobj = Py_None;
6055 return resultobj;
6056 fail:
6057 return NULL;
6058 }
6059
6060
6061 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6062 PyObject *obj;
6063 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6064 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6065 Py_INCREF(obj);
6066 return Py_BuildValue((char *)"");
6067 }
6068 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6069 PyObject *resultobj;
6070 bool result;
6071 char *kwnames[] = {
6072 NULL
6073 };
6074
6075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6076 {
6077 PyThreadState* __tstate = wxPyBeginAllowThreads();
6078 result = (bool)wxThread_IsMain();
6079
6080 wxPyEndAllowThreads(__tstate);
6081 if (PyErr_Occurred()) SWIG_fail;
6082 }
6083 {
6084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6085 }
6086 return resultobj;
6087 fail:
6088 return NULL;
6089 }
6090
6091
6092 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj;
6094 wxString *arg1 = 0 ;
6095 wxToolTip *result;
6096 bool temp1 = false ;
6097 PyObject * obj0 = 0 ;
6098 char *kwnames[] = {
6099 (char *) "tip", NULL
6100 };
6101
6102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6103 {
6104 arg1 = wxString_in_helper(obj0);
6105 if (arg1 == NULL) SWIG_fail;
6106 temp1 = true;
6107 }
6108 {
6109 if (!wxPyCheckForApp()) SWIG_fail;
6110 PyThreadState* __tstate = wxPyBeginAllowThreads();
6111 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6112
6113 wxPyEndAllowThreads(__tstate);
6114 if (PyErr_Occurred()) SWIG_fail;
6115 }
6116 {
6117 resultobj = wxPyMake_wxObject(result, 1);
6118 }
6119 {
6120 if (temp1)
6121 delete arg1;
6122 }
6123 return resultobj;
6124 fail:
6125 {
6126 if (temp1)
6127 delete arg1;
6128 }
6129 return NULL;
6130 }
6131
6132
6133 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6134 PyObject *resultobj;
6135 wxToolTip *arg1 = (wxToolTip *) 0 ;
6136 wxString *arg2 = 0 ;
6137 bool temp2 = false ;
6138 PyObject * obj0 = 0 ;
6139 PyObject * obj1 = 0 ;
6140 char *kwnames[] = {
6141 (char *) "self",(char *) "tip", NULL
6142 };
6143
6144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6146 if (SWIG_arg_fail(1)) SWIG_fail;
6147 {
6148 arg2 = wxString_in_helper(obj1);
6149 if (arg2 == NULL) SWIG_fail;
6150 temp2 = true;
6151 }
6152 {
6153 PyThreadState* __tstate = wxPyBeginAllowThreads();
6154 (arg1)->SetTip((wxString const &)*arg2);
6155
6156 wxPyEndAllowThreads(__tstate);
6157 if (PyErr_Occurred()) SWIG_fail;
6158 }
6159 Py_INCREF(Py_None); resultobj = Py_None;
6160 {
6161 if (temp2)
6162 delete arg2;
6163 }
6164 return resultobj;
6165 fail:
6166 {
6167 if (temp2)
6168 delete arg2;
6169 }
6170 return NULL;
6171 }
6172
6173
6174 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6175 PyObject *resultobj;
6176 wxToolTip *arg1 = (wxToolTip *) 0 ;
6177 wxString result;
6178 PyObject * obj0 = 0 ;
6179 char *kwnames[] = {
6180 (char *) "self", NULL
6181 };
6182
6183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6185 if (SWIG_arg_fail(1)) SWIG_fail;
6186 {
6187 PyThreadState* __tstate = wxPyBeginAllowThreads();
6188 result = (arg1)->GetTip();
6189
6190 wxPyEndAllowThreads(__tstate);
6191 if (PyErr_Occurred()) SWIG_fail;
6192 }
6193 {
6194 #if wxUSE_UNICODE
6195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6196 #else
6197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6198 #endif
6199 }
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj;
6208 wxToolTip *arg1 = (wxToolTip *) 0 ;
6209 wxWindow *result;
6210 PyObject * obj0 = 0 ;
6211 char *kwnames[] = {
6212 (char *) "self", NULL
6213 };
6214
6215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6217 if (SWIG_arg_fail(1)) SWIG_fail;
6218 {
6219 PyThreadState* __tstate = wxPyBeginAllowThreads();
6220 result = (wxWindow *)(arg1)->GetWindow();
6221
6222 wxPyEndAllowThreads(__tstate);
6223 if (PyErr_Occurred()) SWIG_fail;
6224 }
6225 {
6226 resultobj = wxPyMake_wxObject(result, 0);
6227 }
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6235 PyObject *resultobj;
6236 bool arg1 ;
6237 PyObject * obj0 = 0 ;
6238 char *kwnames[] = {
6239 (char *) "flag", NULL
6240 };
6241
6242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6243 {
6244 arg1 = (bool)(SWIG_As_bool(obj0));
6245 if (SWIG_arg_fail(1)) SWIG_fail;
6246 }
6247 {
6248 PyThreadState* __tstate = wxPyBeginAllowThreads();
6249 wxToolTip::Enable(arg1);
6250
6251 wxPyEndAllowThreads(__tstate);
6252 if (PyErr_Occurred()) SWIG_fail;
6253 }
6254 Py_INCREF(Py_None); resultobj = Py_None;
6255 return resultobj;
6256 fail:
6257 return NULL;
6258 }
6259
6260
6261 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6262 PyObject *resultobj;
6263 long arg1 ;
6264 PyObject * obj0 = 0 ;
6265 char *kwnames[] = {
6266 (char *) "milliseconds", NULL
6267 };
6268
6269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6270 {
6271 arg1 = (long)(SWIG_As_long(obj0));
6272 if (SWIG_arg_fail(1)) SWIG_fail;
6273 }
6274 {
6275 PyThreadState* __tstate = wxPyBeginAllowThreads();
6276 wxToolTip::SetDelay(arg1);
6277
6278 wxPyEndAllowThreads(__tstate);
6279 if (PyErr_Occurred()) SWIG_fail;
6280 }
6281 Py_INCREF(Py_None); resultobj = Py_None;
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6289 PyObject *obj;
6290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6291 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6292 Py_INCREF(obj);
6293 return Py_BuildValue((char *)"");
6294 }
6295 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6296 PyObject *resultobj;
6297 wxWindow *arg1 = (wxWindow *) 0 ;
6298 wxSize *arg2 = 0 ;
6299 wxCaret *result;
6300 wxSize temp2 ;
6301 PyObject * obj0 = 0 ;
6302 PyObject * obj1 = 0 ;
6303 char *kwnames[] = {
6304 (char *) "window",(char *) "size", NULL
6305 };
6306
6307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6309 if (SWIG_arg_fail(1)) SWIG_fail;
6310 {
6311 arg2 = &temp2;
6312 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6313 }
6314 {
6315 if (!wxPyCheckForApp()) SWIG_fail;
6316 PyThreadState* __tstate = wxPyBeginAllowThreads();
6317 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6318
6319 wxPyEndAllowThreads(__tstate);
6320 if (PyErr_Occurred()) SWIG_fail;
6321 }
6322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6323 return resultobj;
6324 fail:
6325 return NULL;
6326 }
6327
6328
6329 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6330 PyObject *resultobj;
6331 wxCaret *arg1 = (wxCaret *) 0 ;
6332 PyObject * obj0 = 0 ;
6333 char *kwnames[] = {
6334 (char *) "self", NULL
6335 };
6336
6337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6339 if (SWIG_arg_fail(1)) SWIG_fail;
6340 {
6341 PyThreadState* __tstate = wxPyBeginAllowThreads();
6342 delete arg1;
6343
6344 wxPyEndAllowThreads(__tstate);
6345 if (PyErr_Occurred()) SWIG_fail;
6346 }
6347 Py_INCREF(Py_None); resultobj = Py_None;
6348 return resultobj;
6349 fail:
6350 return NULL;
6351 }
6352
6353
6354 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6355 PyObject *resultobj;
6356 wxCaret *arg1 = (wxCaret *) 0 ;
6357 bool result;
6358 PyObject * obj0 = 0 ;
6359 char *kwnames[] = {
6360 (char *) "self", NULL
6361 };
6362
6363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6365 if (SWIG_arg_fail(1)) SWIG_fail;
6366 {
6367 PyThreadState* __tstate = wxPyBeginAllowThreads();
6368 result = (bool)(arg1)->IsOk();
6369
6370 wxPyEndAllowThreads(__tstate);
6371 if (PyErr_Occurred()) SWIG_fail;
6372 }
6373 {
6374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6375 }
6376 return resultobj;
6377 fail:
6378 return NULL;
6379 }
6380
6381
6382 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6383 PyObject *resultobj;
6384 wxCaret *arg1 = (wxCaret *) 0 ;
6385 bool result;
6386 PyObject * obj0 = 0 ;
6387 char *kwnames[] = {
6388 (char *) "self", NULL
6389 };
6390
6391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6393 if (SWIG_arg_fail(1)) SWIG_fail;
6394 {
6395 PyThreadState* __tstate = wxPyBeginAllowThreads();
6396 result = (bool)(arg1)->IsVisible();
6397
6398 wxPyEndAllowThreads(__tstate);
6399 if (PyErr_Occurred()) SWIG_fail;
6400 }
6401 {
6402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6403 }
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6411 PyObject *resultobj;
6412 wxCaret *arg1 = (wxCaret *) 0 ;
6413 wxPoint result;
6414 PyObject * obj0 = 0 ;
6415 char *kwnames[] = {
6416 (char *) "self", NULL
6417 };
6418
6419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",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 = (arg1)->GetPosition();
6425
6426 wxPyEndAllowThreads(__tstate);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 {
6430 wxPoint * resultptr;
6431 resultptr = new wxPoint((wxPoint &)(result));
6432 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6433 }
6434 return resultobj;
6435 fail:
6436 return NULL;
6437 }
6438
6439
6440 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6441 PyObject *resultobj;
6442 wxCaret *arg1 = (wxCaret *) 0 ;
6443 int *arg2 = (int *) 0 ;
6444 int *arg3 = (int *) 0 ;
6445 int temp2 ;
6446 int res2 = 0 ;
6447 int temp3 ;
6448 int res3 = 0 ;
6449 PyObject * obj0 = 0 ;
6450 char *kwnames[] = {
6451 (char *) "self", NULL
6452 };
6453
6454 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6455 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6458 if (SWIG_arg_fail(1)) SWIG_fail;
6459 {
6460 PyThreadState* __tstate = wxPyBeginAllowThreads();
6461 (arg1)->GetPosition(arg2,arg3);
6462
6463 wxPyEndAllowThreads(__tstate);
6464 if (PyErr_Occurred()) SWIG_fail;
6465 }
6466 Py_INCREF(Py_None); resultobj = Py_None;
6467 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6468 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6469 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6470 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6471 return resultobj;
6472 fail:
6473 return NULL;
6474 }
6475
6476
6477 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6478 PyObject *resultobj;
6479 wxCaret *arg1 = (wxCaret *) 0 ;
6480 wxSize result;
6481 PyObject * obj0 = 0 ;
6482 char *kwnames[] = {
6483 (char *) "self", NULL
6484 };
6485
6486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6488 if (SWIG_arg_fail(1)) SWIG_fail;
6489 {
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = (arg1)->GetSize();
6492
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 {
6497 wxSize * resultptr;
6498 resultptr = new wxSize((wxSize &)(result));
6499 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6500 }
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj;
6509 wxCaret *arg1 = (wxCaret *) 0 ;
6510 int *arg2 = (int *) 0 ;
6511 int *arg3 = (int *) 0 ;
6512 int temp2 ;
6513 int res2 = 0 ;
6514 int temp3 ;
6515 int res3 = 0 ;
6516 PyObject * obj0 = 0 ;
6517 char *kwnames[] = {
6518 (char *) "self", NULL
6519 };
6520
6521 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6522 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6525 if (SWIG_arg_fail(1)) SWIG_fail;
6526 {
6527 PyThreadState* __tstate = wxPyBeginAllowThreads();
6528 (arg1)->GetSize(arg2,arg3);
6529
6530 wxPyEndAllowThreads(__tstate);
6531 if (PyErr_Occurred()) SWIG_fail;
6532 }
6533 Py_INCREF(Py_None); resultobj = Py_None;
6534 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6535 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6536 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6537 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6538 return resultobj;
6539 fail:
6540 return NULL;
6541 }
6542
6543
6544 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6545 PyObject *resultobj;
6546 wxCaret *arg1 = (wxCaret *) 0 ;
6547 wxWindow *result;
6548 PyObject * obj0 = 0 ;
6549 char *kwnames[] = {
6550 (char *) "self", NULL
6551 };
6552
6553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6555 if (SWIG_arg_fail(1)) SWIG_fail;
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = (wxWindow *)(arg1)->GetWindow();
6559
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 {
6564 resultobj = wxPyMake_wxObject(result, 0);
6565 }
6566 return resultobj;
6567 fail:
6568 return NULL;
6569 }
6570
6571
6572 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6573 PyObject *resultobj;
6574 wxCaret *arg1 = (wxCaret *) 0 ;
6575 int arg2 ;
6576 int arg3 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 PyObject * obj2 = 0 ;
6580 char *kwnames[] = {
6581 (char *) "self",(char *) "x",(char *) "y", NULL
6582 };
6583
6584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6586 if (SWIG_arg_fail(1)) SWIG_fail;
6587 {
6588 arg2 = (int)(SWIG_As_int(obj1));
6589 if (SWIG_arg_fail(2)) SWIG_fail;
6590 }
6591 {
6592 arg3 = (int)(SWIG_As_int(obj2));
6593 if (SWIG_arg_fail(3)) SWIG_fail;
6594 }
6595 {
6596 PyThreadState* __tstate = wxPyBeginAllowThreads();
6597 (arg1)->Move(arg2,arg3);
6598
6599 wxPyEndAllowThreads(__tstate);
6600 if (PyErr_Occurred()) SWIG_fail;
6601 }
6602 Py_INCREF(Py_None); resultobj = Py_None;
6603 return resultobj;
6604 fail:
6605 return NULL;
6606 }
6607
6608
6609 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6610 PyObject *resultobj;
6611 wxCaret *arg1 = (wxCaret *) 0 ;
6612 wxPoint *arg2 = 0 ;
6613 wxPoint temp2 ;
6614 PyObject * obj0 = 0 ;
6615 PyObject * obj1 = 0 ;
6616 char *kwnames[] = {
6617 (char *) "self",(char *) "pt", NULL
6618 };
6619
6620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6622 if (SWIG_arg_fail(1)) SWIG_fail;
6623 {
6624 arg2 = &temp2;
6625 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6626 }
6627 {
6628 PyThreadState* __tstate = wxPyBeginAllowThreads();
6629 (arg1)->Move((wxPoint const &)*arg2);
6630
6631 wxPyEndAllowThreads(__tstate);
6632 if (PyErr_Occurred()) SWIG_fail;
6633 }
6634 Py_INCREF(Py_None); resultobj = Py_None;
6635 return resultobj;
6636 fail:
6637 return NULL;
6638 }
6639
6640
6641 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6642 PyObject *resultobj;
6643 wxCaret *arg1 = (wxCaret *) 0 ;
6644 int arg2 ;
6645 int arg3 ;
6646 PyObject * obj0 = 0 ;
6647 PyObject * obj1 = 0 ;
6648 PyObject * obj2 = 0 ;
6649 char *kwnames[] = {
6650 (char *) "self",(char *) "width",(char *) "height", NULL
6651 };
6652
6653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6655 if (SWIG_arg_fail(1)) SWIG_fail;
6656 {
6657 arg2 = (int)(SWIG_As_int(obj1));
6658 if (SWIG_arg_fail(2)) SWIG_fail;
6659 }
6660 {
6661 arg3 = (int)(SWIG_As_int(obj2));
6662 if (SWIG_arg_fail(3)) SWIG_fail;
6663 }
6664 {
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 (arg1)->SetSize(arg2,arg3);
6667
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 Py_INCREF(Py_None); resultobj = Py_None;
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj;
6680 wxCaret *arg1 = (wxCaret *) 0 ;
6681 wxSize *arg2 = 0 ;
6682 wxSize temp2 ;
6683 PyObject * obj0 = 0 ;
6684 PyObject * obj1 = 0 ;
6685 char *kwnames[] = {
6686 (char *) "self",(char *) "size", NULL
6687 };
6688
6689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6691 if (SWIG_arg_fail(1)) SWIG_fail;
6692 {
6693 arg2 = &temp2;
6694 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6695 }
6696 {
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 (arg1)->SetSize((wxSize const &)*arg2);
6699
6700 wxPyEndAllowThreads(__tstate);
6701 if (PyErr_Occurred()) SWIG_fail;
6702 }
6703 Py_INCREF(Py_None); resultobj = Py_None;
6704 return resultobj;
6705 fail:
6706 return NULL;
6707 }
6708
6709
6710 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6711 PyObject *resultobj;
6712 wxCaret *arg1 = (wxCaret *) 0 ;
6713 int arg2 = (int) true ;
6714 PyObject * obj0 = 0 ;
6715 PyObject * obj1 = 0 ;
6716 char *kwnames[] = {
6717 (char *) "self",(char *) "show", NULL
6718 };
6719
6720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6722 if (SWIG_arg_fail(1)) SWIG_fail;
6723 if (obj1) {
6724 {
6725 arg2 = (int)(SWIG_As_int(obj1));
6726 if (SWIG_arg_fail(2)) SWIG_fail;
6727 }
6728 }
6729 {
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 (arg1)->Show(arg2);
6732
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 Py_INCREF(Py_None); resultobj = Py_None;
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj;
6745 wxCaret *arg1 = (wxCaret *) 0 ;
6746 PyObject * obj0 = 0 ;
6747 char *kwnames[] = {
6748 (char *) "self", NULL
6749 };
6750
6751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6753 if (SWIG_arg_fail(1)) SWIG_fail;
6754 {
6755 PyThreadState* __tstate = wxPyBeginAllowThreads();
6756 (arg1)->Hide();
6757
6758 wxPyEndAllowThreads(__tstate);
6759 if (PyErr_Occurred()) SWIG_fail;
6760 }
6761 Py_INCREF(Py_None); resultobj = Py_None;
6762 return resultobj;
6763 fail:
6764 return NULL;
6765 }
6766
6767
6768 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6769 PyObject *obj;
6770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6771 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6772 Py_INCREF(obj);
6773 return Py_BuildValue((char *)"");
6774 }
6775 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6776 PyObject *resultobj;
6777 int result;
6778 char *kwnames[] = {
6779 NULL
6780 };
6781
6782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6783 {
6784 PyThreadState* __tstate = wxPyBeginAllowThreads();
6785 result = (int)wxCaret_GetBlinkTime();
6786
6787 wxPyEndAllowThreads(__tstate);
6788 if (PyErr_Occurred()) SWIG_fail;
6789 }
6790 {
6791 resultobj = SWIG_From_int((int)(result));
6792 }
6793 return resultobj;
6794 fail:
6795 return NULL;
6796 }
6797
6798
6799 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6800 PyObject *resultobj;
6801 int arg1 ;
6802 PyObject * obj0 = 0 ;
6803 char *kwnames[] = {
6804 (char *) "milliseconds", NULL
6805 };
6806
6807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6808 {
6809 arg1 = (int)(SWIG_As_int(obj0));
6810 if (SWIG_arg_fail(1)) SWIG_fail;
6811 }
6812 {
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 wxCaret_SetBlinkTime(arg1);
6815
6816 wxPyEndAllowThreads(__tstate);
6817 if (PyErr_Occurred()) SWIG_fail;
6818 }
6819 Py_INCREF(Py_None); resultobj = Py_None;
6820 return resultobj;
6821 fail:
6822 return NULL;
6823 }
6824
6825
6826 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6827 PyObject *resultobj;
6828 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6829 wxBusyCursor *result;
6830 PyObject * obj0 = 0 ;
6831 char *kwnames[] = {
6832 (char *) "cursor", NULL
6833 };
6834
6835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6836 if (obj0) {
6837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6838 if (SWIG_arg_fail(1)) SWIG_fail;
6839 }
6840 {
6841 if (!wxPyCheckForApp()) SWIG_fail;
6842 PyThreadState* __tstate = wxPyBeginAllowThreads();
6843 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6844
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj;
6857 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6858 PyObject * obj0 = 0 ;
6859 char *kwnames[] = {
6860 (char *) "self", NULL
6861 };
6862
6863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6865 if (SWIG_arg_fail(1)) SWIG_fail;
6866 {
6867 PyThreadState* __tstate = wxPyBeginAllowThreads();
6868 delete arg1;
6869
6870 wxPyEndAllowThreads(__tstate);
6871 if (PyErr_Occurred()) SWIG_fail;
6872 }
6873 Py_INCREF(Py_None); resultobj = Py_None;
6874 return resultobj;
6875 fail:
6876 return NULL;
6877 }
6878
6879
6880 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6881 PyObject *obj;
6882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6883 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6884 Py_INCREF(obj);
6885 return Py_BuildValue((char *)"");
6886 }
6887 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6888 PyObject *resultobj;
6889 wxWindow *arg1 = (wxWindow *) NULL ;
6890 wxWindowDisabler *result;
6891 PyObject * obj0 = 0 ;
6892 char *kwnames[] = {
6893 (char *) "winToSkip", NULL
6894 };
6895
6896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6897 if (obj0) {
6898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6899 if (SWIG_arg_fail(1)) SWIG_fail;
6900 }
6901 {
6902 if (!wxPyCheckForApp()) SWIG_fail;
6903 PyThreadState* __tstate = wxPyBeginAllowThreads();
6904 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6905
6906 wxPyEndAllowThreads(__tstate);
6907 if (PyErr_Occurred()) SWIG_fail;
6908 }
6909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6910 return resultobj;
6911 fail:
6912 return NULL;
6913 }
6914
6915
6916 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6917 PyObject *resultobj;
6918 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6919 PyObject * obj0 = 0 ;
6920 char *kwnames[] = {
6921 (char *) "self", NULL
6922 };
6923
6924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6926 if (SWIG_arg_fail(1)) SWIG_fail;
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 delete arg1;
6930
6931 wxPyEndAllowThreads(__tstate);
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 Py_INCREF(Py_None); resultobj = Py_None;
6935 return resultobj;
6936 fail:
6937 return NULL;
6938 }
6939
6940
6941 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6942 PyObject *obj;
6943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6944 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6945 Py_INCREF(obj);
6946 return Py_BuildValue((char *)"");
6947 }
6948 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj;
6950 wxString *arg1 = 0 ;
6951 wxBusyInfo *result;
6952 bool temp1 = false ;
6953 PyObject * obj0 = 0 ;
6954 char *kwnames[] = {
6955 (char *) "message", NULL
6956 };
6957
6958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6959 {
6960 arg1 = wxString_in_helper(obj0);
6961 if (arg1 == NULL) SWIG_fail;
6962 temp1 = true;
6963 }
6964 {
6965 if (!wxPyCheckForApp()) SWIG_fail;
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6968
6969 wxPyEndAllowThreads(__tstate);
6970 if (PyErr_Occurred()) SWIG_fail;
6971 }
6972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6973 {
6974 if (temp1)
6975 delete arg1;
6976 }
6977 return resultobj;
6978 fail:
6979 {
6980 if (temp1)
6981 delete arg1;
6982 }
6983 return NULL;
6984 }
6985
6986
6987 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6988 PyObject *resultobj;
6989 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6990 PyObject * obj0 = 0 ;
6991 char *kwnames[] = {
6992 (char *) "self", NULL
6993 };
6994
6995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6997 if (SWIG_arg_fail(1)) SWIG_fail;
6998 {
6999 PyThreadState* __tstate = wxPyBeginAllowThreads();
7000 delete arg1;
7001
7002 wxPyEndAllowThreads(__tstate);
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 Py_INCREF(Py_None); resultobj = Py_None;
7006 return resultobj;
7007 fail:
7008 return NULL;
7009 }
7010
7011
7012 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7013 PyObject *obj;
7014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7015 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7016 Py_INCREF(obj);
7017 return Py_BuildValue((char *)"");
7018 }
7019 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7020 PyObject *resultobj;
7021 wxStopWatch *result;
7022 char *kwnames[] = {
7023 NULL
7024 };
7025
7026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7027 {
7028 PyThreadState* __tstate = wxPyBeginAllowThreads();
7029 result = (wxStopWatch *)new wxStopWatch();
7030
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7035 return resultobj;
7036 fail:
7037 return NULL;
7038 }
7039
7040
7041 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7042 PyObject *resultobj;
7043 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7044 long arg2 = (long) 0 ;
7045 PyObject * obj0 = 0 ;
7046 PyObject * obj1 = 0 ;
7047 char *kwnames[] = {
7048 (char *) "self",(char *) "t0", NULL
7049 };
7050
7051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7053 if (SWIG_arg_fail(1)) SWIG_fail;
7054 if (obj1) {
7055 {
7056 arg2 = (long)(SWIG_As_long(obj1));
7057 if (SWIG_arg_fail(2)) SWIG_fail;
7058 }
7059 }
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 (arg1)->Start(arg2);
7063
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 Py_INCREF(Py_None); resultobj = Py_None;
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7075 PyObject *resultobj;
7076 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7077 PyObject * obj0 = 0 ;
7078 char *kwnames[] = {
7079 (char *) "self", NULL
7080 };
7081
7082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7084 if (SWIG_arg_fail(1)) SWIG_fail;
7085 {
7086 PyThreadState* __tstate = wxPyBeginAllowThreads();
7087 (arg1)->Pause();
7088
7089 wxPyEndAllowThreads(__tstate);
7090 if (PyErr_Occurred()) SWIG_fail;
7091 }
7092 Py_INCREF(Py_None); resultobj = Py_None;
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7100 PyObject *resultobj;
7101 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7102 PyObject * obj0 = 0 ;
7103 char *kwnames[] = {
7104 (char *) "self", NULL
7105 };
7106
7107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) 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 {
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 (arg1)->Resume();
7113
7114 wxPyEndAllowThreads(__tstate);
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 Py_INCREF(Py_None); resultobj = Py_None;
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj;
7126 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7127 long result;
7128 PyObject * obj0 = 0 ;
7129 char *kwnames[] = {
7130 (char *) "self", NULL
7131 };
7132
7133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7135 if (SWIG_arg_fail(1)) SWIG_fail;
7136 {
7137 PyThreadState* __tstate = wxPyBeginAllowThreads();
7138 result = (long)((wxStopWatch const *)arg1)->Time();
7139
7140 wxPyEndAllowThreads(__tstate);
7141 if (PyErr_Occurred()) SWIG_fail;
7142 }
7143 {
7144 resultobj = SWIG_From_long((long)(result));
7145 }
7146 return resultobj;
7147 fail:
7148 return NULL;
7149 }
7150
7151
7152 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7153 PyObject *obj;
7154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7155 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7156 Py_INCREF(obj);
7157 return Py_BuildValue((char *)"");
7158 }
7159 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7160 PyObject *resultobj;
7161 int arg1 = (int) 9 ;
7162 int arg2 = (int) wxID_FILE1 ;
7163 wxFileHistory *result;
7164 PyObject * obj0 = 0 ;
7165 PyObject * obj1 = 0 ;
7166 char *kwnames[] = {
7167 (char *) "maxFiles",(char *) "idBase", NULL
7168 };
7169
7170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7171 if (obj0) {
7172 {
7173 arg1 = (int)(SWIG_As_int(obj0));
7174 if (SWIG_arg_fail(1)) SWIG_fail;
7175 }
7176 }
7177 if (obj1) {
7178 {
7179 arg2 = (int)(SWIG_As_int(obj1));
7180 if (SWIG_arg_fail(2)) SWIG_fail;
7181 }
7182 }
7183 {
7184 PyThreadState* __tstate = wxPyBeginAllowThreads();
7185 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7186
7187 wxPyEndAllowThreads(__tstate);
7188 if (PyErr_Occurred()) SWIG_fail;
7189 }
7190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7198 PyObject *resultobj;
7199 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7200 PyObject * obj0 = 0 ;
7201 char *kwnames[] = {
7202 (char *) "self", NULL
7203 };
7204
7205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7207 if (SWIG_arg_fail(1)) SWIG_fail;
7208 {
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 delete arg1;
7211
7212 wxPyEndAllowThreads(__tstate);
7213 if (PyErr_Occurred()) SWIG_fail;
7214 }
7215 Py_INCREF(Py_None); resultobj = Py_None;
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj;
7224 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7225 wxString *arg2 = 0 ;
7226 bool temp2 = false ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 char *kwnames[] = {
7230 (char *) "self",(char *) "file", NULL
7231 };
7232
7233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7235 if (SWIG_arg_fail(1)) SWIG_fail;
7236 {
7237 arg2 = wxString_in_helper(obj1);
7238 if (arg2 == NULL) SWIG_fail;
7239 temp2 = true;
7240 }
7241 {
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 (arg1)->AddFileToHistory((wxString const &)*arg2);
7244
7245 wxPyEndAllowThreads(__tstate);
7246 if (PyErr_Occurred()) SWIG_fail;
7247 }
7248 Py_INCREF(Py_None); resultobj = Py_None;
7249 {
7250 if (temp2)
7251 delete arg2;
7252 }
7253 return resultobj;
7254 fail:
7255 {
7256 if (temp2)
7257 delete arg2;
7258 }
7259 return NULL;
7260 }
7261
7262
7263 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7264 PyObject *resultobj;
7265 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7266 int arg2 ;
7267 PyObject * obj0 = 0 ;
7268 PyObject * obj1 = 0 ;
7269 char *kwnames[] = {
7270 (char *) "self",(char *) "i", NULL
7271 };
7272
7273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7275 if (SWIG_arg_fail(1)) SWIG_fail;
7276 {
7277 arg2 = (int)(SWIG_As_int(obj1));
7278 if (SWIG_arg_fail(2)) SWIG_fail;
7279 }
7280 {
7281 PyThreadState* __tstate = wxPyBeginAllowThreads();
7282 (arg1)->RemoveFileFromHistory(arg2);
7283
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 Py_INCREF(Py_None); resultobj = Py_None;
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj;
7296 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7297 int result;
7298 PyObject * obj0 = 0 ;
7299 char *kwnames[] = {
7300 (char *) "self", NULL
7301 };
7302
7303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7305 if (SWIG_arg_fail(1)) SWIG_fail;
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7309
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 {
7314 resultobj = SWIG_From_int((int)(result));
7315 }
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7323 PyObject *resultobj;
7324 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7325 wxMenu *arg2 = (wxMenu *) 0 ;
7326 PyObject * obj0 = 0 ;
7327 PyObject * obj1 = 0 ;
7328 char *kwnames[] = {
7329 (char *) "self",(char *) "menu", NULL
7330 };
7331
7332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7334 if (SWIG_arg_fail(1)) SWIG_fail;
7335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7336 if (SWIG_arg_fail(2)) SWIG_fail;
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 (arg1)->UseMenu(arg2);
7340
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 Py_INCREF(Py_None); resultobj = Py_None;
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj;
7353 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7354 wxMenu *arg2 = (wxMenu *) 0 ;
7355 PyObject * obj0 = 0 ;
7356 PyObject * obj1 = 0 ;
7357 char *kwnames[] = {
7358 (char *) "self",(char *) "menu", NULL
7359 };
7360
7361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7363 if (SWIG_arg_fail(1)) SWIG_fail;
7364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7365 if (SWIG_arg_fail(2)) SWIG_fail;
7366 {
7367 PyThreadState* __tstate = wxPyBeginAllowThreads();
7368 (arg1)->RemoveMenu(arg2);
7369
7370 wxPyEndAllowThreads(__tstate);
7371 if (PyErr_Occurred()) SWIG_fail;
7372 }
7373 Py_INCREF(Py_None); resultobj = Py_None;
7374 return resultobj;
7375 fail:
7376 return NULL;
7377 }
7378
7379
7380 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7381 PyObject *resultobj;
7382 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7383 wxConfigBase *arg2 = 0 ;
7384 PyObject * obj0 = 0 ;
7385 PyObject * obj1 = 0 ;
7386 char *kwnames[] = {
7387 (char *) "self",(char *) "config", NULL
7388 };
7389
7390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7392 if (SWIG_arg_fail(1)) SWIG_fail;
7393 {
7394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7395 if (SWIG_arg_fail(2)) SWIG_fail;
7396 if (arg2 == NULL) {
7397 SWIG_null_ref("wxConfigBase");
7398 }
7399 if (SWIG_arg_fail(2)) SWIG_fail;
7400 }
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 (arg1)->Load(*arg2);
7404
7405 wxPyEndAllowThreads(__tstate);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 Py_INCREF(Py_None); resultobj = Py_None;
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj;
7417 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7418 wxConfigBase *arg2 = 0 ;
7419 PyObject * obj0 = 0 ;
7420 PyObject * obj1 = 0 ;
7421 char *kwnames[] = {
7422 (char *) "self",(char *) "config", NULL
7423 };
7424
7425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7427 if (SWIG_arg_fail(1)) SWIG_fail;
7428 {
7429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7430 if (SWIG_arg_fail(2)) SWIG_fail;
7431 if (arg2 == NULL) {
7432 SWIG_null_ref("wxConfigBase");
7433 }
7434 if (SWIG_arg_fail(2)) SWIG_fail;
7435 }
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 (arg1)->Save(*arg2);
7439
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 Py_INCREF(Py_None); resultobj = Py_None;
7444 return resultobj;
7445 fail:
7446 return NULL;
7447 }
7448
7449
7450 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7451 PyObject *resultobj;
7452 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7453 PyObject * obj0 = 0 ;
7454 char *kwnames[] = {
7455 (char *) "self", NULL
7456 };
7457
7458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7460 if (SWIG_arg_fail(1)) SWIG_fail;
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 (arg1)->AddFilesToMenu();
7464
7465 wxPyEndAllowThreads(__tstate);
7466 if (PyErr_Occurred()) SWIG_fail;
7467 }
7468 Py_INCREF(Py_None); resultobj = Py_None;
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7476 PyObject *resultobj;
7477 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7478 wxMenu *arg2 = (wxMenu *) 0 ;
7479 PyObject * obj0 = 0 ;
7480 PyObject * obj1 = 0 ;
7481 char *kwnames[] = {
7482 (char *) "self",(char *) "menu", NULL
7483 };
7484
7485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7487 if (SWIG_arg_fail(1)) SWIG_fail;
7488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7489 if (SWIG_arg_fail(2)) SWIG_fail;
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 (arg1)->AddFilesToMenu(arg2);
7493
7494 wxPyEndAllowThreads(__tstate);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 Py_INCREF(Py_None); resultobj = Py_None;
7498 return resultobj;
7499 fail:
7500 return NULL;
7501 }
7502
7503
7504 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7505 PyObject *resultobj;
7506 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7507 int arg2 ;
7508 wxString result;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 char *kwnames[] = {
7512 (char *) "self",(char *) "i", NULL
7513 };
7514
7515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7517 if (SWIG_arg_fail(1)) SWIG_fail;
7518 {
7519 arg2 = (int)(SWIG_As_int(obj1));
7520 if (SWIG_arg_fail(2)) SWIG_fail;
7521 }
7522 {
7523 PyThreadState* __tstate = wxPyBeginAllowThreads();
7524 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7525
7526 wxPyEndAllowThreads(__tstate);
7527 if (PyErr_Occurred()) SWIG_fail;
7528 }
7529 {
7530 #if wxUSE_UNICODE
7531 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7532 #else
7533 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7534 #endif
7535 }
7536 return resultobj;
7537 fail:
7538 return NULL;
7539 }
7540
7541
7542 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7543 PyObject *resultobj;
7544 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7545 int result;
7546 PyObject * obj0 = 0 ;
7547 char *kwnames[] = {
7548 (char *) "self", NULL
7549 };
7550
7551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7553 if (SWIG_arg_fail(1)) SWIG_fail;
7554 {
7555 PyThreadState* __tstate = wxPyBeginAllowThreads();
7556 result = (int)((wxFileHistory const *)arg1)->GetCount();
7557
7558 wxPyEndAllowThreads(__tstate);
7559 if (PyErr_Occurred()) SWIG_fail;
7560 }
7561 {
7562 resultobj = SWIG_From_int((int)(result));
7563 }
7564 return resultobj;
7565 fail:
7566 return NULL;
7567 }
7568
7569
7570 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7571 PyObject *obj;
7572 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7573 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7574 Py_INCREF(obj);
7575 return Py_BuildValue((char *)"");
7576 }
7577 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7578 PyObject *resultobj;
7579 wxString *arg1 = 0 ;
7580 wxString const &arg2_defvalue = wxPyEmptyString ;
7581 wxString *arg2 = (wxString *) &arg2_defvalue ;
7582 wxSingleInstanceChecker *result;
7583 bool temp1 = false ;
7584 bool temp2 = false ;
7585 PyObject * obj0 = 0 ;
7586 PyObject * obj1 = 0 ;
7587 char *kwnames[] = {
7588 (char *) "name",(char *) "path", NULL
7589 };
7590
7591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7592 {
7593 arg1 = wxString_in_helper(obj0);
7594 if (arg1 == NULL) SWIG_fail;
7595 temp1 = true;
7596 }
7597 if (obj1) {
7598 {
7599 arg2 = wxString_in_helper(obj1);
7600 if (arg2 == NULL) SWIG_fail;
7601 temp2 = true;
7602 }
7603 }
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7607
7608 wxPyEndAllowThreads(__tstate);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7612 {
7613 if (temp1)
7614 delete arg1;
7615 }
7616 {
7617 if (temp2)
7618 delete arg2;
7619 }
7620 return resultobj;
7621 fail:
7622 {
7623 if (temp1)
7624 delete arg1;
7625 }
7626 {
7627 if (temp2)
7628 delete arg2;
7629 }
7630 return NULL;
7631 }
7632
7633
7634 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7635 PyObject *resultobj;
7636 wxSingleInstanceChecker *result;
7637 char *kwnames[] = {
7638 NULL
7639 };
7640
7641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7642 {
7643 PyThreadState* __tstate = wxPyBeginAllowThreads();
7644 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7645
7646 wxPyEndAllowThreads(__tstate);
7647 if (PyErr_Occurred()) SWIG_fail;
7648 }
7649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7650 return resultobj;
7651 fail:
7652 return NULL;
7653 }
7654
7655
7656 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7657 PyObject *resultobj;
7658 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7659 PyObject * obj0 = 0 ;
7660 char *kwnames[] = {
7661 (char *) "self", NULL
7662 };
7663
7664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7666 if (SWIG_arg_fail(1)) SWIG_fail;
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 delete arg1;
7670
7671 wxPyEndAllowThreads(__tstate);
7672 if (PyErr_Occurred()) SWIG_fail;
7673 }
7674 Py_INCREF(Py_None); resultobj = Py_None;
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7682 PyObject *resultobj;
7683 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7684 wxString *arg2 = 0 ;
7685 wxString const &arg3_defvalue = wxPyEmptyString ;
7686 wxString *arg3 = (wxString *) &arg3_defvalue ;
7687 bool result;
7688 bool temp2 = false ;
7689 bool temp3 = false ;
7690 PyObject * obj0 = 0 ;
7691 PyObject * obj1 = 0 ;
7692 PyObject * obj2 = 0 ;
7693 char *kwnames[] = {
7694 (char *) "self",(char *) "name",(char *) "path", NULL
7695 };
7696
7697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7699 if (SWIG_arg_fail(1)) SWIG_fail;
7700 {
7701 arg2 = wxString_in_helper(obj1);
7702 if (arg2 == NULL) SWIG_fail;
7703 temp2 = true;
7704 }
7705 if (obj2) {
7706 {
7707 arg3 = wxString_in_helper(obj2);
7708 if (arg3 == NULL) SWIG_fail;
7709 temp3 = true;
7710 }
7711 }
7712 {
7713 PyThreadState* __tstate = wxPyBeginAllowThreads();
7714 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7715
7716 wxPyEndAllowThreads(__tstate);
7717 if (PyErr_Occurred()) SWIG_fail;
7718 }
7719 {
7720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7721 }
7722 {
7723 if (temp2)
7724 delete arg2;
7725 }
7726 {
7727 if (temp3)
7728 delete arg3;
7729 }
7730 return resultobj;
7731 fail:
7732 {
7733 if (temp2)
7734 delete arg2;
7735 }
7736 {
7737 if (temp3)
7738 delete arg3;
7739 }
7740 return NULL;
7741 }
7742
7743
7744 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7745 PyObject *resultobj;
7746 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7747 bool result;
7748 PyObject * obj0 = 0 ;
7749 char *kwnames[] = {
7750 (char *) "self", NULL
7751 };
7752
7753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
7758 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7759
7760 wxPyEndAllowThreads(__tstate);
7761 if (PyErr_Occurred()) SWIG_fail;
7762 }
7763 {
7764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7765 }
7766 return resultobj;
7767 fail:
7768 return NULL;
7769 }
7770
7771
7772 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7773 PyObject *obj;
7774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7775 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7776 Py_INCREF(obj);
7777 return Py_BuildValue((char *)"");
7778 }
7779 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7780 PyObject *resultobj;
7781 wxWindow *arg1 = (wxWindow *) 0 ;
7782 wxDC *arg2 = 0 ;
7783 int arg3 ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 PyObject * obj2 = 0 ;
7787 char *kwnames[] = {
7788 (char *) "window",(char *) "dc",(char *) "method", NULL
7789 };
7790
7791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DrawWindowOnDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
7792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7793 if (SWIG_arg_fail(1)) SWIG_fail;
7794 {
7795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7796 if (SWIG_arg_fail(2)) SWIG_fail;
7797 if (arg2 == NULL) {
7798 SWIG_null_ref("wxDC");
7799 }
7800 if (SWIG_arg_fail(2)) SWIG_fail;
7801 }
7802 {
7803 arg3 = (int)(SWIG_As_int(obj2));
7804 if (SWIG_arg_fail(3)) SWIG_fail;
7805 }
7806 {
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 wxDrawWindowOnDC(arg1,(wxDC const &)*arg2,arg3);
7809
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 Py_INCREF(Py_None); resultobj = Py_None;
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj;
7822 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7823 PyObject * obj0 = 0 ;
7824 char *kwnames[] = {
7825 (char *) "self", NULL
7826 };
7827
7828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7830 if (SWIG_arg_fail(1)) SWIG_fail;
7831 {
7832 PyThreadState* __tstate = wxPyBeginAllowThreads();
7833 delete arg1;
7834
7835 wxPyEndAllowThreads(__tstate);
7836 if (PyErr_Occurred()) SWIG_fail;
7837 }
7838 Py_INCREF(Py_None); resultobj = Py_None;
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj;
7847 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7848 wxString result;
7849 PyObject * obj0 = 0 ;
7850 char *kwnames[] = {
7851 (char *) "self", NULL
7852 };
7853
7854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7856 if (SWIG_arg_fail(1)) SWIG_fail;
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 result = (arg1)->GetTip();
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 {
7865 #if wxUSE_UNICODE
7866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7867 #else
7868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7869 #endif
7870 }
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7878 PyObject *resultobj;
7879 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7880 size_t result;
7881 PyObject * obj0 = 0 ;
7882 char *kwnames[] = {
7883 (char *) "self", NULL
7884 };
7885
7886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7888 if (SWIG_arg_fail(1)) SWIG_fail;
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 result = (size_t)(arg1)->GetCurrentTip();
7892
7893 wxPyEndAllowThreads(__tstate);
7894 if (PyErr_Occurred()) SWIG_fail;
7895 }
7896 {
7897 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7898 }
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7906 PyObject *resultobj;
7907 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7908 wxString *arg2 = 0 ;
7909 wxString result;
7910 bool temp2 = false ;
7911 PyObject * obj0 = 0 ;
7912 PyObject * obj1 = 0 ;
7913 char *kwnames[] = {
7914 (char *) "self",(char *) "tip", NULL
7915 };
7916
7917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7919 if (SWIG_arg_fail(1)) SWIG_fail;
7920 {
7921 arg2 = wxString_in_helper(obj1);
7922 if (arg2 == NULL) SWIG_fail;
7923 temp2 = true;
7924 }
7925 {
7926 PyThreadState* __tstate = wxPyBeginAllowThreads();
7927 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7928
7929 wxPyEndAllowThreads(__tstate);
7930 if (PyErr_Occurred()) SWIG_fail;
7931 }
7932 {
7933 #if wxUSE_UNICODE
7934 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7935 #else
7936 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7937 #endif
7938 }
7939 {
7940 if (temp2)
7941 delete arg2;
7942 }
7943 return resultobj;
7944 fail:
7945 {
7946 if (temp2)
7947 delete arg2;
7948 }
7949 return NULL;
7950 }
7951
7952
7953 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7954 PyObject *obj;
7955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7956 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7957 Py_INCREF(obj);
7958 return Py_BuildValue((char *)"");
7959 }
7960 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7961 PyObject *resultobj;
7962 size_t arg1 ;
7963 wxPyTipProvider *result;
7964 PyObject * obj0 = 0 ;
7965 char *kwnames[] = {
7966 (char *) "currentTip", NULL
7967 };
7968
7969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7970 {
7971 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7972 if (SWIG_arg_fail(1)) SWIG_fail;
7973 }
7974 {
7975 PyThreadState* __tstate = wxPyBeginAllowThreads();
7976 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7977
7978 wxPyEndAllowThreads(__tstate);
7979 if (PyErr_Occurred()) SWIG_fail;
7980 }
7981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7982 return resultobj;
7983 fail:
7984 return NULL;
7985 }
7986
7987
7988 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7989 PyObject *resultobj;
7990 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7991 PyObject *arg2 = (PyObject *) 0 ;
7992 PyObject *arg3 = (PyObject *) 0 ;
7993 PyObject * obj0 = 0 ;
7994 PyObject * obj1 = 0 ;
7995 PyObject * obj2 = 0 ;
7996 char *kwnames[] = {
7997 (char *) "self",(char *) "self",(char *) "_class", NULL
7998 };
7999
8000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8002 if (SWIG_arg_fail(1)) SWIG_fail;
8003 arg2 = obj1;
8004 arg3 = obj2;
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 (arg1)->_setCallbackInfo(arg2,arg3);
8008
8009 wxPyEndAllowThreads(__tstate);
8010 if (PyErr_Occurred()) SWIG_fail;
8011 }
8012 Py_INCREF(Py_None); resultobj = Py_None;
8013 return resultobj;
8014 fail:
8015 return NULL;
8016 }
8017
8018
8019 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8020 PyObject *obj;
8021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8022 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8023 Py_INCREF(obj);
8024 return Py_BuildValue((char *)"");
8025 }
8026 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8027 PyObject *resultobj;
8028 wxWindow *arg1 = (wxWindow *) 0 ;
8029 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8030 bool arg3 = (bool) true ;
8031 bool result;
8032 PyObject * obj0 = 0 ;
8033 PyObject * obj1 = 0 ;
8034 PyObject * obj2 = 0 ;
8035 char *kwnames[] = {
8036 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8037 };
8038
8039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8041 if (SWIG_arg_fail(1)) SWIG_fail;
8042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8043 if (SWIG_arg_fail(2)) SWIG_fail;
8044 if (obj2) {
8045 {
8046 arg3 = (bool)(SWIG_As_bool(obj2));
8047 if (SWIG_arg_fail(3)) SWIG_fail;
8048 }
8049 }
8050 {
8051 if (!wxPyCheckForApp()) SWIG_fail;
8052 PyThreadState* __tstate = wxPyBeginAllowThreads();
8053 result = (bool)wxShowTip(arg1,arg2,arg3);
8054
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 {
8059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8060 }
8061 return resultobj;
8062 fail:
8063 return NULL;
8064 }
8065
8066
8067 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8068 PyObject *resultobj;
8069 wxString *arg1 = 0 ;
8070 size_t arg2 ;
8071 wxTipProvider *result;
8072 bool temp1 = false ;
8073 PyObject * obj0 = 0 ;
8074 PyObject * obj1 = 0 ;
8075 char *kwnames[] = {
8076 (char *) "filename",(char *) "currentTip", NULL
8077 };
8078
8079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8080 {
8081 arg1 = wxString_in_helper(obj0);
8082 if (arg1 == NULL) SWIG_fail;
8083 temp1 = true;
8084 }
8085 {
8086 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8087 if (SWIG_arg_fail(2)) SWIG_fail;
8088 }
8089 {
8090 if (!wxPyCheckForApp()) SWIG_fail;
8091 PyThreadState* __tstate = wxPyBeginAllowThreads();
8092 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8093
8094 wxPyEndAllowThreads(__tstate);
8095 if (PyErr_Occurred()) SWIG_fail;
8096 }
8097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8098 {
8099 if (temp1)
8100 delete arg1;
8101 }
8102 return resultobj;
8103 fail:
8104 {
8105 if (temp1)
8106 delete arg1;
8107 }
8108 return NULL;
8109 }
8110
8111
8112 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8113 PyObject *resultobj;
8114 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8115 int arg2 = (int) -1 ;
8116 wxPyTimer *result;
8117 PyObject * obj0 = 0 ;
8118 PyObject * obj1 = 0 ;
8119 char *kwnames[] = {
8120 (char *) "owner",(char *) "id", NULL
8121 };
8122
8123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8124 if (obj0) {
8125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8126 if (SWIG_arg_fail(1)) SWIG_fail;
8127 }
8128 if (obj1) {
8129 {
8130 arg2 = (int)(SWIG_As_int(obj1));
8131 if (SWIG_arg_fail(2)) SWIG_fail;
8132 }
8133 }
8134 {
8135 if (!wxPyCheckForApp()) SWIG_fail;
8136 PyThreadState* __tstate = wxPyBeginAllowThreads();
8137 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8138
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8150 PyObject *resultobj;
8151 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8152 PyObject * obj0 = 0 ;
8153 char *kwnames[] = {
8154 (char *) "self", NULL
8155 };
8156
8157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8159 if (SWIG_arg_fail(1)) SWIG_fail;
8160 {
8161 PyThreadState* __tstate = wxPyBeginAllowThreads();
8162 delete arg1;
8163
8164 wxPyEndAllowThreads(__tstate);
8165 if (PyErr_Occurred()) SWIG_fail;
8166 }
8167 Py_INCREF(Py_None); resultobj = Py_None;
8168 return resultobj;
8169 fail:
8170 return NULL;
8171 }
8172
8173
8174 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8175 PyObject *resultobj;
8176 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8177 PyObject *arg2 = (PyObject *) 0 ;
8178 PyObject *arg3 = (PyObject *) 0 ;
8179 int arg4 = (int) 1 ;
8180 PyObject * obj0 = 0 ;
8181 PyObject * obj1 = 0 ;
8182 PyObject * obj2 = 0 ;
8183 PyObject * obj3 = 0 ;
8184 char *kwnames[] = {
8185 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8186 };
8187
8188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8190 if (SWIG_arg_fail(1)) SWIG_fail;
8191 arg2 = obj1;
8192 arg3 = obj2;
8193 if (obj3) {
8194 {
8195 arg4 = (int)(SWIG_As_int(obj3));
8196 if (SWIG_arg_fail(4)) SWIG_fail;
8197 }
8198 }
8199 {
8200 PyThreadState* __tstate = wxPyBeginAllowThreads();
8201 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8202
8203 wxPyEndAllowThreads(__tstate);
8204 if (PyErr_Occurred()) SWIG_fail;
8205 }
8206 Py_INCREF(Py_None); resultobj = Py_None;
8207 return resultobj;
8208 fail:
8209 return NULL;
8210 }
8211
8212
8213 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8214 PyObject *resultobj;
8215 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8216 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8217 int arg3 = (int) -1 ;
8218 PyObject * obj0 = 0 ;
8219 PyObject * obj1 = 0 ;
8220 PyObject * obj2 = 0 ;
8221 char *kwnames[] = {
8222 (char *) "self",(char *) "owner",(char *) "id", NULL
8223 };
8224
8225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8227 if (SWIG_arg_fail(1)) SWIG_fail;
8228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8229 if (SWIG_arg_fail(2)) SWIG_fail;
8230 if (obj2) {
8231 {
8232 arg3 = (int)(SWIG_As_int(obj2));
8233 if (SWIG_arg_fail(3)) SWIG_fail;
8234 }
8235 }
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 (arg1)->SetOwner(arg2,arg3);
8239
8240 wxPyEndAllowThreads(__tstate);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 Py_INCREF(Py_None); resultobj = Py_None;
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8251 PyObject *resultobj;
8252 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8253 wxEvtHandler *result;
8254 PyObject * obj0 = 0 ;
8255 char *kwnames[] = {
8256 (char *) "self", NULL
8257 };
8258
8259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8261 if (SWIG_arg_fail(1)) SWIG_fail;
8262 {
8263 PyThreadState* __tstate = wxPyBeginAllowThreads();
8264 result = (wxEvtHandler *)(arg1)->GetOwner();
8265
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 {
8270 resultobj = wxPyMake_wxObject(result, 0);
8271 }
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8279 PyObject *resultobj;
8280 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8281 int arg2 = (int) -1 ;
8282 bool arg3 = (bool) false ;
8283 bool result;
8284 PyObject * obj0 = 0 ;
8285 PyObject * obj1 = 0 ;
8286 PyObject * obj2 = 0 ;
8287 char *kwnames[] = {
8288 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8289 };
8290
8291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8293 if (SWIG_arg_fail(1)) SWIG_fail;
8294 if (obj1) {
8295 {
8296 arg2 = (int)(SWIG_As_int(obj1));
8297 if (SWIG_arg_fail(2)) SWIG_fail;
8298 }
8299 }
8300 if (obj2) {
8301 {
8302 arg3 = (bool)(SWIG_As_bool(obj2));
8303 if (SWIG_arg_fail(3)) SWIG_fail;
8304 }
8305 }
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 result = (bool)(arg1)->Start(arg2,arg3);
8309
8310 wxPyEndAllowThreads(__tstate);
8311 if (PyErr_Occurred()) SWIG_fail;
8312 }
8313 {
8314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8315 }
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj;
8324 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8325 PyObject * obj0 = 0 ;
8326 char *kwnames[] = {
8327 (char *) "self", NULL
8328 };
8329
8330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8332 if (SWIG_arg_fail(1)) SWIG_fail;
8333 {
8334 PyThreadState* __tstate = wxPyBeginAllowThreads();
8335 (arg1)->Stop();
8336
8337 wxPyEndAllowThreads(__tstate);
8338 if (PyErr_Occurred()) SWIG_fail;
8339 }
8340 Py_INCREF(Py_None); resultobj = Py_None;
8341 return resultobj;
8342 fail:
8343 return NULL;
8344 }
8345
8346
8347 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8348 PyObject *resultobj;
8349 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8350 bool result;
8351 PyObject * obj0 = 0 ;
8352 char *kwnames[] = {
8353 (char *) "self", NULL
8354 };
8355
8356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8358 if (SWIG_arg_fail(1)) SWIG_fail;
8359 {
8360 PyThreadState* __tstate = wxPyBeginAllowThreads();
8361 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
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_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8376 PyObject *resultobj;
8377 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8378 int result;
8379 PyObject * obj0 = 0 ;
8380 char *kwnames[] = {
8381 (char *) "self", NULL
8382 };
8383
8384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8386 if (SWIG_arg_fail(1)) SWIG_fail;
8387 {
8388 PyThreadState* __tstate = wxPyBeginAllowThreads();
8389 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8390
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 {
8395 resultobj = SWIG_From_int((int)(result));
8396 }
8397 return resultobj;
8398 fail:
8399 return NULL;
8400 }
8401
8402
8403 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8404 PyObject *resultobj;
8405 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8406 bool result;
8407 PyObject * obj0 = 0 ;
8408 char *kwnames[] = {
8409 (char *) "self", NULL
8410 };
8411
8412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8414 if (SWIG_arg_fail(1)) SWIG_fail;
8415 {
8416 PyThreadState* __tstate = wxPyBeginAllowThreads();
8417 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8418
8419 wxPyEndAllowThreads(__tstate);
8420 if (PyErr_Occurred()) SWIG_fail;
8421 }
8422 {
8423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8424 }
8425 return resultobj;
8426 fail:
8427 return NULL;
8428 }
8429
8430
8431 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8432 PyObject *resultobj;
8433 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8434 int result;
8435 PyObject * obj0 = 0 ;
8436 char *kwnames[] = {
8437 (char *) "self", NULL
8438 };
8439
8440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8442 if (SWIG_arg_fail(1)) SWIG_fail;
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (int)((wxPyTimer const *)arg1)->GetId();
8446
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 {
8451 resultobj = SWIG_From_int((int)(result));
8452 }
8453 return resultobj;
8454 fail:
8455 return NULL;
8456 }
8457
8458
8459 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8460 PyObject *obj;
8461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8462 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8463 Py_INCREF(obj);
8464 return Py_BuildValue((char *)"");
8465 }
8466 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8467 PyObject *resultobj;
8468 int arg1 = (int) 0 ;
8469 int arg2 = (int) 0 ;
8470 wxTimerEvent *result;
8471 PyObject * obj0 = 0 ;
8472 PyObject * obj1 = 0 ;
8473 char *kwnames[] = {
8474 (char *) "timerid",(char *) "interval", NULL
8475 };
8476
8477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8478 if (obj0) {
8479 {
8480 arg1 = (int)(SWIG_As_int(obj0));
8481 if (SWIG_arg_fail(1)) SWIG_fail;
8482 }
8483 }
8484 if (obj1) {
8485 {
8486 arg2 = (int)(SWIG_As_int(obj1));
8487 if (SWIG_arg_fail(2)) SWIG_fail;
8488 }
8489 }
8490 {
8491 PyThreadState* __tstate = wxPyBeginAllowThreads();
8492 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8493
8494 wxPyEndAllowThreads(__tstate);
8495 if (PyErr_Occurred()) SWIG_fail;
8496 }
8497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8505 PyObject *resultobj;
8506 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8507 int result;
8508 PyObject * obj0 = 0 ;
8509 char *kwnames[] = {
8510 (char *) "self", NULL
8511 };
8512
8513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8515 if (SWIG_arg_fail(1)) SWIG_fail;
8516 {
8517 PyThreadState* __tstate = wxPyBeginAllowThreads();
8518 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8519
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 {
8524 resultobj = SWIG_From_int((int)(result));
8525 }
8526 return resultobj;
8527 fail:
8528 return NULL;
8529 }
8530
8531
8532 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8533 PyObject *obj;
8534 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8535 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8536 Py_INCREF(obj);
8537 return Py_BuildValue((char *)"");
8538 }
8539 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8540 PyObject *resultobj;
8541 wxTimer *arg1 = 0 ;
8542 wxTimerRunner *result;
8543 PyObject * obj0 = 0 ;
8544
8545 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8546 {
8547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8548 if (SWIG_arg_fail(1)) SWIG_fail;
8549 if (arg1 == NULL) {
8550 SWIG_null_ref("wxTimer");
8551 }
8552 if (SWIG_arg_fail(1)) SWIG_fail;
8553 }
8554 {
8555 if (!wxPyCheckForApp()) SWIG_fail;
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8558
8559 wxPyEndAllowThreads(__tstate);
8560 if (PyErr_Occurred()) SWIG_fail;
8561 }
8562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8563 return resultobj;
8564 fail:
8565 return NULL;
8566 }
8567
8568
8569 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8570 PyObject *resultobj;
8571 wxTimer *arg1 = 0 ;
8572 int arg2 ;
8573 bool arg3 = (bool) false ;
8574 wxTimerRunner *result;
8575 PyObject * obj0 = 0 ;
8576 PyObject * obj1 = 0 ;
8577 PyObject * obj2 = 0 ;
8578
8579 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8580 {
8581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8582 if (SWIG_arg_fail(1)) SWIG_fail;
8583 if (arg1 == NULL) {
8584 SWIG_null_ref("wxTimer");
8585 }
8586 if (SWIG_arg_fail(1)) SWIG_fail;
8587 }
8588 {
8589 arg2 = (int)(SWIG_As_int(obj1));
8590 if (SWIG_arg_fail(2)) SWIG_fail;
8591 }
8592 if (obj2) {
8593 {
8594 arg3 = (bool)(SWIG_As_bool(obj2));
8595 if (SWIG_arg_fail(3)) SWIG_fail;
8596 }
8597 }
8598 {
8599 if (!wxPyCheckForApp()) SWIG_fail;
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8602
8603 wxPyEndAllowThreads(__tstate);
8604 if (PyErr_Occurred()) SWIG_fail;
8605 }
8606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8607 return resultobj;
8608 fail:
8609 return NULL;
8610 }
8611
8612
8613 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8614 int argc;
8615 PyObject *argv[4];
8616 int ii;
8617
8618 argc = PyObject_Length(args);
8619 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8620 argv[ii] = PyTuple_GetItem(args,ii);
8621 }
8622 if (argc == 1) {
8623 int _v;
8624 {
8625 void *ptr = 0;
8626 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8627 _v = 0;
8628 PyErr_Clear();
8629 } else {
8630 _v = (ptr != 0);
8631 }
8632 }
8633 if (_v) {
8634 return _wrap_new_TimerRunner__SWIG_0(self,args);
8635 }
8636 }
8637 if ((argc >= 2) && (argc <= 3)) {
8638 int _v;
8639 {
8640 void *ptr = 0;
8641 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8642 _v = 0;
8643 PyErr_Clear();
8644 } else {
8645 _v = (ptr != 0);
8646 }
8647 }
8648 if (_v) {
8649 _v = SWIG_Check_int(argv[1]);
8650 if (_v) {
8651 if (argc <= 2) {
8652 return _wrap_new_TimerRunner__SWIG_1(self,args);
8653 }
8654 _v = SWIG_Check_bool(argv[2]);
8655 if (_v) {
8656 return _wrap_new_TimerRunner__SWIG_1(self,args);
8657 }
8658 }
8659 }
8660 }
8661
8662 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8663 return NULL;
8664 }
8665
8666
8667 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8668 PyObject *resultobj;
8669 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8670 PyObject * obj0 = 0 ;
8671 char *kwnames[] = {
8672 (char *) "self", NULL
8673 };
8674
8675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8677 if (SWIG_arg_fail(1)) SWIG_fail;
8678 {
8679 PyThreadState* __tstate = wxPyBeginAllowThreads();
8680 delete arg1;
8681
8682 wxPyEndAllowThreads(__tstate);
8683 if (PyErr_Occurred()) SWIG_fail;
8684 }
8685 Py_INCREF(Py_None); resultobj = Py_None;
8686 return resultobj;
8687 fail:
8688 return NULL;
8689 }
8690
8691
8692 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8693 PyObject *resultobj;
8694 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8695 int arg2 ;
8696 bool arg3 = (bool) false ;
8697 PyObject * obj0 = 0 ;
8698 PyObject * obj1 = 0 ;
8699 PyObject * obj2 = 0 ;
8700 char *kwnames[] = {
8701 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8702 };
8703
8704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8706 if (SWIG_arg_fail(1)) SWIG_fail;
8707 {
8708 arg2 = (int)(SWIG_As_int(obj1));
8709 if (SWIG_arg_fail(2)) SWIG_fail;
8710 }
8711 if (obj2) {
8712 {
8713 arg3 = (bool)(SWIG_As_bool(obj2));
8714 if (SWIG_arg_fail(3)) SWIG_fail;
8715 }
8716 }
8717 {
8718 PyThreadState* __tstate = wxPyBeginAllowThreads();
8719 (arg1)->Start(arg2,arg3);
8720
8721 wxPyEndAllowThreads(__tstate);
8722 if (PyErr_Occurred()) SWIG_fail;
8723 }
8724 Py_INCREF(Py_None); resultobj = Py_None;
8725 return resultobj;
8726 fail:
8727 return NULL;
8728 }
8729
8730
8731 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8732 PyObject *obj;
8733 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8734 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8735 Py_INCREF(obj);
8736 return Py_BuildValue((char *)"");
8737 }
8738 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8739 PyObject *resultobj;
8740 wxLog *result;
8741 char *kwnames[] = {
8742 NULL
8743 };
8744
8745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8746 {
8747 PyThreadState* __tstate = wxPyBeginAllowThreads();
8748 result = (wxLog *)new wxLog();
8749
8750 wxPyEndAllowThreads(__tstate);
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8754 return resultobj;
8755 fail:
8756 return NULL;
8757 }
8758
8759
8760 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8761 PyObject *resultobj;
8762 bool result;
8763 char *kwnames[] = {
8764 NULL
8765 };
8766
8767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8768 {
8769 PyThreadState* __tstate = wxPyBeginAllowThreads();
8770 result = (bool)wxLog::IsEnabled();
8771
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 {
8776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8777 }
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8785 PyObject *resultobj;
8786 bool arg1 = (bool) true ;
8787 bool result;
8788 PyObject * obj0 = 0 ;
8789 char *kwnames[] = {
8790 (char *) "doIt", NULL
8791 };
8792
8793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8794 if (obj0) {
8795 {
8796 arg1 = (bool)(SWIG_As_bool(obj0));
8797 if (SWIG_arg_fail(1)) SWIG_fail;
8798 }
8799 }
8800 {
8801 PyThreadState* __tstate = wxPyBeginAllowThreads();
8802 result = (bool)wxLog::EnableLogging(arg1);
8803
8804 wxPyEndAllowThreads(__tstate);
8805 if (PyErr_Occurred()) SWIG_fail;
8806 }
8807 {
8808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8809 }
8810 return resultobj;
8811 fail:
8812 return NULL;
8813 }
8814
8815
8816 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8817 PyObject *resultobj;
8818 wxLogLevel arg1 ;
8819 wxChar *arg2 = (wxChar *) 0 ;
8820 time_t arg3 ;
8821 PyObject * obj0 = 0 ;
8822 PyObject * obj1 = 0 ;
8823 PyObject * obj2 = 0 ;
8824 char *kwnames[] = {
8825 (char *) "level",(char *) "szString",(char *) "t", NULL
8826 };
8827
8828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8829 {
8830 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8831 if (SWIG_arg_fail(1)) SWIG_fail;
8832 }
8833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8834 if (SWIG_arg_fail(2)) SWIG_fail;
8835 {
8836 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8837 if (SWIG_arg_fail(3)) SWIG_fail;
8838 }
8839 {
8840 PyThreadState* __tstate = wxPyBeginAllowThreads();
8841 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8842
8843 wxPyEndAllowThreads(__tstate);
8844 if (PyErr_Occurred()) SWIG_fail;
8845 }
8846 Py_INCREF(Py_None); resultobj = Py_None;
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8854 PyObject *resultobj;
8855 wxLog *arg1 = (wxLog *) 0 ;
8856 PyObject * obj0 = 0 ;
8857 char *kwnames[] = {
8858 (char *) "self", NULL
8859 };
8860
8861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8863 if (SWIG_arg_fail(1)) SWIG_fail;
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 (arg1)->Flush();
8867
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 Py_INCREF(Py_None); resultobj = Py_None;
8872 return resultobj;
8873 fail:
8874 return NULL;
8875 }
8876
8877
8878 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8879 PyObject *resultobj;
8880 char *kwnames[] = {
8881 NULL
8882 };
8883
8884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8885 {
8886 PyThreadState* __tstate = wxPyBeginAllowThreads();
8887 wxLog::FlushActive();
8888
8889 wxPyEndAllowThreads(__tstate);
8890 if (PyErr_Occurred()) SWIG_fail;
8891 }
8892 Py_INCREF(Py_None); resultobj = Py_None;
8893 return resultobj;
8894 fail:
8895 return NULL;
8896 }
8897
8898
8899 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8900 PyObject *resultobj;
8901 wxLog *result;
8902 char *kwnames[] = {
8903 NULL
8904 };
8905
8906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 result = (wxLog *)wxLog::GetActiveTarget();
8910
8911 wxPyEndAllowThreads(__tstate);
8912 if (PyErr_Occurred()) SWIG_fail;
8913 }
8914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8915 return resultobj;
8916 fail:
8917 return NULL;
8918 }
8919
8920
8921 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8922 PyObject *resultobj;
8923 wxLog *arg1 = (wxLog *) 0 ;
8924 wxLog *result;
8925 PyObject * obj0 = 0 ;
8926 char *kwnames[] = {
8927 (char *) "pLogger", NULL
8928 };
8929
8930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8932 if (SWIG_arg_fail(1)) SWIG_fail;
8933 {
8934 PyThreadState* __tstate = wxPyBeginAllowThreads();
8935 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8936
8937 wxPyEndAllowThreads(__tstate);
8938 if (PyErr_Occurred()) SWIG_fail;
8939 }
8940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8941 return resultobj;
8942 fail:
8943 return NULL;
8944 }
8945
8946
8947 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8948 PyObject *resultobj;
8949 char *kwnames[] = {
8950 NULL
8951 };
8952
8953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 wxLog::Suspend();
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 Py_INCREF(Py_None); resultobj = Py_None;
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj;
8970 char *kwnames[] = {
8971 NULL
8972 };
8973
8974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8975 {
8976 PyThreadState* __tstate = wxPyBeginAllowThreads();
8977 wxLog::Resume();
8978
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 Py_INCREF(Py_None); resultobj = Py_None;
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8990 PyObject *resultobj;
8991 bool arg1 = (bool) true ;
8992 PyObject * obj0 = 0 ;
8993 char *kwnames[] = {
8994 (char *) "bVerbose", NULL
8995 };
8996
8997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8998 if (obj0) {
8999 {
9000 arg1 = (bool)(SWIG_As_bool(obj0));
9001 if (SWIG_arg_fail(1)) SWIG_fail;
9002 }
9003 }
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 wxLog::SetVerbose(arg1);
9007
9008 wxPyEndAllowThreads(__tstate);
9009 if (PyErr_Occurred()) SWIG_fail;
9010 }
9011 Py_INCREF(Py_None); resultobj = Py_None;
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj;
9020 wxLogLevel arg1 ;
9021 PyObject * obj0 = 0 ;
9022 char *kwnames[] = {
9023 (char *) "logLevel", NULL
9024 };
9025
9026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9027 {
9028 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9029 if (SWIG_arg_fail(1)) SWIG_fail;
9030 }
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 wxLog::SetLogLevel(arg1);
9034
9035 wxPyEndAllowThreads(__tstate);
9036 if (PyErr_Occurred()) SWIG_fail;
9037 }
9038 Py_INCREF(Py_None); resultobj = Py_None;
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj;
9047 char *kwnames[] = {
9048 NULL
9049 };
9050
9051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9052 {
9053 PyThreadState* __tstate = wxPyBeginAllowThreads();
9054 wxLog::DontCreateOnDemand();
9055
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 Py_INCREF(Py_None); resultobj = Py_None;
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9067 PyObject *resultobj;
9068 wxTraceMask arg1 ;
9069 PyObject * obj0 = 0 ;
9070 char *kwnames[] = {
9071 (char *) "ulMask", NULL
9072 };
9073
9074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9075 {
9076 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9077 if (SWIG_arg_fail(1)) SWIG_fail;
9078 }
9079 {
9080 PyThreadState* __tstate = wxPyBeginAllowThreads();
9081 wxLog::SetTraceMask(arg1);
9082
9083 wxPyEndAllowThreads(__tstate);
9084 if (PyErr_Occurred()) SWIG_fail;
9085 }
9086 Py_INCREF(Py_None); resultobj = Py_None;
9087 return resultobj;
9088 fail:
9089 return NULL;
9090 }
9091
9092
9093 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9094 PyObject *resultobj;
9095 wxString *arg1 = 0 ;
9096 bool temp1 = false ;
9097 PyObject * obj0 = 0 ;
9098 char *kwnames[] = {
9099 (char *) "str", NULL
9100 };
9101
9102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9103 {
9104 arg1 = wxString_in_helper(obj0);
9105 if (arg1 == NULL) SWIG_fail;
9106 temp1 = true;
9107 }
9108 {
9109 PyThreadState* __tstate = wxPyBeginAllowThreads();
9110 wxLog::AddTraceMask((wxString const &)*arg1);
9111
9112 wxPyEndAllowThreads(__tstate);
9113 if (PyErr_Occurred()) SWIG_fail;
9114 }
9115 Py_INCREF(Py_None); resultobj = Py_None;
9116 {
9117 if (temp1)
9118 delete arg1;
9119 }
9120 return resultobj;
9121 fail:
9122 {
9123 if (temp1)
9124 delete arg1;
9125 }
9126 return NULL;
9127 }
9128
9129
9130 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9131 PyObject *resultobj;
9132 wxString *arg1 = 0 ;
9133 bool temp1 = false ;
9134 PyObject * obj0 = 0 ;
9135 char *kwnames[] = {
9136 (char *) "str", NULL
9137 };
9138
9139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9140 {
9141 arg1 = wxString_in_helper(obj0);
9142 if (arg1 == NULL) SWIG_fail;
9143 temp1 = true;
9144 }
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 wxLog::RemoveTraceMask((wxString const &)*arg1);
9148
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 Py_INCREF(Py_None); resultobj = Py_None;
9153 {
9154 if (temp1)
9155 delete arg1;
9156 }
9157 return resultobj;
9158 fail:
9159 {
9160 if (temp1)
9161 delete arg1;
9162 }
9163 return NULL;
9164 }
9165
9166
9167 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9168 PyObject *resultobj;
9169 char *kwnames[] = {
9170 NULL
9171 };
9172
9173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9174 {
9175 PyThreadState* __tstate = wxPyBeginAllowThreads();
9176 wxLog::ClearTraceMasks();
9177
9178 wxPyEndAllowThreads(__tstate);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 Py_INCREF(Py_None); resultobj = Py_None;
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9189 PyObject *resultobj;
9190 wxArrayString *result;
9191 char *kwnames[] = {
9192 NULL
9193 };
9194
9195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 {
9199 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9200 result = (wxArrayString *) &_result_ref;
9201 }
9202
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 {
9207 resultobj = wxArrayString2PyList_helper(*result);
9208 }
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9216 PyObject *resultobj;
9217 wxChar *arg1 = (wxChar *) 0 ;
9218 PyObject * obj0 = 0 ;
9219 char *kwnames[] = {
9220 (char *) "ts", NULL
9221 };
9222
9223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9225 if (SWIG_arg_fail(1)) SWIG_fail;
9226 {
9227 PyThreadState* __tstate = wxPyBeginAllowThreads();
9228 wxLog::SetTimestamp((wxChar const *)arg1);
9229
9230 wxPyEndAllowThreads(__tstate);
9231 if (PyErr_Occurred()) SWIG_fail;
9232 }
9233 Py_INCREF(Py_None); resultobj = Py_None;
9234 return resultobj;
9235 fail:
9236 return NULL;
9237 }
9238
9239
9240 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9241 PyObject *resultobj;
9242 bool result;
9243 char *kwnames[] = {
9244 NULL
9245 };
9246
9247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9248 {
9249 PyThreadState* __tstate = wxPyBeginAllowThreads();
9250 result = (bool)wxLog::GetVerbose();
9251
9252 wxPyEndAllowThreads(__tstate);
9253 if (PyErr_Occurred()) SWIG_fail;
9254 }
9255 {
9256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9257 }
9258 return resultobj;
9259 fail:
9260 return NULL;
9261 }
9262
9263
9264 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9265 PyObject *resultobj;
9266 wxTraceMask result;
9267 char *kwnames[] = {
9268 NULL
9269 };
9270
9271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 result = (wxTraceMask)wxLog::GetTraceMask();
9275
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 {
9280 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9281 }
9282 return resultobj;
9283 fail:
9284 return NULL;
9285 }
9286
9287
9288 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9289 PyObject *resultobj;
9290 wxChar *arg1 = (wxChar *) 0 ;
9291 bool result;
9292 PyObject * obj0 = 0 ;
9293 char *kwnames[] = {
9294 (char *) "mask", NULL
9295 };
9296
9297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9299 if (SWIG_arg_fail(1)) SWIG_fail;
9300 {
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9303
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 {
9308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9309 }
9310 return resultobj;
9311 fail:
9312 return NULL;
9313 }
9314
9315
9316 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9317 PyObject *resultobj;
9318 wxLogLevel result;
9319 char *kwnames[] = {
9320 NULL
9321 };
9322
9323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 result = (wxLogLevel)wxLog::GetLogLevel();
9327
9328 wxPyEndAllowThreads(__tstate);
9329 if (PyErr_Occurred()) SWIG_fail;
9330 }
9331 {
9332 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9333 }
9334 return resultobj;
9335 fail:
9336 return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj;
9342 wxChar *result;
9343 char *kwnames[] = {
9344 NULL
9345 };
9346
9347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 result = (wxChar *)wxLog::GetTimestamp();
9351
9352 wxPyEndAllowThreads(__tstate);
9353 if (PyErr_Occurred()) SWIG_fail;
9354 }
9355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9356 return resultobj;
9357 fail:
9358 return NULL;
9359 }
9360
9361
9362 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9363 PyObject *resultobj;
9364 wxString result;
9365 char *kwnames[] = {
9366 NULL
9367 };
9368
9369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9370 {
9371 PyThreadState* __tstate = wxPyBeginAllowThreads();
9372 result = Log_TimeStamp();
9373
9374 wxPyEndAllowThreads(__tstate);
9375 if (PyErr_Occurred()) SWIG_fail;
9376 }
9377 {
9378 #if wxUSE_UNICODE
9379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9380 #else
9381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9382 #endif
9383 }
9384 return resultobj;
9385 fail:
9386 return NULL;
9387 }
9388
9389
9390 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9391 PyObject *resultobj;
9392 wxLog *arg1 = (wxLog *) 0 ;
9393 PyObject * obj0 = 0 ;
9394 char *kwnames[] = {
9395 (char *) "self", NULL
9396 };
9397
9398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9400 if (SWIG_arg_fail(1)) SWIG_fail;
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 wxLog_Destroy(arg1);
9404
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 Py_INCREF(Py_None); resultobj = Py_None;
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9416 PyObject *obj;
9417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9418 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9419 Py_INCREF(obj);
9420 return Py_BuildValue((char *)"");
9421 }
9422 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9423 PyObject *resultobj;
9424 wxLogStderr *result;
9425 char *kwnames[] = {
9426 NULL
9427 };
9428
9429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (wxLogStderr *)new wxLogStderr();
9433
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9445 PyObject *obj;
9446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9447 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9448 Py_INCREF(obj);
9449 return Py_BuildValue((char *)"");
9450 }
9451 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9452 PyObject *resultobj;
9453 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9454 wxLogTextCtrl *result;
9455 PyObject * obj0 = 0 ;
9456 char *kwnames[] = {
9457 (char *) "pTextCtrl", NULL
9458 };
9459
9460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9462 if (SWIG_arg_fail(1)) SWIG_fail;
9463 {
9464 PyThreadState* __tstate = wxPyBeginAllowThreads();
9465 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9466
9467 wxPyEndAllowThreads(__tstate);
9468 if (PyErr_Occurred()) SWIG_fail;
9469 }
9470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9471 return resultobj;
9472 fail:
9473 return NULL;
9474 }
9475
9476
9477 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9478 PyObject *obj;
9479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9480 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9481 Py_INCREF(obj);
9482 return Py_BuildValue((char *)"");
9483 }
9484 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj;
9486 wxLogGui *result;
9487 char *kwnames[] = {
9488 NULL
9489 };
9490
9491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9492 {
9493 PyThreadState* __tstate = wxPyBeginAllowThreads();
9494 result = (wxLogGui *)new wxLogGui();
9495
9496 wxPyEndAllowThreads(__tstate);
9497 if (PyErr_Occurred()) SWIG_fail;
9498 }
9499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9500 return resultobj;
9501 fail:
9502 return NULL;
9503 }
9504
9505
9506 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9507 PyObject *obj;
9508 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9509 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9510 Py_INCREF(obj);
9511 return Py_BuildValue((char *)"");
9512 }
9513 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9514 PyObject *resultobj;
9515 wxFrame *arg1 = (wxFrame *) 0 ;
9516 wxString *arg2 = 0 ;
9517 bool arg3 = (bool) true ;
9518 bool arg4 = (bool) true ;
9519 wxLogWindow *result;
9520 bool temp2 = false ;
9521 PyObject * obj0 = 0 ;
9522 PyObject * obj1 = 0 ;
9523 PyObject * obj2 = 0 ;
9524 PyObject * obj3 = 0 ;
9525 char *kwnames[] = {
9526 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9527 };
9528
9529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9531 if (SWIG_arg_fail(1)) SWIG_fail;
9532 {
9533 arg2 = wxString_in_helper(obj1);
9534 if (arg2 == NULL) SWIG_fail;
9535 temp2 = true;
9536 }
9537 if (obj2) {
9538 {
9539 arg3 = (bool)(SWIG_As_bool(obj2));
9540 if (SWIG_arg_fail(3)) SWIG_fail;
9541 }
9542 }
9543 if (obj3) {
9544 {
9545 arg4 = (bool)(SWIG_As_bool(obj3));
9546 if (SWIG_arg_fail(4)) SWIG_fail;
9547 }
9548 }
9549 {
9550 PyThreadState* __tstate = wxPyBeginAllowThreads();
9551 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9552
9553 wxPyEndAllowThreads(__tstate);
9554 if (PyErr_Occurred()) SWIG_fail;
9555 }
9556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9557 {
9558 if (temp2)
9559 delete arg2;
9560 }
9561 return resultobj;
9562 fail:
9563 {
9564 if (temp2)
9565 delete arg2;
9566 }
9567 return NULL;
9568 }
9569
9570
9571 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9572 PyObject *resultobj;
9573 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9574 bool arg2 = (bool) true ;
9575 PyObject * obj0 = 0 ;
9576 PyObject * obj1 = 0 ;
9577 char *kwnames[] = {
9578 (char *) "self",(char *) "bShow", NULL
9579 };
9580
9581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9583 if (SWIG_arg_fail(1)) SWIG_fail;
9584 if (obj1) {
9585 {
9586 arg2 = (bool)(SWIG_As_bool(obj1));
9587 if (SWIG_arg_fail(2)) SWIG_fail;
9588 }
9589 }
9590 {
9591 PyThreadState* __tstate = wxPyBeginAllowThreads();
9592 (arg1)->Show(arg2);
9593
9594 wxPyEndAllowThreads(__tstate);
9595 if (PyErr_Occurred()) SWIG_fail;
9596 }
9597 Py_INCREF(Py_None); resultobj = Py_None;
9598 return resultobj;
9599 fail:
9600 return NULL;
9601 }
9602
9603
9604 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9605 PyObject *resultobj;
9606 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9607 wxFrame *result;
9608 PyObject * obj0 = 0 ;
9609 char *kwnames[] = {
9610 (char *) "self", NULL
9611 };
9612
9613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9615 if (SWIG_arg_fail(1)) SWIG_fail;
9616 {
9617 PyThreadState* __tstate = wxPyBeginAllowThreads();
9618 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9619
9620 wxPyEndAllowThreads(__tstate);
9621 if (PyErr_Occurred()) SWIG_fail;
9622 }
9623 {
9624 resultobj = wxPyMake_wxObject(result, 0);
9625 }
9626 return resultobj;
9627 fail:
9628 return NULL;
9629 }
9630
9631
9632 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9633 PyObject *resultobj;
9634 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9635 wxLog *result;
9636 PyObject * obj0 = 0 ;
9637 char *kwnames[] = {
9638 (char *) "self", NULL
9639 };
9640
9641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9643 if (SWIG_arg_fail(1)) SWIG_fail;
9644 {
9645 PyThreadState* __tstate = wxPyBeginAllowThreads();
9646 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9647
9648 wxPyEndAllowThreads(__tstate);
9649 if (PyErr_Occurred()) SWIG_fail;
9650 }
9651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9652 return resultobj;
9653 fail:
9654 return NULL;
9655 }
9656
9657
9658 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9659 PyObject *resultobj;
9660 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9661 bool result;
9662 PyObject * obj0 = 0 ;
9663 char *kwnames[] = {
9664 (char *) "self", NULL
9665 };
9666
9667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9669 if (SWIG_arg_fail(1)) SWIG_fail;
9670 {
9671 PyThreadState* __tstate = wxPyBeginAllowThreads();
9672 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9673
9674 wxPyEndAllowThreads(__tstate);
9675 if (PyErr_Occurred()) SWIG_fail;
9676 }
9677 {
9678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9679 }
9680 return resultobj;
9681 fail:
9682 return NULL;
9683 }
9684
9685
9686 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9687 PyObject *resultobj;
9688 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9689 bool arg2 ;
9690 PyObject * obj0 = 0 ;
9691 PyObject * obj1 = 0 ;
9692 char *kwnames[] = {
9693 (char *) "self",(char *) "bDoPass", NULL
9694 };
9695
9696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9698 if (SWIG_arg_fail(1)) SWIG_fail;
9699 {
9700 arg2 = (bool)(SWIG_As_bool(obj1));
9701 if (SWIG_arg_fail(2)) SWIG_fail;
9702 }
9703 {
9704 PyThreadState* __tstate = wxPyBeginAllowThreads();
9705 (arg1)->PassMessages(arg2);
9706
9707 wxPyEndAllowThreads(__tstate);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 Py_INCREF(Py_None); resultobj = Py_None;
9711 return resultobj;
9712 fail:
9713 return NULL;
9714 }
9715
9716
9717 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9718 PyObject *obj;
9719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9720 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9721 Py_INCREF(obj);
9722 return Py_BuildValue((char *)"");
9723 }
9724 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9725 PyObject *resultobj;
9726 wxLog *arg1 = (wxLog *) 0 ;
9727 wxLogChain *result;
9728 PyObject * obj0 = 0 ;
9729 char *kwnames[] = {
9730 (char *) "logger", NULL
9731 };
9732
9733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9735 if (SWIG_arg_fail(1)) SWIG_fail;
9736 {
9737 PyThreadState* __tstate = wxPyBeginAllowThreads();
9738 result = (wxLogChain *)new wxLogChain(arg1);
9739
9740 wxPyEndAllowThreads(__tstate);
9741 if (PyErr_Occurred()) SWIG_fail;
9742 }
9743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9744 return resultobj;
9745 fail:
9746 return NULL;
9747 }
9748
9749
9750 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9751 PyObject *resultobj;
9752 wxLogChain *arg1 = (wxLogChain *) 0 ;
9753 wxLog *arg2 = (wxLog *) 0 ;
9754 PyObject * obj0 = 0 ;
9755 PyObject * obj1 = 0 ;
9756 char *kwnames[] = {
9757 (char *) "self",(char *) "logger", NULL
9758 };
9759
9760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9762 if (SWIG_arg_fail(1)) SWIG_fail;
9763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9764 if (SWIG_arg_fail(2)) SWIG_fail;
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 (arg1)->SetLog(arg2);
9768
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 Py_INCREF(Py_None); resultobj = Py_None;
9773 return resultobj;
9774 fail:
9775 return NULL;
9776 }
9777
9778
9779 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9780 PyObject *resultobj;
9781 wxLogChain *arg1 = (wxLogChain *) 0 ;
9782 bool arg2 ;
9783 PyObject * obj0 = 0 ;
9784 PyObject * obj1 = 0 ;
9785 char *kwnames[] = {
9786 (char *) "self",(char *) "bDoPass", NULL
9787 };
9788
9789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9791 if (SWIG_arg_fail(1)) SWIG_fail;
9792 {
9793 arg2 = (bool)(SWIG_As_bool(obj1));
9794 if (SWIG_arg_fail(2)) SWIG_fail;
9795 }
9796 {
9797 PyThreadState* __tstate = wxPyBeginAllowThreads();
9798 (arg1)->PassMessages(arg2);
9799
9800 wxPyEndAllowThreads(__tstate);
9801 if (PyErr_Occurred()) SWIG_fail;
9802 }
9803 Py_INCREF(Py_None); resultobj = Py_None;
9804 return resultobj;
9805 fail:
9806 return NULL;
9807 }
9808
9809
9810 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9811 PyObject *resultobj;
9812 wxLogChain *arg1 = (wxLogChain *) 0 ;
9813 bool result;
9814 PyObject * obj0 = 0 ;
9815 char *kwnames[] = {
9816 (char *) "self", NULL
9817 };
9818
9819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9821 if (SWIG_arg_fail(1)) SWIG_fail;
9822 {
9823 PyThreadState* __tstate = wxPyBeginAllowThreads();
9824 result = (bool)(arg1)->IsPassingMessages();
9825
9826 wxPyEndAllowThreads(__tstate);
9827 if (PyErr_Occurred()) SWIG_fail;
9828 }
9829 {
9830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9831 }
9832 return resultobj;
9833 fail:
9834 return NULL;
9835 }
9836
9837
9838 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9839 PyObject *resultobj;
9840 wxLogChain *arg1 = (wxLogChain *) 0 ;
9841 wxLog *result;
9842 PyObject * obj0 = 0 ;
9843 char *kwnames[] = {
9844 (char *) "self", NULL
9845 };
9846
9847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9849 if (SWIG_arg_fail(1)) SWIG_fail;
9850 {
9851 PyThreadState* __tstate = wxPyBeginAllowThreads();
9852 result = (wxLog *)(arg1)->GetOldLog();
9853
9854 wxPyEndAllowThreads(__tstate);
9855 if (PyErr_Occurred()) SWIG_fail;
9856 }
9857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9865 PyObject *obj;
9866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9867 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9868 Py_INCREF(obj);
9869 return Py_BuildValue((char *)"");
9870 }
9871 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 unsigned long result;
9874 char *kwnames[] = {
9875 NULL
9876 };
9877
9878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 result = (unsigned long)wxSysErrorCode();
9882
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 {
9887 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9888 }
9889 return resultobj;
9890 fail:
9891 return NULL;
9892 }
9893
9894
9895 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9896 PyObject *resultobj;
9897 unsigned long arg1 = (unsigned long) 0 ;
9898 wxString result;
9899 PyObject * obj0 = 0 ;
9900 char *kwnames[] = {
9901 (char *) "nErrCode", NULL
9902 };
9903
9904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9905 if (obj0) {
9906 {
9907 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 }
9910 }
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 result = wxSysErrorMsg(arg1);
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 {
9919 #if wxUSE_UNICODE
9920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9921 #else
9922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9923 #endif
9924 }
9925 return resultobj;
9926 fail:
9927 return NULL;
9928 }
9929
9930
9931 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9932 PyObject *resultobj;
9933 wxString *arg1 = 0 ;
9934 bool temp1 = false ;
9935 PyObject * obj0 = 0 ;
9936 char *kwnames[] = {
9937 (char *) "msg", NULL
9938 };
9939
9940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9941 {
9942 arg1 = wxString_in_helper(obj0);
9943 if (arg1 == NULL) SWIG_fail;
9944 temp1 = true;
9945 }
9946 {
9947 PyThreadState* __tstate = wxPyBeginAllowThreads();
9948 wxPyLogFatalError((wxString const &)*arg1);
9949
9950 wxPyEndAllowThreads(__tstate);
9951 if (PyErr_Occurred()) SWIG_fail;
9952 }
9953 Py_INCREF(Py_None); resultobj = Py_None;
9954 {
9955 if (temp1)
9956 delete arg1;
9957 }
9958 return resultobj;
9959 fail:
9960 {
9961 if (temp1)
9962 delete arg1;
9963 }
9964 return NULL;
9965 }
9966
9967
9968 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9969 PyObject *resultobj;
9970 wxString *arg1 = 0 ;
9971 bool temp1 = false ;
9972 PyObject * obj0 = 0 ;
9973 char *kwnames[] = {
9974 (char *) "msg", NULL
9975 };
9976
9977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9978 {
9979 arg1 = wxString_in_helper(obj0);
9980 if (arg1 == NULL) SWIG_fail;
9981 temp1 = true;
9982 }
9983 {
9984 PyThreadState* __tstate = wxPyBeginAllowThreads();
9985 wxPyLogError((wxString const &)*arg1);
9986
9987 wxPyEndAllowThreads(__tstate);
9988 if (PyErr_Occurred()) SWIG_fail;
9989 }
9990 Py_INCREF(Py_None); resultobj = Py_None;
9991 {
9992 if (temp1)
9993 delete arg1;
9994 }
9995 return resultobj;
9996 fail:
9997 {
9998 if (temp1)
9999 delete arg1;
10000 }
10001 return NULL;
10002 }
10003
10004
10005 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj;
10007 wxString *arg1 = 0 ;
10008 bool temp1 = false ;
10009 PyObject * obj0 = 0 ;
10010 char *kwnames[] = {
10011 (char *) "msg", NULL
10012 };
10013
10014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10015 {
10016 arg1 = wxString_in_helper(obj0);
10017 if (arg1 == NULL) SWIG_fail;
10018 temp1 = true;
10019 }
10020 {
10021 PyThreadState* __tstate = wxPyBeginAllowThreads();
10022 wxPyLogWarning((wxString const &)*arg1);
10023
10024 wxPyEndAllowThreads(__tstate);
10025 if (PyErr_Occurred()) SWIG_fail;
10026 }
10027 Py_INCREF(Py_None); resultobj = Py_None;
10028 {
10029 if (temp1)
10030 delete arg1;
10031 }
10032 return resultobj;
10033 fail:
10034 {
10035 if (temp1)
10036 delete arg1;
10037 }
10038 return NULL;
10039 }
10040
10041
10042 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10043 PyObject *resultobj;
10044 wxString *arg1 = 0 ;
10045 bool temp1 = false ;
10046 PyObject * obj0 = 0 ;
10047 char *kwnames[] = {
10048 (char *) "msg", NULL
10049 };
10050
10051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10052 {
10053 arg1 = wxString_in_helper(obj0);
10054 if (arg1 == NULL) SWIG_fail;
10055 temp1 = true;
10056 }
10057 {
10058 PyThreadState* __tstate = wxPyBeginAllowThreads();
10059 wxPyLogMessage((wxString const &)*arg1);
10060
10061 wxPyEndAllowThreads(__tstate);
10062 if (PyErr_Occurred()) SWIG_fail;
10063 }
10064 Py_INCREF(Py_None); resultobj = Py_None;
10065 {
10066 if (temp1)
10067 delete arg1;
10068 }
10069 return resultobj;
10070 fail:
10071 {
10072 if (temp1)
10073 delete arg1;
10074 }
10075 return NULL;
10076 }
10077
10078
10079 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj;
10081 wxString *arg1 = 0 ;
10082 bool temp1 = false ;
10083 PyObject * obj0 = 0 ;
10084 char *kwnames[] = {
10085 (char *) "msg", NULL
10086 };
10087
10088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10089 {
10090 arg1 = wxString_in_helper(obj0);
10091 if (arg1 == NULL) SWIG_fail;
10092 temp1 = true;
10093 }
10094 {
10095 PyThreadState* __tstate = wxPyBeginAllowThreads();
10096 wxPyLogInfo((wxString const &)*arg1);
10097
10098 wxPyEndAllowThreads(__tstate);
10099 if (PyErr_Occurred()) SWIG_fail;
10100 }
10101 Py_INCREF(Py_None); resultobj = Py_None;
10102 {
10103 if (temp1)
10104 delete arg1;
10105 }
10106 return resultobj;
10107 fail:
10108 {
10109 if (temp1)
10110 delete arg1;
10111 }
10112 return NULL;
10113 }
10114
10115
10116 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10117 PyObject *resultobj;
10118 wxString *arg1 = 0 ;
10119 bool temp1 = false ;
10120 PyObject * obj0 = 0 ;
10121 char *kwnames[] = {
10122 (char *) "msg", NULL
10123 };
10124
10125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10126 {
10127 arg1 = wxString_in_helper(obj0);
10128 if (arg1 == NULL) SWIG_fail;
10129 temp1 = true;
10130 }
10131 {
10132 PyThreadState* __tstate = wxPyBeginAllowThreads();
10133 wxPyLogDebug((wxString const &)*arg1);
10134
10135 wxPyEndAllowThreads(__tstate);
10136 if (PyErr_Occurred()) SWIG_fail;
10137 }
10138 Py_INCREF(Py_None); resultobj = Py_None;
10139 {
10140 if (temp1)
10141 delete arg1;
10142 }
10143 return resultobj;
10144 fail:
10145 {
10146 if (temp1)
10147 delete arg1;
10148 }
10149 return NULL;
10150 }
10151
10152
10153 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj;
10155 wxString *arg1 = 0 ;
10156 bool temp1 = false ;
10157 PyObject * obj0 = 0 ;
10158 char *kwnames[] = {
10159 (char *) "msg", NULL
10160 };
10161
10162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10163 {
10164 arg1 = wxString_in_helper(obj0);
10165 if (arg1 == NULL) SWIG_fail;
10166 temp1 = true;
10167 }
10168 {
10169 PyThreadState* __tstate = wxPyBeginAllowThreads();
10170 wxPyLogVerbose((wxString const &)*arg1);
10171
10172 wxPyEndAllowThreads(__tstate);
10173 if (PyErr_Occurred()) SWIG_fail;
10174 }
10175 Py_INCREF(Py_None); resultobj = Py_None;
10176 {
10177 if (temp1)
10178 delete arg1;
10179 }
10180 return resultobj;
10181 fail:
10182 {
10183 if (temp1)
10184 delete arg1;
10185 }
10186 return NULL;
10187 }
10188
10189
10190 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10191 PyObject *resultobj;
10192 wxString *arg1 = 0 ;
10193 bool temp1 = false ;
10194 PyObject * obj0 = 0 ;
10195 char *kwnames[] = {
10196 (char *) "msg", NULL
10197 };
10198
10199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10200 {
10201 arg1 = wxString_in_helper(obj0);
10202 if (arg1 == NULL) SWIG_fail;
10203 temp1 = true;
10204 }
10205 {
10206 PyThreadState* __tstate = wxPyBeginAllowThreads();
10207 wxPyLogStatus((wxString const &)*arg1);
10208
10209 wxPyEndAllowThreads(__tstate);
10210 if (PyErr_Occurred()) SWIG_fail;
10211 }
10212 Py_INCREF(Py_None); resultobj = Py_None;
10213 {
10214 if (temp1)
10215 delete arg1;
10216 }
10217 return resultobj;
10218 fail:
10219 {
10220 if (temp1)
10221 delete arg1;
10222 }
10223 return NULL;
10224 }
10225
10226
10227 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj;
10229 wxFrame *arg1 = (wxFrame *) 0 ;
10230 wxString *arg2 = 0 ;
10231 bool temp2 = false ;
10232 PyObject * obj0 = 0 ;
10233 PyObject * obj1 = 0 ;
10234 char *kwnames[] = {
10235 (char *) "pFrame",(char *) "msg", NULL
10236 };
10237
10238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10240 if (SWIG_arg_fail(1)) SWIG_fail;
10241 {
10242 arg2 = wxString_in_helper(obj1);
10243 if (arg2 == NULL) SWIG_fail;
10244 temp2 = true;
10245 }
10246 {
10247 PyThreadState* __tstate = wxPyBeginAllowThreads();
10248 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10249
10250 wxPyEndAllowThreads(__tstate);
10251 if (PyErr_Occurred()) SWIG_fail;
10252 }
10253 Py_INCREF(Py_None); resultobj = Py_None;
10254 {
10255 if (temp2)
10256 delete arg2;
10257 }
10258 return resultobj;
10259 fail:
10260 {
10261 if (temp2)
10262 delete arg2;
10263 }
10264 return NULL;
10265 }
10266
10267
10268 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10269 PyObject *resultobj;
10270 wxString *arg1 = 0 ;
10271 bool temp1 = false ;
10272 PyObject * obj0 = 0 ;
10273 char *kwnames[] = {
10274 (char *) "msg", NULL
10275 };
10276
10277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10278 {
10279 arg1 = wxString_in_helper(obj0);
10280 if (arg1 == NULL) SWIG_fail;
10281 temp1 = true;
10282 }
10283 {
10284 PyThreadState* __tstate = wxPyBeginAllowThreads();
10285 wxPyLogSysError((wxString const &)*arg1);
10286
10287 wxPyEndAllowThreads(__tstate);
10288 if (PyErr_Occurred()) SWIG_fail;
10289 }
10290 Py_INCREF(Py_None); resultobj = Py_None;
10291 {
10292 if (temp1)
10293 delete arg1;
10294 }
10295 return resultobj;
10296 fail:
10297 {
10298 if (temp1)
10299 delete arg1;
10300 }
10301 return NULL;
10302 }
10303
10304
10305 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10306 PyObject *resultobj;
10307 unsigned long arg1 ;
10308 wxString *arg2 = 0 ;
10309 bool temp2 = false ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char *kwnames[] = {
10313 (char *) "level",(char *) "msg", NULL
10314 };
10315
10316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10317 {
10318 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10319 if (SWIG_arg_fail(1)) SWIG_fail;
10320 }
10321 {
10322 arg2 = wxString_in_helper(obj1);
10323 if (arg2 == NULL) SWIG_fail;
10324 temp2 = true;
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10329
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 Py_INCREF(Py_None); resultobj = Py_None;
10334 {
10335 if (temp2)
10336 delete arg2;
10337 }
10338 return resultobj;
10339 fail:
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return NULL;
10345 }
10346
10347
10348 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10349 PyObject *resultobj;
10350 unsigned long arg1 ;
10351 wxString *arg2 = 0 ;
10352 bool temp2 = false ;
10353 PyObject * obj0 = 0 ;
10354 PyObject * obj1 = 0 ;
10355
10356 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10357 {
10358 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10359 if (SWIG_arg_fail(1)) SWIG_fail;
10360 }
10361 {
10362 arg2 = wxString_in_helper(obj1);
10363 if (arg2 == NULL) SWIG_fail;
10364 temp2 = true;
10365 }
10366 {
10367 PyThreadState* __tstate = wxPyBeginAllowThreads();
10368 wxPyLogTrace(arg1,(wxString const &)*arg2);
10369
10370 wxPyEndAllowThreads(__tstate);
10371 if (PyErr_Occurred()) SWIG_fail;
10372 }
10373 Py_INCREF(Py_None); resultobj = Py_None;
10374 {
10375 if (temp2)
10376 delete arg2;
10377 }
10378 return resultobj;
10379 fail:
10380 {
10381 if (temp2)
10382 delete arg2;
10383 }
10384 return NULL;
10385 }
10386
10387
10388 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10389 PyObject *resultobj;
10390 wxString *arg1 = 0 ;
10391 wxString *arg2 = 0 ;
10392 bool temp1 = false ;
10393 bool temp2 = false ;
10394 PyObject * obj0 = 0 ;
10395 PyObject * obj1 = 0 ;
10396
10397 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10398 {
10399 arg1 = wxString_in_helper(obj0);
10400 if (arg1 == NULL) SWIG_fail;
10401 temp1 = true;
10402 }
10403 {
10404 arg2 = wxString_in_helper(obj1);
10405 if (arg2 == NULL) SWIG_fail;
10406 temp2 = true;
10407 }
10408 {
10409 PyThreadState* __tstate = wxPyBeginAllowThreads();
10410 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10411
10412 wxPyEndAllowThreads(__tstate);
10413 if (PyErr_Occurred()) SWIG_fail;
10414 }
10415 Py_INCREF(Py_None); resultobj = Py_None;
10416 {
10417 if (temp1)
10418 delete arg1;
10419 }
10420 {
10421 if (temp2)
10422 delete arg2;
10423 }
10424 return resultobj;
10425 fail:
10426 {
10427 if (temp1)
10428 delete arg1;
10429 }
10430 {
10431 if (temp2)
10432 delete arg2;
10433 }
10434 return NULL;
10435 }
10436
10437
10438 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10439 int argc;
10440 PyObject *argv[3];
10441 int ii;
10442
10443 argc = PyObject_Length(args);
10444 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10445 argv[ii] = PyTuple_GetItem(args,ii);
10446 }
10447 if (argc == 2) {
10448 int _v;
10449 {
10450 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10451 }
10452 if (_v) {
10453 {
10454 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10455 }
10456 if (_v) {
10457 return _wrap_LogTrace__SWIG_1(self,args);
10458 }
10459 }
10460 }
10461 if (argc == 2) {
10462 int _v;
10463 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10464 if (_v) {
10465 {
10466 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10467 }
10468 if (_v) {
10469 return _wrap_LogTrace__SWIG_0(self,args);
10470 }
10471 }
10472 }
10473
10474 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10475 return NULL;
10476 }
10477
10478
10479 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10480 PyObject *resultobj;
10481 wxString *arg1 = 0 ;
10482 wxString *arg2 = 0 ;
10483 bool temp1 = false ;
10484 bool temp2 = false ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487 char *kwnames[] = {
10488 (char *) "title",(char *) "text", NULL
10489 };
10490
10491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10492 {
10493 arg1 = wxString_in_helper(obj0);
10494 if (arg1 == NULL) SWIG_fail;
10495 temp1 = true;
10496 }
10497 {
10498 arg2 = wxString_in_helper(obj1);
10499 if (arg2 == NULL) SWIG_fail;
10500 temp2 = true;
10501 }
10502 {
10503 PyThreadState* __tstate = wxPyBeginAllowThreads();
10504 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10505
10506 wxPyEndAllowThreads(__tstate);
10507 if (PyErr_Occurred()) SWIG_fail;
10508 }
10509 Py_INCREF(Py_None); resultobj = Py_None;
10510 {
10511 if (temp1)
10512 delete arg1;
10513 }
10514 {
10515 if (temp2)
10516 delete arg2;
10517 }
10518 return resultobj;
10519 fail:
10520 {
10521 if (temp1)
10522 delete arg1;
10523 }
10524 {
10525 if (temp2)
10526 delete arg2;
10527 }
10528 return NULL;
10529 }
10530
10531
10532 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10533 PyObject *resultobj;
10534 wxLogNull *result;
10535 char *kwnames[] = {
10536 NULL
10537 };
10538
10539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 result = (wxLogNull *)new wxLogNull();
10543
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10548 return resultobj;
10549 fail:
10550 return NULL;
10551 }
10552
10553
10554 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10555 PyObject *resultobj;
10556 wxLogNull *arg1 = (wxLogNull *) 0 ;
10557 PyObject * obj0 = 0 ;
10558 char *kwnames[] = {
10559 (char *) "self", NULL
10560 };
10561
10562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10564 if (SWIG_arg_fail(1)) SWIG_fail;
10565 {
10566 PyThreadState* __tstate = wxPyBeginAllowThreads();
10567 delete arg1;
10568
10569 wxPyEndAllowThreads(__tstate);
10570 if (PyErr_Occurred()) SWIG_fail;
10571 }
10572 Py_INCREF(Py_None); resultobj = Py_None;
10573 return resultobj;
10574 fail:
10575 return NULL;
10576 }
10577
10578
10579 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10580 PyObject *obj;
10581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10582 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10583 Py_INCREF(obj);
10584 return Py_BuildValue((char *)"");
10585 }
10586 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj;
10588 wxPyLog *result;
10589 char *kwnames[] = {
10590 NULL
10591 };
10592
10593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10594 {
10595 PyThreadState* __tstate = wxPyBeginAllowThreads();
10596 result = (wxPyLog *)new wxPyLog();
10597
10598 wxPyEndAllowThreads(__tstate);
10599 if (PyErr_Occurred()) SWIG_fail;
10600 }
10601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10602 return resultobj;
10603 fail:
10604 return NULL;
10605 }
10606
10607
10608 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10609 PyObject *resultobj;
10610 wxPyLog *arg1 = (wxPyLog *) 0 ;
10611 PyObject *arg2 = (PyObject *) 0 ;
10612 PyObject *arg3 = (PyObject *) 0 ;
10613 PyObject * obj0 = 0 ;
10614 PyObject * obj1 = 0 ;
10615 PyObject * obj2 = 0 ;
10616 char *kwnames[] = {
10617 (char *) "self",(char *) "self",(char *) "_class", NULL
10618 };
10619
10620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10622 if (SWIG_arg_fail(1)) SWIG_fail;
10623 arg2 = obj1;
10624 arg3 = obj2;
10625 {
10626 PyThreadState* __tstate = wxPyBeginAllowThreads();
10627 (arg1)->_setCallbackInfo(arg2,arg3);
10628
10629 wxPyEndAllowThreads(__tstate);
10630 if (PyErr_Occurred()) SWIG_fail;
10631 }
10632 Py_INCREF(Py_None); resultobj = Py_None;
10633 return resultobj;
10634 fail:
10635 return NULL;
10636 }
10637
10638
10639 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10640 PyObject *obj;
10641 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10642 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10643 Py_INCREF(obj);
10644 return Py_BuildValue((char *)"");
10645 }
10646 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10647 PyObject *resultobj;
10648 int arg1 ;
10649 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10650 int arg3 = (int) wxKILL_NOCHILDREN ;
10651 wxKillError result;
10652 PyObject * obj0 = 0 ;
10653 PyObject * obj1 = 0 ;
10654 PyObject * obj2 = 0 ;
10655 char *kwnames[] = {
10656 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10657 };
10658
10659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10660 {
10661 arg1 = (int)(SWIG_As_int(obj0));
10662 if (SWIG_arg_fail(1)) SWIG_fail;
10663 }
10664 if (obj1) {
10665 {
10666 arg2 = (wxSignal)(SWIG_As_int(obj1));
10667 if (SWIG_arg_fail(2)) SWIG_fail;
10668 }
10669 }
10670 if (obj2) {
10671 {
10672 arg3 = (int)(SWIG_As_int(obj2));
10673 if (SWIG_arg_fail(3)) SWIG_fail;
10674 }
10675 }
10676 {
10677 PyThreadState* __tstate = wxPyBeginAllowThreads();
10678 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10679
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 resultobj = SWIG_From_int((result));
10684 return resultobj;
10685 fail:
10686 return NULL;
10687 }
10688
10689
10690 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj;
10692 int arg1 ;
10693 bool result;
10694 PyObject * obj0 = 0 ;
10695 char *kwnames[] = {
10696 (char *) "pid", NULL
10697 };
10698
10699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10700 {
10701 arg1 = (int)(SWIG_As_int(obj0));
10702 if (SWIG_arg_fail(1)) SWIG_fail;
10703 }
10704 {
10705 PyThreadState* __tstate = wxPyBeginAllowThreads();
10706 result = (bool)wxPyProcess::Exists(arg1);
10707
10708 wxPyEndAllowThreads(__tstate);
10709 if (PyErr_Occurred()) SWIG_fail;
10710 }
10711 {
10712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10713 }
10714 return resultobj;
10715 fail:
10716 return NULL;
10717 }
10718
10719
10720 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10721 PyObject *resultobj;
10722 wxString *arg1 = 0 ;
10723 int arg2 = (int) wxEXEC_ASYNC ;
10724 wxPyProcess *result;
10725 bool temp1 = false ;
10726 PyObject * obj0 = 0 ;
10727 PyObject * obj1 = 0 ;
10728 char *kwnames[] = {
10729 (char *) "cmd",(char *) "flags", NULL
10730 };
10731
10732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10733 {
10734 arg1 = wxString_in_helper(obj0);
10735 if (arg1 == NULL) SWIG_fail;
10736 temp1 = true;
10737 }
10738 if (obj1) {
10739 {
10740 arg2 = (int)(SWIG_As_int(obj1));
10741 if (SWIG_arg_fail(2)) SWIG_fail;
10742 }
10743 }
10744 {
10745 PyThreadState* __tstate = wxPyBeginAllowThreads();
10746 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10747
10748 wxPyEndAllowThreads(__tstate);
10749 if (PyErr_Occurred()) SWIG_fail;
10750 }
10751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10752 {
10753 if (temp1)
10754 delete arg1;
10755 }
10756 return resultobj;
10757 fail:
10758 {
10759 if (temp1)
10760 delete arg1;
10761 }
10762 return NULL;
10763 }
10764
10765
10766 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10767 PyObject *resultobj;
10768 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10769 int arg2 = (int) -1 ;
10770 wxPyProcess *result;
10771 PyObject * obj0 = 0 ;
10772 PyObject * obj1 = 0 ;
10773 char *kwnames[] = {
10774 (char *) "parent",(char *) "id", NULL
10775 };
10776
10777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10778 if (obj0) {
10779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10780 if (SWIG_arg_fail(1)) SWIG_fail;
10781 }
10782 if (obj1) {
10783 {
10784 arg2 = (int)(SWIG_As_int(obj1));
10785 if (SWIG_arg_fail(2)) SWIG_fail;
10786 }
10787 }
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10791
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10796 return resultobj;
10797 fail:
10798 return NULL;
10799 }
10800
10801
10802 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10803 PyObject *resultobj;
10804 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10805 PyObject *arg2 = (PyObject *) 0 ;
10806 PyObject *arg3 = (PyObject *) 0 ;
10807 PyObject * obj0 = 0 ;
10808 PyObject * obj1 = 0 ;
10809 PyObject * obj2 = 0 ;
10810 char *kwnames[] = {
10811 (char *) "self",(char *) "self",(char *) "_class", NULL
10812 };
10813
10814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10816 if (SWIG_arg_fail(1)) SWIG_fail;
10817 arg2 = obj1;
10818 arg3 = obj2;
10819 {
10820 PyThreadState* __tstate = wxPyBeginAllowThreads();
10821 (arg1)->_setCallbackInfo(arg2,arg3);
10822
10823 wxPyEndAllowThreads(__tstate);
10824 if (PyErr_Occurred()) SWIG_fail;
10825 }
10826 Py_INCREF(Py_None); resultobj = Py_None;
10827 return resultobj;
10828 fail:
10829 return NULL;
10830 }
10831
10832
10833 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10834 PyObject *resultobj;
10835 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10836 int arg2 ;
10837 int arg3 ;
10838 PyObject * obj0 = 0 ;
10839 PyObject * obj1 = 0 ;
10840 PyObject * obj2 = 0 ;
10841 char *kwnames[] = {
10842 (char *) "self",(char *) "pid",(char *) "status", NULL
10843 };
10844
10845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10847 if (SWIG_arg_fail(1)) SWIG_fail;
10848 {
10849 arg2 = (int)(SWIG_As_int(obj1));
10850 if (SWIG_arg_fail(2)) SWIG_fail;
10851 }
10852 {
10853 arg3 = (int)(SWIG_As_int(obj2));
10854 if (SWIG_arg_fail(3)) SWIG_fail;
10855 }
10856 {
10857 PyThreadState* __tstate = wxPyBeginAllowThreads();
10858 (arg1)->base_OnTerminate(arg2,arg3);
10859
10860 wxPyEndAllowThreads(__tstate);
10861 if (PyErr_Occurred()) SWIG_fail;
10862 }
10863 Py_INCREF(Py_None); resultobj = Py_None;
10864 return resultobj;
10865 fail:
10866 return NULL;
10867 }
10868
10869
10870 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10871 PyObject *resultobj;
10872 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10873 PyObject * obj0 = 0 ;
10874 char *kwnames[] = {
10875 (char *) "self", NULL
10876 };
10877
10878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10880 if (SWIG_arg_fail(1)) SWIG_fail;
10881 {
10882 PyThreadState* __tstate = wxPyBeginAllowThreads();
10883 (arg1)->Redirect();
10884
10885 wxPyEndAllowThreads(__tstate);
10886 if (PyErr_Occurred()) SWIG_fail;
10887 }
10888 Py_INCREF(Py_None); resultobj = Py_None;
10889 return resultobj;
10890 fail:
10891 return NULL;
10892 }
10893
10894
10895 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10896 PyObject *resultobj;
10897 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10898 bool result;
10899 PyObject * obj0 = 0 ;
10900 char *kwnames[] = {
10901 (char *) "self", NULL
10902 };
10903
10904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10906 if (SWIG_arg_fail(1)) SWIG_fail;
10907 {
10908 PyThreadState* __tstate = wxPyBeginAllowThreads();
10909 result = (bool)(arg1)->IsRedirected();
10910
10911 wxPyEndAllowThreads(__tstate);
10912 if (PyErr_Occurred()) SWIG_fail;
10913 }
10914 {
10915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10916 }
10917 return resultobj;
10918 fail:
10919 return NULL;
10920 }
10921
10922
10923 static PyObject *_wrap_Process_Detach(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_Detach",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)->Detach();
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_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj;
10950 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10951 wxInputStream *result;
10952 PyObject * obj0 = 0 ;
10953 char *kwnames[] = {
10954 (char *) "self", NULL
10955 };
10956
10957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",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 = (wxInputStream *)(arg1)->GetInputStream();
10963
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 {
10968 wxPyInputStream * _ptr = NULL;
10969
10970 if (result) {
10971 _ptr = new wxPyInputStream(result);
10972 }
10973 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10974 }
10975 return resultobj;
10976 fail:
10977 return NULL;
10978 }
10979
10980
10981 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10982 PyObject *resultobj;
10983 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10984 wxInputStream *result;
10985 PyObject * obj0 = 0 ;
10986 char *kwnames[] = {
10987 (char *) "self", NULL
10988 };
10989
10990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10992 if (SWIG_arg_fail(1)) SWIG_fail;
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 result = (wxInputStream *)(arg1)->GetErrorStream();
10996
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 {
11001 wxPyInputStream * _ptr = NULL;
11002
11003 if (result) {
11004 _ptr = new wxPyInputStream(result);
11005 }
11006 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj;
11016 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11017 wxOutputStream *result;
11018 PyObject * obj0 = 0 ;
11019 char *kwnames[] = {
11020 (char *) "self", NULL
11021 };
11022
11023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11025 if (SWIG_arg_fail(1)) SWIG_fail;
11026 {
11027 PyThreadState* __tstate = wxPyBeginAllowThreads();
11028 result = (wxOutputStream *)(arg1)->GetOutputStream();
11029
11030 wxPyEndAllowThreads(__tstate);
11031 if (PyErr_Occurred()) SWIG_fail;
11032 }
11033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj;
11042 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11043 PyObject * obj0 = 0 ;
11044 char *kwnames[] = {
11045 (char *) "self", NULL
11046 };
11047
11048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11050 if (SWIG_arg_fail(1)) SWIG_fail;
11051 {
11052 PyThreadState* __tstate = wxPyBeginAllowThreads();
11053 (arg1)->CloseOutput();
11054
11055 wxPyEndAllowThreads(__tstate);
11056 if (PyErr_Occurred()) SWIG_fail;
11057 }
11058 Py_INCREF(Py_None); resultobj = Py_None;
11059 return resultobj;
11060 fail:
11061 return NULL;
11062 }
11063
11064
11065 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11066 PyObject *resultobj;
11067 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11068 bool result;
11069 PyObject * obj0 = 0 ;
11070 char *kwnames[] = {
11071 (char *) "self", NULL
11072 };
11073
11074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11076 if (SWIG_arg_fail(1)) SWIG_fail;
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11080
11081 wxPyEndAllowThreads(__tstate);
11082 if (PyErr_Occurred()) SWIG_fail;
11083 }
11084 {
11085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11086 }
11087 return resultobj;
11088 fail:
11089 return NULL;
11090 }
11091
11092
11093 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11094 PyObject *resultobj;
11095 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11096 bool result;
11097 PyObject * obj0 = 0 ;
11098 char *kwnames[] = {
11099 (char *) "self", NULL
11100 };
11101
11102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11104 if (SWIG_arg_fail(1)) SWIG_fail;
11105 {
11106 PyThreadState* __tstate = wxPyBeginAllowThreads();
11107 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11108
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 {
11113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11114 }
11115 return resultobj;
11116 fail:
11117 return NULL;
11118 }
11119
11120
11121 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11122 PyObject *resultobj;
11123 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11124 bool result;
11125 PyObject * obj0 = 0 ;
11126 char *kwnames[] = {
11127 (char *) "self", NULL
11128 };
11129
11130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11132 if (SWIG_arg_fail(1)) SWIG_fail;
11133 {
11134 PyThreadState* __tstate = wxPyBeginAllowThreads();
11135 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11136
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 {
11141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11142 }
11143 return resultobj;
11144 fail:
11145 return NULL;
11146 }
11147
11148
11149 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11150 PyObject *obj;
11151 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11152 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11153 Py_INCREF(obj);
11154 return Py_BuildValue((char *)"");
11155 }
11156 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11157 PyObject *resultobj;
11158 int arg1 = (int) 0 ;
11159 int arg2 = (int) 0 ;
11160 int arg3 = (int) 0 ;
11161 wxProcessEvent *result;
11162 PyObject * obj0 = 0 ;
11163 PyObject * obj1 = 0 ;
11164 PyObject * obj2 = 0 ;
11165 char *kwnames[] = {
11166 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11167 };
11168
11169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11170 if (obj0) {
11171 {
11172 arg1 = (int)(SWIG_As_int(obj0));
11173 if (SWIG_arg_fail(1)) SWIG_fail;
11174 }
11175 }
11176 if (obj1) {
11177 {
11178 arg2 = (int)(SWIG_As_int(obj1));
11179 if (SWIG_arg_fail(2)) SWIG_fail;
11180 }
11181 }
11182 if (obj2) {
11183 {
11184 arg3 = (int)(SWIG_As_int(obj2));
11185 if (SWIG_arg_fail(3)) SWIG_fail;
11186 }
11187 }
11188 {
11189 PyThreadState* __tstate = wxPyBeginAllowThreads();
11190 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11191
11192 wxPyEndAllowThreads(__tstate);
11193 if (PyErr_Occurred()) SWIG_fail;
11194 }
11195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11196 return resultobj;
11197 fail:
11198 return NULL;
11199 }
11200
11201
11202 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11203 PyObject *resultobj;
11204 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11205 int result;
11206 PyObject * obj0 = 0 ;
11207 char *kwnames[] = {
11208 (char *) "self", NULL
11209 };
11210
11211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11213 if (SWIG_arg_fail(1)) SWIG_fail;
11214 {
11215 PyThreadState* __tstate = wxPyBeginAllowThreads();
11216 result = (int)(arg1)->GetPid();
11217
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 {
11222 resultobj = SWIG_From_int((int)(result));
11223 }
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11231 PyObject *resultobj;
11232 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11233 int result;
11234 PyObject * obj0 = 0 ;
11235 char *kwnames[] = {
11236 (char *) "self", NULL
11237 };
11238
11239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11241 if (SWIG_arg_fail(1)) SWIG_fail;
11242 {
11243 PyThreadState* __tstate = wxPyBeginAllowThreads();
11244 result = (int)(arg1)->GetExitCode();
11245
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 {
11250 resultobj = SWIG_From_int((int)(result));
11251 }
11252 return resultobj;
11253 fail:
11254 return NULL;
11255 }
11256
11257
11258 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj;
11260 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11261 int arg2 ;
11262 PyObject * obj0 = 0 ;
11263 PyObject * obj1 = 0 ;
11264 char *kwnames[] = {
11265 (char *) "self",(char *) "m_pid", NULL
11266 };
11267
11268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11270 if (SWIG_arg_fail(1)) SWIG_fail;
11271 {
11272 arg2 = (int)(SWIG_As_int(obj1));
11273 if (SWIG_arg_fail(2)) SWIG_fail;
11274 }
11275 if (arg1) (arg1)->m_pid = arg2;
11276
11277 Py_INCREF(Py_None); resultobj = Py_None;
11278 return resultobj;
11279 fail:
11280 return NULL;
11281 }
11282
11283
11284 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11285 PyObject *resultobj;
11286 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11287 int result;
11288 PyObject * obj0 = 0 ;
11289 char *kwnames[] = {
11290 (char *) "self", NULL
11291 };
11292
11293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11295 if (SWIG_arg_fail(1)) SWIG_fail;
11296 result = (int) ((arg1)->m_pid);
11297
11298 {
11299 resultobj = SWIG_From_int((int)(result));
11300 }
11301 return resultobj;
11302 fail:
11303 return NULL;
11304 }
11305
11306
11307 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11308 PyObject *resultobj;
11309 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11310 int arg2 ;
11311 PyObject * obj0 = 0 ;
11312 PyObject * obj1 = 0 ;
11313 char *kwnames[] = {
11314 (char *) "self",(char *) "m_exitcode", NULL
11315 };
11316
11317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11319 if (SWIG_arg_fail(1)) SWIG_fail;
11320 {
11321 arg2 = (int)(SWIG_As_int(obj1));
11322 if (SWIG_arg_fail(2)) SWIG_fail;
11323 }
11324 if (arg1) (arg1)->m_exitcode = arg2;
11325
11326 Py_INCREF(Py_None); resultobj = Py_None;
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11334 PyObject *resultobj;
11335 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11336 int result;
11337 PyObject * obj0 = 0 ;
11338 char *kwnames[] = {
11339 (char *) "self", NULL
11340 };
11341
11342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11344 if (SWIG_arg_fail(1)) SWIG_fail;
11345 result = (int) ((arg1)->m_exitcode);
11346
11347 {
11348 resultobj = SWIG_From_int((int)(result));
11349 }
11350 return resultobj;
11351 fail:
11352 return NULL;
11353 }
11354
11355
11356 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11357 PyObject *obj;
11358 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11359 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11360 Py_INCREF(obj);
11361 return Py_BuildValue((char *)"");
11362 }
11363 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj;
11365 wxString *arg1 = 0 ;
11366 int arg2 = (int) wxEXEC_ASYNC ;
11367 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11368 long result;
11369 bool temp1 = false ;
11370 PyObject * obj0 = 0 ;
11371 PyObject * obj1 = 0 ;
11372 PyObject * obj2 = 0 ;
11373 char *kwnames[] = {
11374 (char *) "command",(char *) "flags",(char *) "process", NULL
11375 };
11376
11377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11378 {
11379 arg1 = wxString_in_helper(obj0);
11380 if (arg1 == NULL) SWIG_fail;
11381 temp1 = true;
11382 }
11383 if (obj1) {
11384 {
11385 arg2 = (int)(SWIG_As_int(obj1));
11386 if (SWIG_arg_fail(2)) SWIG_fail;
11387 }
11388 }
11389 if (obj2) {
11390 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11391 if (SWIG_arg_fail(3)) SWIG_fail;
11392 }
11393 {
11394 if (!wxPyCheckForApp()) SWIG_fail;
11395 PyThreadState* __tstate = wxPyBeginAllowThreads();
11396 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11397
11398 wxPyEndAllowThreads(__tstate);
11399 if (PyErr_Occurred()) SWIG_fail;
11400 }
11401 {
11402 resultobj = SWIG_From_long((long)(result));
11403 }
11404 {
11405 if (temp1)
11406 delete arg1;
11407 }
11408 return resultobj;
11409 fail:
11410 {
11411 if (temp1)
11412 delete arg1;
11413 }
11414 return NULL;
11415 }
11416
11417
11418 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11419 PyObject *resultobj;
11420 long arg1 ;
11421 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11422 wxKillError *arg3 = (wxKillError *) 0 ;
11423 int arg4 = (int) wxKILL_NOCHILDREN ;
11424 int result;
11425 wxKillError temp3 ;
11426 PyObject * obj0 = 0 ;
11427 PyObject * obj1 = 0 ;
11428 PyObject * obj2 = 0 ;
11429 char *kwnames[] = {
11430 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11431 };
11432
11433 {
11434 arg3 = &temp3;
11435 }
11436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11437 {
11438 arg1 = (long)(SWIG_As_long(obj0));
11439 if (SWIG_arg_fail(1)) SWIG_fail;
11440 }
11441 if (obj1) {
11442 {
11443 arg2 = (wxSignal)(SWIG_As_int(obj1));
11444 if (SWIG_arg_fail(2)) SWIG_fail;
11445 }
11446 }
11447 if (obj2) {
11448 {
11449 arg4 = (int)(SWIG_As_int(obj2));
11450 if (SWIG_arg_fail(4)) SWIG_fail;
11451 }
11452 }
11453 {
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11456
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 {
11461 resultobj = SWIG_From_int((int)(result));
11462 }
11463 {
11464 PyObject* o;
11465 o = PyInt_FromLong((long) (*arg3));
11466 resultobj = t_output_helper(resultobj, o);
11467 }
11468 return resultobj;
11469 fail:
11470 return NULL;
11471 }
11472
11473
11474 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11475 PyObject *resultobj;
11476 int arg1 = (int) wxJOYSTICK1 ;
11477 wxJoystick *result;
11478 PyObject * obj0 = 0 ;
11479 char *kwnames[] = {
11480 (char *) "joystick", NULL
11481 };
11482
11483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11484 if (obj0) {
11485 {
11486 arg1 = (int)(SWIG_As_int(obj0));
11487 if (SWIG_arg_fail(1)) SWIG_fail;
11488 }
11489 }
11490 {
11491 if (!wxPyCheckForApp()) SWIG_fail;
11492 PyThreadState* __tstate = wxPyBeginAllowThreads();
11493 result = (wxJoystick *)new wxJoystick(arg1);
11494
11495 wxPyEndAllowThreads(__tstate);
11496 if (PyErr_Occurred()) SWIG_fail;
11497 }
11498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11499 return resultobj;
11500 fail:
11501 return NULL;
11502 }
11503
11504
11505 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11506 PyObject *resultobj;
11507 wxJoystick *arg1 = (wxJoystick *) 0 ;
11508 PyObject * obj0 = 0 ;
11509 char *kwnames[] = {
11510 (char *) "self", NULL
11511 };
11512
11513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11515 if (SWIG_arg_fail(1)) SWIG_fail;
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 delete arg1;
11519
11520 wxPyEndAllowThreads(__tstate);
11521 if (PyErr_Occurred()) SWIG_fail;
11522 }
11523 Py_INCREF(Py_None); resultobj = Py_None;
11524 return resultobj;
11525 fail:
11526 return NULL;
11527 }
11528
11529
11530 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj;
11532 wxJoystick *arg1 = (wxJoystick *) 0 ;
11533 wxPoint result;
11534 PyObject * obj0 = 0 ;
11535 char *kwnames[] = {
11536 (char *) "self", NULL
11537 };
11538
11539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11541 if (SWIG_arg_fail(1)) SWIG_fail;
11542 {
11543 PyThreadState* __tstate = wxPyBeginAllowThreads();
11544 result = (arg1)->GetPosition();
11545
11546 wxPyEndAllowThreads(__tstate);
11547 if (PyErr_Occurred()) SWIG_fail;
11548 }
11549 {
11550 wxPoint * resultptr;
11551 resultptr = new wxPoint((wxPoint &)(result));
11552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11553 }
11554 return resultobj;
11555 fail:
11556 return NULL;
11557 }
11558
11559
11560 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11561 PyObject *resultobj;
11562 wxJoystick *arg1 = (wxJoystick *) 0 ;
11563 int result;
11564 PyObject * obj0 = 0 ;
11565 char *kwnames[] = {
11566 (char *) "self", NULL
11567 };
11568
11569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11571 if (SWIG_arg_fail(1)) SWIG_fail;
11572 {
11573 PyThreadState* __tstate = wxPyBeginAllowThreads();
11574 result = (int)(arg1)->GetZPosition();
11575
11576 wxPyEndAllowThreads(__tstate);
11577 if (PyErr_Occurred()) SWIG_fail;
11578 }
11579 {
11580 resultobj = SWIG_From_int((int)(result));
11581 }
11582 return resultobj;
11583 fail:
11584 return NULL;
11585 }
11586
11587
11588 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11589 PyObject *resultobj;
11590 wxJoystick *arg1 = (wxJoystick *) 0 ;
11591 int result;
11592 PyObject * obj0 = 0 ;
11593 char *kwnames[] = {
11594 (char *) "self", NULL
11595 };
11596
11597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11599 if (SWIG_arg_fail(1)) SWIG_fail;
11600 {
11601 PyThreadState* __tstate = wxPyBeginAllowThreads();
11602 result = (int)(arg1)->GetButtonState();
11603
11604 wxPyEndAllowThreads(__tstate);
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 {
11608 resultobj = SWIG_From_int((int)(result));
11609 }
11610 return resultobj;
11611 fail:
11612 return NULL;
11613 }
11614
11615
11616 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11617 PyObject *resultobj;
11618 wxJoystick *arg1 = (wxJoystick *) 0 ;
11619 int result;
11620 PyObject * obj0 = 0 ;
11621 char *kwnames[] = {
11622 (char *) "self", NULL
11623 };
11624
11625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11627 if (SWIG_arg_fail(1)) SWIG_fail;
11628 {
11629 PyThreadState* __tstate = wxPyBeginAllowThreads();
11630 result = (int)(arg1)->GetPOVPosition();
11631
11632 wxPyEndAllowThreads(__tstate);
11633 if (PyErr_Occurred()) SWIG_fail;
11634 }
11635 {
11636 resultobj = SWIG_From_int((int)(result));
11637 }
11638 return resultobj;
11639 fail:
11640 return NULL;
11641 }
11642
11643
11644 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11645 PyObject *resultobj;
11646 wxJoystick *arg1 = (wxJoystick *) 0 ;
11647 int result;
11648 PyObject * obj0 = 0 ;
11649 char *kwnames[] = {
11650 (char *) "self", NULL
11651 };
11652
11653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11655 if (SWIG_arg_fail(1)) SWIG_fail;
11656 {
11657 PyThreadState* __tstate = wxPyBeginAllowThreads();
11658 result = (int)(arg1)->GetPOVCTSPosition();
11659
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 {
11664 resultobj = SWIG_From_int((int)(result));
11665 }
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11673 PyObject *resultobj;
11674 wxJoystick *arg1 = (wxJoystick *) 0 ;
11675 int result;
11676 PyObject * obj0 = 0 ;
11677 char *kwnames[] = {
11678 (char *) "self", NULL
11679 };
11680
11681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11683 if (SWIG_arg_fail(1)) SWIG_fail;
11684 {
11685 PyThreadState* __tstate = wxPyBeginAllowThreads();
11686 result = (int)(arg1)->GetRudderPosition();
11687
11688 wxPyEndAllowThreads(__tstate);
11689 if (PyErr_Occurred()) SWIG_fail;
11690 }
11691 {
11692 resultobj = SWIG_From_int((int)(result));
11693 }
11694 return resultobj;
11695 fail:
11696 return NULL;
11697 }
11698
11699
11700 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11701 PyObject *resultobj;
11702 wxJoystick *arg1 = (wxJoystick *) 0 ;
11703 int result;
11704 PyObject * obj0 = 0 ;
11705 char *kwnames[] = {
11706 (char *) "self", NULL
11707 };
11708
11709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11711 if (SWIG_arg_fail(1)) SWIG_fail;
11712 {
11713 PyThreadState* __tstate = wxPyBeginAllowThreads();
11714 result = (int)(arg1)->GetUPosition();
11715
11716 wxPyEndAllowThreads(__tstate);
11717 if (PyErr_Occurred()) SWIG_fail;
11718 }
11719 {
11720 resultobj = SWIG_From_int((int)(result));
11721 }
11722 return resultobj;
11723 fail:
11724 return NULL;
11725 }
11726
11727
11728 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11729 PyObject *resultobj;
11730 wxJoystick *arg1 = (wxJoystick *) 0 ;
11731 int result;
11732 PyObject * obj0 = 0 ;
11733 char *kwnames[] = {
11734 (char *) "self", NULL
11735 };
11736
11737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11739 if (SWIG_arg_fail(1)) SWIG_fail;
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 result = (int)(arg1)->GetVPosition();
11743
11744 wxPyEndAllowThreads(__tstate);
11745 if (PyErr_Occurred()) SWIG_fail;
11746 }
11747 {
11748 resultobj = SWIG_From_int((int)(result));
11749 }
11750 return resultobj;
11751 fail:
11752 return NULL;
11753 }
11754
11755
11756 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11757 PyObject *resultobj;
11758 wxJoystick *arg1 = (wxJoystick *) 0 ;
11759 int result;
11760 PyObject * obj0 = 0 ;
11761 char *kwnames[] = {
11762 (char *) "self", NULL
11763 };
11764
11765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11767 if (SWIG_arg_fail(1)) SWIG_fail;
11768 {
11769 PyThreadState* __tstate = wxPyBeginAllowThreads();
11770 result = (int)(arg1)->GetMovementThreshold();
11771
11772 wxPyEndAllowThreads(__tstate);
11773 if (PyErr_Occurred()) SWIG_fail;
11774 }
11775 {
11776 resultobj = SWIG_From_int((int)(result));
11777 }
11778 return resultobj;
11779 fail:
11780 return NULL;
11781 }
11782
11783
11784 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11785 PyObject *resultobj;
11786 wxJoystick *arg1 = (wxJoystick *) 0 ;
11787 int arg2 ;
11788 PyObject * obj0 = 0 ;
11789 PyObject * obj1 = 0 ;
11790 char *kwnames[] = {
11791 (char *) "self",(char *) "threshold", NULL
11792 };
11793
11794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11796 if (SWIG_arg_fail(1)) SWIG_fail;
11797 {
11798 arg2 = (int)(SWIG_As_int(obj1));
11799 if (SWIG_arg_fail(2)) SWIG_fail;
11800 }
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 (arg1)->SetMovementThreshold(arg2);
11804
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 Py_INCREF(Py_None); resultobj = Py_None;
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11816 PyObject *resultobj;
11817 wxJoystick *arg1 = (wxJoystick *) 0 ;
11818 bool result;
11819 PyObject * obj0 = 0 ;
11820 char *kwnames[] = {
11821 (char *) "self", NULL
11822 };
11823
11824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11826 if (SWIG_arg_fail(1)) SWIG_fail;
11827 {
11828 PyThreadState* __tstate = wxPyBeginAllowThreads();
11829 result = (bool)(arg1)->IsOk();
11830
11831 wxPyEndAllowThreads(__tstate);
11832 if (PyErr_Occurred()) SWIG_fail;
11833 }
11834 {
11835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11836 }
11837 return resultobj;
11838 fail:
11839 return NULL;
11840 }
11841
11842
11843 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11844 PyObject *resultobj;
11845 wxJoystick *arg1 = (wxJoystick *) 0 ;
11846 int result;
11847 PyObject * obj0 = 0 ;
11848 char *kwnames[] = {
11849 (char *) "self", NULL
11850 };
11851
11852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11854 if (SWIG_arg_fail(1)) SWIG_fail;
11855 {
11856 PyThreadState* __tstate = wxPyBeginAllowThreads();
11857 result = (int)(arg1)->GetNumberJoysticks();
11858
11859 wxPyEndAllowThreads(__tstate);
11860 if (PyErr_Occurred()) SWIG_fail;
11861 }
11862 {
11863 resultobj = SWIG_From_int((int)(result));
11864 }
11865 return resultobj;
11866 fail:
11867 return NULL;
11868 }
11869
11870
11871 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11872 PyObject *resultobj;
11873 wxJoystick *arg1 = (wxJoystick *) 0 ;
11874 int result;
11875 PyObject * obj0 = 0 ;
11876 char *kwnames[] = {
11877 (char *) "self", NULL
11878 };
11879
11880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11882 if (SWIG_arg_fail(1)) SWIG_fail;
11883 {
11884 PyThreadState* __tstate = wxPyBeginAllowThreads();
11885 result = (int)(arg1)->GetManufacturerId();
11886
11887 wxPyEndAllowThreads(__tstate);
11888 if (PyErr_Occurred()) SWIG_fail;
11889 }
11890 {
11891 resultobj = SWIG_From_int((int)(result));
11892 }
11893 return resultobj;
11894 fail:
11895 return NULL;
11896 }
11897
11898
11899 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11900 PyObject *resultobj;
11901 wxJoystick *arg1 = (wxJoystick *) 0 ;
11902 int result;
11903 PyObject * obj0 = 0 ;
11904 char *kwnames[] = {
11905 (char *) "self", NULL
11906 };
11907
11908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11910 if (SWIG_arg_fail(1)) SWIG_fail;
11911 {
11912 PyThreadState* __tstate = wxPyBeginAllowThreads();
11913 result = (int)(arg1)->GetProductId();
11914
11915 wxPyEndAllowThreads(__tstate);
11916 if (PyErr_Occurred()) SWIG_fail;
11917 }
11918 {
11919 resultobj = SWIG_From_int((int)(result));
11920 }
11921 return resultobj;
11922 fail:
11923 return NULL;
11924 }
11925
11926
11927 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11928 PyObject *resultobj;
11929 wxJoystick *arg1 = (wxJoystick *) 0 ;
11930 wxString result;
11931 PyObject * obj0 = 0 ;
11932 char *kwnames[] = {
11933 (char *) "self", NULL
11934 };
11935
11936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11938 if (SWIG_arg_fail(1)) SWIG_fail;
11939 {
11940 PyThreadState* __tstate = wxPyBeginAllowThreads();
11941 result = (arg1)->GetProductName();
11942
11943 wxPyEndAllowThreads(__tstate);
11944 if (PyErr_Occurred()) SWIG_fail;
11945 }
11946 {
11947 #if wxUSE_UNICODE
11948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11949 #else
11950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11951 #endif
11952 }
11953 return resultobj;
11954 fail:
11955 return NULL;
11956 }
11957
11958
11959 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11960 PyObject *resultobj;
11961 wxJoystick *arg1 = (wxJoystick *) 0 ;
11962 int result;
11963 PyObject * obj0 = 0 ;
11964 char *kwnames[] = {
11965 (char *) "self", NULL
11966 };
11967
11968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11970 if (SWIG_arg_fail(1)) SWIG_fail;
11971 {
11972 PyThreadState* __tstate = wxPyBeginAllowThreads();
11973 result = (int)(arg1)->GetXMin();
11974
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 {
11979 resultobj = SWIG_From_int((int)(result));
11980 }
11981 return resultobj;
11982 fail:
11983 return NULL;
11984 }
11985
11986
11987 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11988 PyObject *resultobj;
11989 wxJoystick *arg1 = (wxJoystick *) 0 ;
11990 int result;
11991 PyObject * obj0 = 0 ;
11992 char *kwnames[] = {
11993 (char *) "self", NULL
11994 };
11995
11996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11998 if (SWIG_arg_fail(1)) SWIG_fail;
11999 {
12000 PyThreadState* __tstate = wxPyBeginAllowThreads();
12001 result = (int)(arg1)->GetYMin();
12002
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 {
12007 resultobj = SWIG_From_int((int)(result));
12008 }
12009 return resultobj;
12010 fail:
12011 return NULL;
12012 }
12013
12014
12015 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj;
12017 wxJoystick *arg1 = (wxJoystick *) 0 ;
12018 int result;
12019 PyObject * obj0 = 0 ;
12020 char *kwnames[] = {
12021 (char *) "self", NULL
12022 };
12023
12024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12026 if (SWIG_arg_fail(1)) SWIG_fail;
12027 {
12028 PyThreadState* __tstate = wxPyBeginAllowThreads();
12029 result = (int)(arg1)->GetZMin();
12030
12031 wxPyEndAllowThreads(__tstate);
12032 if (PyErr_Occurred()) SWIG_fail;
12033 }
12034 {
12035 resultobj = SWIG_From_int((int)(result));
12036 }
12037 return resultobj;
12038 fail:
12039 return NULL;
12040 }
12041
12042
12043 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12044 PyObject *resultobj;
12045 wxJoystick *arg1 = (wxJoystick *) 0 ;
12046 int result;
12047 PyObject * obj0 = 0 ;
12048 char *kwnames[] = {
12049 (char *) "self", NULL
12050 };
12051
12052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12054 if (SWIG_arg_fail(1)) SWIG_fail;
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 result = (int)(arg1)->GetXMax();
12058
12059 wxPyEndAllowThreads(__tstate);
12060 if (PyErr_Occurred()) SWIG_fail;
12061 }
12062 {
12063 resultobj = SWIG_From_int((int)(result));
12064 }
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12072 PyObject *resultobj;
12073 wxJoystick *arg1 = (wxJoystick *) 0 ;
12074 int result;
12075 PyObject * obj0 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 result = (int)(arg1)->GetYMax();
12086
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 {
12091 resultobj = SWIG_From_int((int)(result));
12092 }
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12100 PyObject *resultobj;
12101 wxJoystick *arg1 = (wxJoystick *) 0 ;
12102 int result;
12103 PyObject * obj0 = 0 ;
12104 char *kwnames[] = {
12105 (char *) "self", NULL
12106 };
12107
12108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12110 if (SWIG_arg_fail(1)) SWIG_fail;
12111 {
12112 PyThreadState* __tstate = wxPyBeginAllowThreads();
12113 result = (int)(arg1)->GetZMax();
12114
12115 wxPyEndAllowThreads(__tstate);
12116 if (PyErr_Occurred()) SWIG_fail;
12117 }
12118 {
12119 resultobj = SWIG_From_int((int)(result));
12120 }
12121 return resultobj;
12122 fail:
12123 return NULL;
12124 }
12125
12126
12127 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12128 PyObject *resultobj;
12129 wxJoystick *arg1 = (wxJoystick *) 0 ;
12130 int result;
12131 PyObject * obj0 = 0 ;
12132 char *kwnames[] = {
12133 (char *) "self", NULL
12134 };
12135
12136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12138 if (SWIG_arg_fail(1)) SWIG_fail;
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 result = (int)(arg1)->GetNumberButtons();
12142
12143 wxPyEndAllowThreads(__tstate);
12144 if (PyErr_Occurred()) SWIG_fail;
12145 }
12146 {
12147 resultobj = SWIG_From_int((int)(result));
12148 }
12149 return resultobj;
12150 fail:
12151 return NULL;
12152 }
12153
12154
12155 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12156 PyObject *resultobj;
12157 wxJoystick *arg1 = (wxJoystick *) 0 ;
12158 int result;
12159 PyObject * obj0 = 0 ;
12160 char *kwnames[] = {
12161 (char *) "self", NULL
12162 };
12163
12164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12166 if (SWIG_arg_fail(1)) SWIG_fail;
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 result = (int)(arg1)->GetNumberAxes();
12170
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 {
12175 resultobj = SWIG_From_int((int)(result));
12176 }
12177 return resultobj;
12178 fail:
12179 return NULL;
12180 }
12181
12182
12183 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj;
12185 wxJoystick *arg1 = (wxJoystick *) 0 ;
12186 int result;
12187 PyObject * obj0 = 0 ;
12188 char *kwnames[] = {
12189 (char *) "self", NULL
12190 };
12191
12192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12194 if (SWIG_arg_fail(1)) SWIG_fail;
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 result = (int)(arg1)->GetMaxButtons();
12198
12199 wxPyEndAllowThreads(__tstate);
12200 if (PyErr_Occurred()) SWIG_fail;
12201 }
12202 {
12203 resultobj = SWIG_From_int((int)(result));
12204 }
12205 return resultobj;
12206 fail:
12207 return NULL;
12208 }
12209
12210
12211 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12212 PyObject *resultobj;
12213 wxJoystick *arg1 = (wxJoystick *) 0 ;
12214 int result;
12215 PyObject * obj0 = 0 ;
12216 char *kwnames[] = {
12217 (char *) "self", NULL
12218 };
12219
12220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12222 if (SWIG_arg_fail(1)) SWIG_fail;
12223 {
12224 PyThreadState* __tstate = wxPyBeginAllowThreads();
12225 result = (int)(arg1)->GetMaxAxes();
12226
12227 wxPyEndAllowThreads(__tstate);
12228 if (PyErr_Occurred()) SWIG_fail;
12229 }
12230 {
12231 resultobj = SWIG_From_int((int)(result));
12232 }
12233 return resultobj;
12234 fail:
12235 return NULL;
12236 }
12237
12238
12239 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12240 PyObject *resultobj;
12241 wxJoystick *arg1 = (wxJoystick *) 0 ;
12242 int result;
12243 PyObject * obj0 = 0 ;
12244 char *kwnames[] = {
12245 (char *) "self", NULL
12246 };
12247
12248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12250 if (SWIG_arg_fail(1)) SWIG_fail;
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = (int)(arg1)->GetPollingMin();
12254
12255 wxPyEndAllowThreads(__tstate);
12256 if (PyErr_Occurred()) SWIG_fail;
12257 }
12258 {
12259 resultobj = SWIG_From_int((int)(result));
12260 }
12261 return resultobj;
12262 fail:
12263 return NULL;
12264 }
12265
12266
12267 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12268 PyObject *resultobj;
12269 wxJoystick *arg1 = (wxJoystick *) 0 ;
12270 int result;
12271 PyObject * obj0 = 0 ;
12272 char *kwnames[] = {
12273 (char *) "self", NULL
12274 };
12275
12276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12278 if (SWIG_arg_fail(1)) SWIG_fail;
12279 {
12280 PyThreadState* __tstate = wxPyBeginAllowThreads();
12281 result = (int)(arg1)->GetPollingMax();
12282
12283 wxPyEndAllowThreads(__tstate);
12284 if (PyErr_Occurred()) SWIG_fail;
12285 }
12286 {
12287 resultobj = SWIG_From_int((int)(result));
12288 }
12289 return resultobj;
12290 fail:
12291 return NULL;
12292 }
12293
12294
12295 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12296 PyObject *resultobj;
12297 wxJoystick *arg1 = (wxJoystick *) 0 ;
12298 int result;
12299 PyObject * obj0 = 0 ;
12300 char *kwnames[] = {
12301 (char *) "self", NULL
12302 };
12303
12304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12306 if (SWIG_arg_fail(1)) SWIG_fail;
12307 {
12308 PyThreadState* __tstate = wxPyBeginAllowThreads();
12309 result = (int)(arg1)->GetRudderMin();
12310
12311 wxPyEndAllowThreads(__tstate);
12312 if (PyErr_Occurred()) SWIG_fail;
12313 }
12314 {
12315 resultobj = SWIG_From_int((int)(result));
12316 }
12317 return resultobj;
12318 fail:
12319 return NULL;
12320 }
12321
12322
12323 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12324 PyObject *resultobj;
12325 wxJoystick *arg1 = (wxJoystick *) 0 ;
12326 int result;
12327 PyObject * obj0 = 0 ;
12328 char *kwnames[] = {
12329 (char *) "self", NULL
12330 };
12331
12332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12334 if (SWIG_arg_fail(1)) SWIG_fail;
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 result = (int)(arg1)->GetRudderMax();
12338
12339 wxPyEndAllowThreads(__tstate);
12340 if (PyErr_Occurred()) SWIG_fail;
12341 }
12342 {
12343 resultobj = SWIG_From_int((int)(result));
12344 }
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12352 PyObject *resultobj;
12353 wxJoystick *arg1 = (wxJoystick *) 0 ;
12354 int result;
12355 PyObject * obj0 = 0 ;
12356 char *kwnames[] = {
12357 (char *) "self", NULL
12358 };
12359
12360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12362 if (SWIG_arg_fail(1)) SWIG_fail;
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 result = (int)(arg1)->GetUMin();
12366
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 {
12371 resultobj = SWIG_From_int((int)(result));
12372 }
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxJoystick *arg1 = (wxJoystick *) 0 ;
12382 int result;
12383 PyObject * obj0 = 0 ;
12384 char *kwnames[] = {
12385 (char *) "self", NULL
12386 };
12387
12388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12390 if (SWIG_arg_fail(1)) SWIG_fail;
12391 {
12392 PyThreadState* __tstate = wxPyBeginAllowThreads();
12393 result = (int)(arg1)->GetUMax();
12394
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 {
12399 resultobj = SWIG_From_int((int)(result));
12400 }
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj;
12409 wxJoystick *arg1 = (wxJoystick *) 0 ;
12410 int result;
12411 PyObject * obj0 = 0 ;
12412 char *kwnames[] = {
12413 (char *) "self", NULL
12414 };
12415
12416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12418 if (SWIG_arg_fail(1)) SWIG_fail;
12419 {
12420 PyThreadState* __tstate = wxPyBeginAllowThreads();
12421 result = (int)(arg1)->GetVMin();
12422
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 {
12427 resultobj = SWIG_From_int((int)(result));
12428 }
12429 return resultobj;
12430 fail:
12431 return NULL;
12432 }
12433
12434
12435 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12436 PyObject *resultobj;
12437 wxJoystick *arg1 = (wxJoystick *) 0 ;
12438 int result;
12439 PyObject * obj0 = 0 ;
12440 char *kwnames[] = {
12441 (char *) "self", NULL
12442 };
12443
12444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12446 if (SWIG_arg_fail(1)) SWIG_fail;
12447 {
12448 PyThreadState* __tstate = wxPyBeginAllowThreads();
12449 result = (int)(arg1)->GetVMax();
12450
12451 wxPyEndAllowThreads(__tstate);
12452 if (PyErr_Occurred()) SWIG_fail;
12453 }
12454 {
12455 resultobj = SWIG_From_int((int)(result));
12456 }
12457 return resultobj;
12458 fail:
12459 return NULL;
12460 }
12461
12462
12463 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12464 PyObject *resultobj;
12465 wxJoystick *arg1 = (wxJoystick *) 0 ;
12466 bool result;
12467 PyObject * obj0 = 0 ;
12468 char *kwnames[] = {
12469 (char *) "self", NULL
12470 };
12471
12472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12474 if (SWIG_arg_fail(1)) SWIG_fail;
12475 {
12476 PyThreadState* __tstate = wxPyBeginAllowThreads();
12477 result = (bool)(arg1)->HasRudder();
12478
12479 wxPyEndAllowThreads(__tstate);
12480 if (PyErr_Occurred()) SWIG_fail;
12481 }
12482 {
12483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12484 }
12485 return resultobj;
12486 fail:
12487 return NULL;
12488 }
12489
12490
12491 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12492 PyObject *resultobj;
12493 wxJoystick *arg1 = (wxJoystick *) 0 ;
12494 bool result;
12495 PyObject * obj0 = 0 ;
12496 char *kwnames[] = {
12497 (char *) "self", NULL
12498 };
12499
12500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12502 if (SWIG_arg_fail(1)) SWIG_fail;
12503 {
12504 PyThreadState* __tstate = wxPyBeginAllowThreads();
12505 result = (bool)(arg1)->HasZ();
12506
12507 wxPyEndAllowThreads(__tstate);
12508 if (PyErr_Occurred()) SWIG_fail;
12509 }
12510 {
12511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12512 }
12513 return resultobj;
12514 fail:
12515 return NULL;
12516 }
12517
12518
12519 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj;
12521 wxJoystick *arg1 = (wxJoystick *) 0 ;
12522 bool result;
12523 PyObject * obj0 = 0 ;
12524 char *kwnames[] = {
12525 (char *) "self", NULL
12526 };
12527
12528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12530 if (SWIG_arg_fail(1)) SWIG_fail;
12531 {
12532 PyThreadState* __tstate = wxPyBeginAllowThreads();
12533 result = (bool)(arg1)->HasU();
12534
12535 wxPyEndAllowThreads(__tstate);
12536 if (PyErr_Occurred()) SWIG_fail;
12537 }
12538 {
12539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12540 }
12541 return resultobj;
12542 fail:
12543 return NULL;
12544 }
12545
12546
12547 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12548 PyObject *resultobj;
12549 wxJoystick *arg1 = (wxJoystick *) 0 ;
12550 bool result;
12551 PyObject * obj0 = 0 ;
12552 char *kwnames[] = {
12553 (char *) "self", NULL
12554 };
12555
12556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12558 if (SWIG_arg_fail(1)) SWIG_fail;
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (bool)(arg1)->HasV();
12562
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 {
12567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12568 }
12569 return resultobj;
12570 fail:
12571 return NULL;
12572 }
12573
12574
12575 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12576 PyObject *resultobj;
12577 wxJoystick *arg1 = (wxJoystick *) 0 ;
12578 bool result;
12579 PyObject * obj0 = 0 ;
12580 char *kwnames[] = {
12581 (char *) "self", NULL
12582 };
12583
12584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12586 if (SWIG_arg_fail(1)) SWIG_fail;
12587 {
12588 PyThreadState* __tstate = wxPyBeginAllowThreads();
12589 result = (bool)(arg1)->HasPOV();
12590
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 {
12595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12596 }
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12604 PyObject *resultobj;
12605 wxJoystick *arg1 = (wxJoystick *) 0 ;
12606 bool result;
12607 PyObject * obj0 = 0 ;
12608 char *kwnames[] = {
12609 (char *) "self", NULL
12610 };
12611
12612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12614 if (SWIG_arg_fail(1)) SWIG_fail;
12615 {
12616 PyThreadState* __tstate = wxPyBeginAllowThreads();
12617 result = (bool)(arg1)->HasPOV4Dir();
12618
12619 wxPyEndAllowThreads(__tstate);
12620 if (PyErr_Occurred()) SWIG_fail;
12621 }
12622 {
12623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12624 }
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12632 PyObject *resultobj;
12633 wxJoystick *arg1 = (wxJoystick *) 0 ;
12634 bool result;
12635 PyObject * obj0 = 0 ;
12636 char *kwnames[] = {
12637 (char *) "self", NULL
12638 };
12639
12640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12642 if (SWIG_arg_fail(1)) SWIG_fail;
12643 {
12644 PyThreadState* __tstate = wxPyBeginAllowThreads();
12645 result = (bool)(arg1)->HasPOVCTS();
12646
12647 wxPyEndAllowThreads(__tstate);
12648 if (PyErr_Occurred()) SWIG_fail;
12649 }
12650 {
12651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12652 }
12653 return resultobj;
12654 fail:
12655 return NULL;
12656 }
12657
12658
12659 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12660 PyObject *resultobj;
12661 wxJoystick *arg1 = (wxJoystick *) 0 ;
12662 wxWindow *arg2 = (wxWindow *) 0 ;
12663 int arg3 = (int) 0 ;
12664 bool result;
12665 PyObject * obj0 = 0 ;
12666 PyObject * obj1 = 0 ;
12667 PyObject * obj2 = 0 ;
12668 char *kwnames[] = {
12669 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12670 };
12671
12672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12674 if (SWIG_arg_fail(1)) SWIG_fail;
12675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12676 if (SWIG_arg_fail(2)) SWIG_fail;
12677 if (obj2) {
12678 {
12679 arg3 = (int)(SWIG_As_int(obj2));
12680 if (SWIG_arg_fail(3)) SWIG_fail;
12681 }
12682 }
12683 {
12684 PyThreadState* __tstate = wxPyBeginAllowThreads();
12685 result = (bool)(arg1)->SetCapture(arg2,arg3);
12686
12687 wxPyEndAllowThreads(__tstate);
12688 if (PyErr_Occurred()) SWIG_fail;
12689 }
12690 {
12691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12692 }
12693 return resultobj;
12694 fail:
12695 return NULL;
12696 }
12697
12698
12699 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12700 PyObject *resultobj;
12701 wxJoystick *arg1 = (wxJoystick *) 0 ;
12702 bool result;
12703 PyObject * obj0 = 0 ;
12704 char *kwnames[] = {
12705 (char *) "self", NULL
12706 };
12707
12708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12710 if (SWIG_arg_fail(1)) SWIG_fail;
12711 {
12712 PyThreadState* __tstate = wxPyBeginAllowThreads();
12713 result = (bool)(arg1)->ReleaseCapture();
12714
12715 wxPyEndAllowThreads(__tstate);
12716 if (PyErr_Occurred()) SWIG_fail;
12717 }
12718 {
12719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12720 }
12721 return resultobj;
12722 fail:
12723 return NULL;
12724 }
12725
12726
12727 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12728 PyObject *obj;
12729 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12730 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12731 Py_INCREF(obj);
12732 return Py_BuildValue((char *)"");
12733 }
12734 static PyObject *_wrap_JoystickEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
12735 PyObject *resultobj;
12736 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12737 wxPoint *arg2 = (wxPoint *) 0 ;
12738 PyObject * obj0 = 0 ;
12739 PyObject * obj1 = 0 ;
12740 char *kwnames[] = {
12741 (char *) "self",(char *) "m_pos", NULL
12742 };
12743
12744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
12745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12746 if (SWIG_arg_fail(1)) SWIG_fail;
12747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12748 if (SWIG_arg_fail(2)) SWIG_fail;
12749 if (arg1) (arg1)->m_pos = *arg2;
12750
12751 Py_INCREF(Py_None); resultobj = Py_None;
12752 return resultobj;
12753 fail:
12754 return NULL;
12755 }
12756
12757
12758 static PyObject *_wrap_JoystickEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
12759 PyObject *resultobj;
12760 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12761 wxPoint *result;
12762 PyObject * obj0 = 0 ;
12763 char *kwnames[] = {
12764 (char *) "self", NULL
12765 };
12766
12767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_pos_get",kwnames,&obj0)) goto fail;
12768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12769 if (SWIG_arg_fail(1)) SWIG_fail;
12770 result = (wxPoint *)& ((arg1)->m_pos);
12771
12772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 static PyObject *_wrap_JoystickEvent_m_zPosition_set(PyObject *, PyObject *args, PyObject *kwargs) {
12780 PyObject *resultobj;
12781 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12782 int arg2 ;
12783 PyObject * obj0 = 0 ;
12784 PyObject * obj1 = 0 ;
12785 char *kwnames[] = {
12786 (char *) "self",(char *) "m_zPosition", NULL
12787 };
12788
12789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_zPosition_set",kwnames,&obj0,&obj1)) goto fail;
12790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12791 if (SWIG_arg_fail(1)) SWIG_fail;
12792 {
12793 arg2 = (int)(SWIG_As_int(obj1));
12794 if (SWIG_arg_fail(2)) SWIG_fail;
12795 }
12796 if (arg1) (arg1)->m_zPosition = arg2;
12797
12798 Py_INCREF(Py_None); resultobj = Py_None;
12799 return resultobj;
12800 fail:
12801 return NULL;
12802 }
12803
12804
12805 static PyObject *_wrap_JoystickEvent_m_zPosition_get(PyObject *, PyObject *args, PyObject *kwargs) {
12806 PyObject *resultobj;
12807 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12808 int result;
12809 PyObject * obj0 = 0 ;
12810 char *kwnames[] = {
12811 (char *) "self", NULL
12812 };
12813
12814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_zPosition_get",kwnames,&obj0)) goto fail;
12815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12816 if (SWIG_arg_fail(1)) SWIG_fail;
12817 result = (int) ((arg1)->m_zPosition);
12818
12819 {
12820 resultobj = SWIG_From_int((int)(result));
12821 }
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 static PyObject *_wrap_JoystickEvent_m_buttonChange_set(PyObject *, PyObject *args, PyObject *kwargs) {
12829 PyObject *resultobj;
12830 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12831 int arg2 ;
12832 PyObject * obj0 = 0 ;
12833 PyObject * obj1 = 0 ;
12834 char *kwnames[] = {
12835 (char *) "self",(char *) "m_buttonChange", NULL
12836 };
12837
12838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonChange_set",kwnames,&obj0,&obj1)) goto fail;
12839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12840 if (SWIG_arg_fail(1)) SWIG_fail;
12841 {
12842 arg2 = (int)(SWIG_As_int(obj1));
12843 if (SWIG_arg_fail(2)) SWIG_fail;
12844 }
12845 if (arg1) (arg1)->m_buttonChange = arg2;
12846
12847 Py_INCREF(Py_None); resultobj = Py_None;
12848 return resultobj;
12849 fail:
12850 return NULL;
12851 }
12852
12853
12854 static PyObject *_wrap_JoystickEvent_m_buttonChange_get(PyObject *, PyObject *args, PyObject *kwargs) {
12855 PyObject *resultobj;
12856 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12857 int result;
12858 PyObject * obj0 = 0 ;
12859 char *kwnames[] = {
12860 (char *) "self", NULL
12861 };
12862
12863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonChange_get",kwnames,&obj0)) goto fail;
12864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12865 if (SWIG_arg_fail(1)) SWIG_fail;
12866 result = (int) ((arg1)->m_buttonChange);
12867
12868 {
12869 resultobj = SWIG_From_int((int)(result));
12870 }
12871 return resultobj;
12872 fail:
12873 return NULL;
12874 }
12875
12876
12877 static PyObject *_wrap_JoystickEvent_m_buttonState_set(PyObject *, PyObject *args, PyObject *kwargs) {
12878 PyObject *resultobj;
12879 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12880 int arg2 ;
12881 PyObject * obj0 = 0 ;
12882 PyObject * obj1 = 0 ;
12883 char *kwnames[] = {
12884 (char *) "self",(char *) "m_buttonState", NULL
12885 };
12886
12887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_buttonState_set",kwnames,&obj0,&obj1)) goto fail;
12888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12889 if (SWIG_arg_fail(1)) SWIG_fail;
12890 {
12891 arg2 = (int)(SWIG_As_int(obj1));
12892 if (SWIG_arg_fail(2)) SWIG_fail;
12893 }
12894 if (arg1) (arg1)->m_buttonState = arg2;
12895
12896 Py_INCREF(Py_None); resultobj = Py_None;
12897 return resultobj;
12898 fail:
12899 return NULL;
12900 }
12901
12902
12903 static PyObject *_wrap_JoystickEvent_m_buttonState_get(PyObject *, PyObject *args, PyObject *kwargs) {
12904 PyObject *resultobj;
12905 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12906 int result;
12907 PyObject * obj0 = 0 ;
12908 char *kwnames[] = {
12909 (char *) "self", NULL
12910 };
12911
12912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_buttonState_get",kwnames,&obj0)) goto fail;
12913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12914 if (SWIG_arg_fail(1)) SWIG_fail;
12915 result = (int) ((arg1)->m_buttonState);
12916
12917 {
12918 resultobj = SWIG_From_int((int)(result));
12919 }
12920 return resultobj;
12921 fail:
12922 return NULL;
12923 }
12924
12925
12926 static PyObject *_wrap_JoystickEvent_m_joyStick_set(PyObject *, PyObject *args, PyObject *kwargs) {
12927 PyObject *resultobj;
12928 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12929 int arg2 ;
12930 PyObject * obj0 = 0 ;
12931 PyObject * obj1 = 0 ;
12932 char *kwnames[] = {
12933 (char *) "self",(char *) "m_joyStick", NULL
12934 };
12935
12936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_m_joyStick_set",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
12941 if (SWIG_arg_fail(2)) SWIG_fail;
12942 }
12943 if (arg1) (arg1)->m_joyStick = arg2;
12944
12945 Py_INCREF(Py_None); resultobj = Py_None;
12946 return resultobj;
12947 fail:
12948 return NULL;
12949 }
12950
12951
12952 static PyObject *_wrap_JoystickEvent_m_joyStick_get(PyObject *, PyObject *args, PyObject *kwargs) {
12953 PyObject *resultobj;
12954 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12955 int result;
12956 PyObject * obj0 = 0 ;
12957 char *kwnames[] = {
12958 (char *) "self", NULL
12959 };
12960
12961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_m_joyStick_get",kwnames,&obj0)) goto fail;
12962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12963 if (SWIG_arg_fail(1)) SWIG_fail;
12964 result = (int) ((arg1)->m_joyStick);
12965
12966 {
12967 resultobj = SWIG_From_int((int)(result));
12968 }
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12976 PyObject *resultobj;
12977 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12978 int arg2 = (int) 0 ;
12979 int arg3 = (int) wxJOYSTICK1 ;
12980 int arg4 = (int) 0 ;
12981 wxJoystickEvent *result;
12982 PyObject * obj0 = 0 ;
12983 PyObject * obj1 = 0 ;
12984 PyObject * obj2 = 0 ;
12985 PyObject * obj3 = 0 ;
12986 char *kwnames[] = {
12987 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12988 };
12989
12990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12991 if (obj0) {
12992 {
12993 arg1 = (wxEventType)(SWIG_As_int(obj0));
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 }
12996 }
12997 if (obj1) {
12998 {
12999 arg2 = (int)(SWIG_As_int(obj1));
13000 if (SWIG_arg_fail(2)) SWIG_fail;
13001 }
13002 }
13003 if (obj2) {
13004 {
13005 arg3 = (int)(SWIG_As_int(obj2));
13006 if (SWIG_arg_fail(3)) SWIG_fail;
13007 }
13008 }
13009 if (obj3) {
13010 {
13011 arg4 = (int)(SWIG_As_int(obj3));
13012 if (SWIG_arg_fail(4)) SWIG_fail;
13013 }
13014 }
13015 {
13016 PyThreadState* __tstate = wxPyBeginAllowThreads();
13017 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13018
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13030 PyObject *resultobj;
13031 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13032 wxPoint result;
13033 PyObject * obj0 = 0 ;
13034 char *kwnames[] = {
13035 (char *) "self", NULL
13036 };
13037
13038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13040 if (SWIG_arg_fail(1)) SWIG_fail;
13041 {
13042 PyThreadState* __tstate = wxPyBeginAllowThreads();
13043 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13044
13045 wxPyEndAllowThreads(__tstate);
13046 if (PyErr_Occurred()) SWIG_fail;
13047 }
13048 {
13049 wxPoint * resultptr;
13050 resultptr = new wxPoint((wxPoint &)(result));
13051 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13052 }
13053 return resultobj;
13054 fail:
13055 return NULL;
13056 }
13057
13058
13059 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13060 PyObject *resultobj;
13061 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13062 int result;
13063 PyObject * obj0 = 0 ;
13064 char *kwnames[] = {
13065 (char *) "self", NULL
13066 };
13067
13068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13070 if (SWIG_arg_fail(1)) SWIG_fail;
13071 {
13072 PyThreadState* __tstate = wxPyBeginAllowThreads();
13073 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13074
13075 wxPyEndAllowThreads(__tstate);
13076 if (PyErr_Occurred()) SWIG_fail;
13077 }
13078 {
13079 resultobj = SWIG_From_int((int)(result));
13080 }
13081 return resultobj;
13082 fail:
13083 return NULL;
13084 }
13085
13086
13087 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13088 PyObject *resultobj;
13089 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13090 int result;
13091 PyObject * obj0 = 0 ;
13092 char *kwnames[] = {
13093 (char *) "self", NULL
13094 };
13095
13096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13098 if (SWIG_arg_fail(1)) SWIG_fail;
13099 {
13100 PyThreadState* __tstate = wxPyBeginAllowThreads();
13101 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13102
13103 wxPyEndAllowThreads(__tstate);
13104 if (PyErr_Occurred()) SWIG_fail;
13105 }
13106 {
13107 resultobj = SWIG_From_int((int)(result));
13108 }
13109 return resultobj;
13110 fail:
13111 return NULL;
13112 }
13113
13114
13115 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13116 PyObject *resultobj;
13117 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13118 int result;
13119 PyObject * obj0 = 0 ;
13120 char *kwnames[] = {
13121 (char *) "self", NULL
13122 };
13123
13124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13126 if (SWIG_arg_fail(1)) SWIG_fail;
13127 {
13128 PyThreadState* __tstate = wxPyBeginAllowThreads();
13129 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13130
13131 wxPyEndAllowThreads(__tstate);
13132 if (PyErr_Occurred()) SWIG_fail;
13133 }
13134 {
13135 resultobj = SWIG_From_int((int)(result));
13136 }
13137 return resultobj;
13138 fail:
13139 return NULL;
13140 }
13141
13142
13143 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13144 PyObject *resultobj;
13145 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13146 int result;
13147 PyObject * obj0 = 0 ;
13148 char *kwnames[] = {
13149 (char *) "self", NULL
13150 };
13151
13152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13154 if (SWIG_arg_fail(1)) SWIG_fail;
13155 {
13156 PyThreadState* __tstate = wxPyBeginAllowThreads();
13157 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13158
13159 wxPyEndAllowThreads(__tstate);
13160 if (PyErr_Occurred()) SWIG_fail;
13161 }
13162 {
13163 resultobj = SWIG_From_int((int)(result));
13164 }
13165 return resultobj;
13166 fail:
13167 return NULL;
13168 }
13169
13170
13171 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13172 PyObject *resultobj;
13173 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13174 int arg2 ;
13175 PyObject * obj0 = 0 ;
13176 PyObject * obj1 = 0 ;
13177 char *kwnames[] = {
13178 (char *) "self",(char *) "stick", NULL
13179 };
13180
13181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13183 if (SWIG_arg_fail(1)) SWIG_fail;
13184 {
13185 arg2 = (int)(SWIG_As_int(obj1));
13186 if (SWIG_arg_fail(2)) SWIG_fail;
13187 }
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 (arg1)->SetJoystick(arg2);
13191
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 Py_INCREF(Py_None); resultobj = Py_None;
13196 return resultobj;
13197 fail:
13198 return NULL;
13199 }
13200
13201
13202 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13203 PyObject *resultobj;
13204 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13205 int arg2 ;
13206 PyObject * obj0 = 0 ;
13207 PyObject * obj1 = 0 ;
13208 char *kwnames[] = {
13209 (char *) "self",(char *) "state", NULL
13210 };
13211
13212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13214 if (SWIG_arg_fail(1)) SWIG_fail;
13215 {
13216 arg2 = (int)(SWIG_As_int(obj1));
13217 if (SWIG_arg_fail(2)) SWIG_fail;
13218 }
13219 {
13220 PyThreadState* __tstate = wxPyBeginAllowThreads();
13221 (arg1)->SetButtonState(arg2);
13222
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 Py_INCREF(Py_None); resultobj = Py_None;
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj;
13235 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13236 int arg2 ;
13237 PyObject * obj0 = 0 ;
13238 PyObject * obj1 = 0 ;
13239 char *kwnames[] = {
13240 (char *) "self",(char *) "change", NULL
13241 };
13242
13243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13245 if (SWIG_arg_fail(1)) SWIG_fail;
13246 {
13247 arg2 = (int)(SWIG_As_int(obj1));
13248 if (SWIG_arg_fail(2)) SWIG_fail;
13249 }
13250 {
13251 PyThreadState* __tstate = wxPyBeginAllowThreads();
13252 (arg1)->SetButtonChange(arg2);
13253
13254 wxPyEndAllowThreads(__tstate);
13255 if (PyErr_Occurred()) SWIG_fail;
13256 }
13257 Py_INCREF(Py_None); resultobj = Py_None;
13258 return resultobj;
13259 fail:
13260 return NULL;
13261 }
13262
13263
13264 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13265 PyObject *resultobj;
13266 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13267 wxPoint *arg2 = 0 ;
13268 wxPoint temp2 ;
13269 PyObject * obj0 = 0 ;
13270 PyObject * obj1 = 0 ;
13271 char *kwnames[] = {
13272 (char *) "self",(char *) "pos", NULL
13273 };
13274
13275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13277 if (SWIG_arg_fail(1)) SWIG_fail;
13278 {
13279 arg2 = &temp2;
13280 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13281 }
13282 {
13283 PyThreadState* __tstate = wxPyBeginAllowThreads();
13284 (arg1)->SetPosition((wxPoint const &)*arg2);
13285
13286 wxPyEndAllowThreads(__tstate);
13287 if (PyErr_Occurred()) SWIG_fail;
13288 }
13289 Py_INCREF(Py_None); resultobj = Py_None;
13290 return resultobj;
13291 fail:
13292 return NULL;
13293 }
13294
13295
13296 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13297 PyObject *resultobj;
13298 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13299 int arg2 ;
13300 PyObject * obj0 = 0 ;
13301 PyObject * obj1 = 0 ;
13302 char *kwnames[] = {
13303 (char *) "self",(char *) "zPos", NULL
13304 };
13305
13306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",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 {
13310 arg2 = (int)(SWIG_As_int(obj1));
13311 if (SWIG_arg_fail(2)) SWIG_fail;
13312 }
13313 {
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 (arg1)->SetZPosition(arg2);
13316
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 Py_INCREF(Py_None); resultobj = Py_None;
13321 return resultobj;
13322 fail:
13323 return NULL;
13324 }
13325
13326
13327 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13328 PyObject *resultobj;
13329 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13330 bool result;
13331 PyObject * obj0 = 0 ;
13332 char *kwnames[] = {
13333 (char *) "self", NULL
13334 };
13335
13336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13338 if (SWIG_arg_fail(1)) SWIG_fail;
13339 {
13340 PyThreadState* __tstate = wxPyBeginAllowThreads();
13341 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13342
13343 wxPyEndAllowThreads(__tstate);
13344 if (PyErr_Occurred()) SWIG_fail;
13345 }
13346 {
13347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13348 }
13349 return resultobj;
13350 fail:
13351 return NULL;
13352 }
13353
13354
13355 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13356 PyObject *resultobj;
13357 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13358 bool result;
13359 PyObject * obj0 = 0 ;
13360 char *kwnames[] = {
13361 (char *) "self", NULL
13362 };
13363
13364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13366 if (SWIG_arg_fail(1)) SWIG_fail;
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13370
13371 wxPyEndAllowThreads(__tstate);
13372 if (PyErr_Occurred()) SWIG_fail;
13373 }
13374 {
13375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13376 }
13377 return resultobj;
13378 fail:
13379 return NULL;
13380 }
13381
13382
13383 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13384 PyObject *resultobj;
13385 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13386 bool result;
13387 PyObject * obj0 = 0 ;
13388 char *kwnames[] = {
13389 (char *) "self", NULL
13390 };
13391
13392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13394 if (SWIG_arg_fail(1)) SWIG_fail;
13395 {
13396 PyThreadState* __tstate = wxPyBeginAllowThreads();
13397 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13398
13399 wxPyEndAllowThreads(__tstate);
13400 if (PyErr_Occurred()) SWIG_fail;
13401 }
13402 {
13403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13404 }
13405 return resultobj;
13406 fail:
13407 return NULL;
13408 }
13409
13410
13411 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13412 PyObject *resultobj;
13413 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13414 int arg2 = (int) wxJOY_BUTTON_ANY ;
13415 bool result;
13416 PyObject * obj0 = 0 ;
13417 PyObject * obj1 = 0 ;
13418 char *kwnames[] = {
13419 (char *) "self",(char *) "but", NULL
13420 };
13421
13422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13424 if (SWIG_arg_fail(1)) SWIG_fail;
13425 if (obj1) {
13426 {
13427 arg2 = (int)(SWIG_As_int(obj1));
13428 if (SWIG_arg_fail(2)) SWIG_fail;
13429 }
13430 }
13431 {
13432 PyThreadState* __tstate = wxPyBeginAllowThreads();
13433 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13434
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 {
13439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13440 }
13441 return resultobj;
13442 fail:
13443 return NULL;
13444 }
13445
13446
13447 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13448 PyObject *resultobj;
13449 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13450 int arg2 = (int) wxJOY_BUTTON_ANY ;
13451 bool result;
13452 PyObject * obj0 = 0 ;
13453 PyObject * obj1 = 0 ;
13454 char *kwnames[] = {
13455 (char *) "self",(char *) "but", NULL
13456 };
13457
13458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13460 if (SWIG_arg_fail(1)) SWIG_fail;
13461 if (obj1) {
13462 {
13463 arg2 = (int)(SWIG_As_int(obj1));
13464 if (SWIG_arg_fail(2)) SWIG_fail;
13465 }
13466 }
13467 {
13468 PyThreadState* __tstate = wxPyBeginAllowThreads();
13469 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13470
13471 wxPyEndAllowThreads(__tstate);
13472 if (PyErr_Occurred()) SWIG_fail;
13473 }
13474 {
13475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13476 }
13477 return resultobj;
13478 fail:
13479 return NULL;
13480 }
13481
13482
13483 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13484 PyObject *resultobj;
13485 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13486 int arg2 = (int) wxJOY_BUTTON_ANY ;
13487 bool result;
13488 PyObject * obj0 = 0 ;
13489 PyObject * obj1 = 0 ;
13490 char *kwnames[] = {
13491 (char *) "self",(char *) "but", NULL
13492 };
13493
13494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13496 if (SWIG_arg_fail(1)) SWIG_fail;
13497 if (obj1) {
13498 {
13499 arg2 = (int)(SWIG_As_int(obj1));
13500 if (SWIG_arg_fail(2)) SWIG_fail;
13501 }
13502 }
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13506
13507 wxPyEndAllowThreads(__tstate);
13508 if (PyErr_Occurred()) SWIG_fail;
13509 }
13510 {
13511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13512 }
13513 return resultobj;
13514 fail:
13515 return NULL;
13516 }
13517
13518
13519 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13520 PyObject *obj;
13521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13522 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13523 Py_INCREF(obj);
13524 return Py_BuildValue((char *)"");
13525 }
13526 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj;
13528 wxString const &arg1_defvalue = wxPyEmptyString ;
13529 wxString *arg1 = (wxString *) &arg1_defvalue ;
13530 wxSound *result;
13531 bool temp1 = false ;
13532 PyObject * obj0 = 0 ;
13533 char *kwnames[] = {
13534 (char *) "fileName", NULL
13535 };
13536
13537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13538 if (obj0) {
13539 {
13540 arg1 = wxString_in_helper(obj0);
13541 if (arg1 == NULL) SWIG_fail;
13542 temp1 = true;
13543 }
13544 }
13545 {
13546 if (!wxPyCheckForApp()) SWIG_fail;
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13549
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13554 {
13555 if (temp1)
13556 delete arg1;
13557 }
13558 return resultobj;
13559 fail:
13560 {
13561 if (temp1)
13562 delete arg1;
13563 }
13564 return NULL;
13565 }
13566
13567
13568 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13569 PyObject *resultobj;
13570 PyObject *arg1 = (PyObject *) 0 ;
13571 wxSound *result;
13572 PyObject * obj0 = 0 ;
13573 char *kwnames[] = {
13574 (char *) "data", NULL
13575 };
13576
13577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13578 arg1 = obj0;
13579 {
13580 if (!wxPyCheckForApp()) SWIG_fail;
13581 PyThreadState* __tstate = wxPyBeginAllowThreads();
13582 result = (wxSound *)new_wxSound(arg1);
13583
13584 wxPyEndAllowThreads(__tstate);
13585 if (PyErr_Occurred()) SWIG_fail;
13586 }
13587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13588 return resultobj;
13589 fail:
13590 return NULL;
13591 }
13592
13593
13594 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13595 PyObject *resultobj;
13596 wxSound *arg1 = (wxSound *) 0 ;
13597 PyObject * obj0 = 0 ;
13598 char *kwnames[] = {
13599 (char *) "self", NULL
13600 };
13601
13602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13604 if (SWIG_arg_fail(1)) SWIG_fail;
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 delete arg1;
13608
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 Py_INCREF(Py_None); resultobj = Py_None;
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj;
13621 wxSound *arg1 = (wxSound *) 0 ;
13622 wxString *arg2 = 0 ;
13623 bool result;
13624 bool temp2 = false ;
13625 PyObject * obj0 = 0 ;
13626 PyObject * obj1 = 0 ;
13627 char *kwnames[] = {
13628 (char *) "self",(char *) "fileName", NULL
13629 };
13630
13631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13633 if (SWIG_arg_fail(1)) SWIG_fail;
13634 {
13635 arg2 = wxString_in_helper(obj1);
13636 if (arg2 == NULL) SWIG_fail;
13637 temp2 = true;
13638 }
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 result = (bool)(arg1)->Create((wxString const &)*arg2);
13642
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 {
13647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13648 }
13649 {
13650 if (temp2)
13651 delete arg2;
13652 }
13653 return resultobj;
13654 fail:
13655 {
13656 if (temp2)
13657 delete arg2;
13658 }
13659 return NULL;
13660 }
13661
13662
13663 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13664 PyObject *resultobj;
13665 wxSound *arg1 = (wxSound *) 0 ;
13666 PyObject *arg2 = (PyObject *) 0 ;
13667 bool result;
13668 PyObject * obj0 = 0 ;
13669 PyObject * obj1 = 0 ;
13670 char *kwnames[] = {
13671 (char *) "self",(char *) "data", NULL
13672 };
13673
13674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13676 if (SWIG_arg_fail(1)) SWIG_fail;
13677 arg2 = obj1;
13678 {
13679 PyThreadState* __tstate = wxPyBeginAllowThreads();
13680 result = (bool)wxSound_CreateFromData(arg1,arg2);
13681
13682 wxPyEndAllowThreads(__tstate);
13683 if (PyErr_Occurred()) SWIG_fail;
13684 }
13685 {
13686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13687 }
13688 return resultobj;
13689 fail:
13690 return NULL;
13691 }
13692
13693
13694 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13695 PyObject *resultobj;
13696 wxSound *arg1 = (wxSound *) 0 ;
13697 bool result;
13698 PyObject * obj0 = 0 ;
13699 char *kwnames[] = {
13700 (char *) "self", NULL
13701 };
13702
13703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13705 if (SWIG_arg_fail(1)) SWIG_fail;
13706 {
13707 PyThreadState* __tstate = wxPyBeginAllowThreads();
13708 result = (bool)(arg1)->IsOk();
13709
13710 wxPyEndAllowThreads(__tstate);
13711 if (PyErr_Occurred()) SWIG_fail;
13712 }
13713 {
13714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13715 }
13716 return resultobj;
13717 fail:
13718 return NULL;
13719 }
13720
13721
13722 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13723 PyObject *resultobj;
13724 wxSound *arg1 = (wxSound *) 0 ;
13725 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13726 bool result;
13727 PyObject * obj0 = 0 ;
13728 PyObject * obj1 = 0 ;
13729 char *kwnames[] = {
13730 (char *) "self",(char *) "flags", NULL
13731 };
13732
13733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13735 if (SWIG_arg_fail(1)) SWIG_fail;
13736 if (obj1) {
13737 {
13738 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13739 if (SWIG_arg_fail(2)) SWIG_fail;
13740 }
13741 }
13742 {
13743 if (!wxPyCheckForApp()) SWIG_fail;
13744 PyThreadState* __tstate = wxPyBeginAllowThreads();
13745 result = (bool)((wxSound const *)arg1)->Play(arg2);
13746
13747 wxPyEndAllowThreads(__tstate);
13748 if (PyErr_Occurred()) SWIG_fail;
13749 }
13750 {
13751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13752 }
13753 return resultobj;
13754 fail:
13755 return NULL;
13756 }
13757
13758
13759 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj;
13761 wxString *arg1 = 0 ;
13762 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13763 bool result;
13764 bool temp1 = false ;
13765 PyObject * obj0 = 0 ;
13766 PyObject * obj1 = 0 ;
13767 char *kwnames[] = {
13768 (char *) "filename",(char *) "flags", NULL
13769 };
13770
13771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13772 {
13773 arg1 = wxString_in_helper(obj0);
13774 if (arg1 == NULL) SWIG_fail;
13775 temp1 = true;
13776 }
13777 if (obj1) {
13778 {
13779 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13780 if (SWIG_arg_fail(2)) SWIG_fail;
13781 }
13782 }
13783 {
13784 if (!wxPyCheckForApp()) SWIG_fail;
13785 PyThreadState* __tstate = wxPyBeginAllowThreads();
13786 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13787
13788 wxPyEndAllowThreads(__tstate);
13789 if (PyErr_Occurred()) SWIG_fail;
13790 }
13791 {
13792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13793 }
13794 {
13795 if (temp1)
13796 delete arg1;
13797 }
13798 return resultobj;
13799 fail:
13800 {
13801 if (temp1)
13802 delete arg1;
13803 }
13804 return NULL;
13805 }
13806
13807
13808 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13809 PyObject *resultobj;
13810 char *kwnames[] = {
13811 NULL
13812 };
13813
13814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13815 {
13816 if (!wxPyCheckForApp()) SWIG_fail;
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 Sound_Stop();
13819
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 Py_INCREF(Py_None); resultobj = Py_None;
13824 return resultobj;
13825 fail:
13826 return NULL;
13827 }
13828
13829
13830 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13831 PyObject *obj;
13832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13833 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13834 Py_INCREF(obj);
13835 return Py_BuildValue((char *)"");
13836 }
13837 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13838 PyObject *resultobj;
13839 wxString *arg1 = 0 ;
13840 wxString *arg2 = 0 ;
13841 wxString *arg3 = 0 ;
13842 wxString *arg4 = 0 ;
13843 wxFileTypeInfo *result;
13844 bool temp1 = false ;
13845 bool temp2 = false ;
13846 bool temp3 = false ;
13847 bool temp4 = false ;
13848 PyObject * obj0 = 0 ;
13849 PyObject * obj1 = 0 ;
13850 PyObject * obj2 = 0 ;
13851 PyObject * obj3 = 0 ;
13852 char *kwnames[] = {
13853 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13854 };
13855
13856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13857 {
13858 arg1 = wxString_in_helper(obj0);
13859 if (arg1 == NULL) SWIG_fail;
13860 temp1 = true;
13861 }
13862 {
13863 arg2 = wxString_in_helper(obj1);
13864 if (arg2 == NULL) SWIG_fail;
13865 temp2 = true;
13866 }
13867 {
13868 arg3 = wxString_in_helper(obj2);
13869 if (arg3 == NULL) SWIG_fail;
13870 temp3 = true;
13871 }
13872 {
13873 arg4 = wxString_in_helper(obj3);
13874 if (arg4 == NULL) SWIG_fail;
13875 temp4 = true;
13876 }
13877 {
13878 PyThreadState* __tstate = wxPyBeginAllowThreads();
13879 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13880
13881 wxPyEndAllowThreads(__tstate);
13882 if (PyErr_Occurred()) SWIG_fail;
13883 }
13884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13885 {
13886 if (temp1)
13887 delete arg1;
13888 }
13889 {
13890 if (temp2)
13891 delete arg2;
13892 }
13893 {
13894 if (temp3)
13895 delete arg3;
13896 }
13897 {
13898 if (temp4)
13899 delete arg4;
13900 }
13901 return resultobj;
13902 fail:
13903 {
13904 if (temp1)
13905 delete arg1;
13906 }
13907 {
13908 if (temp2)
13909 delete arg2;
13910 }
13911 {
13912 if (temp3)
13913 delete arg3;
13914 }
13915 {
13916 if (temp4)
13917 delete arg4;
13918 }
13919 return NULL;
13920 }
13921
13922
13923 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13924 PyObject *resultobj;
13925 wxArrayString *arg1 = 0 ;
13926 wxFileTypeInfo *result;
13927 bool temp1 = false ;
13928 PyObject * obj0 = 0 ;
13929 char *kwnames[] = {
13930 (char *) "sArray", NULL
13931 };
13932
13933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13934 {
13935 if (! PySequence_Check(obj0)) {
13936 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13937 SWIG_fail;
13938 }
13939 arg1 = new wxArrayString;
13940 temp1 = true;
13941 int i, len=PySequence_Length(obj0);
13942 for (i=0; i<len; i++) {
13943 PyObject* item = PySequence_GetItem(obj0, i);
13944 #if wxUSE_UNICODE
13945 PyObject* str = PyObject_Unicode(item);
13946 #else
13947 PyObject* str = PyObject_Str(item);
13948 #endif
13949 if (PyErr_Occurred()) SWIG_fail;
13950 arg1->Add(Py2wxString(str));
13951 Py_DECREF(item);
13952 Py_DECREF(str);
13953 }
13954 }
13955 {
13956 PyThreadState* __tstate = wxPyBeginAllowThreads();
13957 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13958
13959 wxPyEndAllowThreads(__tstate);
13960 if (PyErr_Occurred()) SWIG_fail;
13961 }
13962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13963 {
13964 if (temp1) delete arg1;
13965 }
13966 return resultobj;
13967 fail:
13968 {
13969 if (temp1) delete arg1;
13970 }
13971 return NULL;
13972 }
13973
13974
13975 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13976 PyObject *resultobj;
13977 wxFileTypeInfo *result;
13978 char *kwnames[] = {
13979 NULL
13980 };
13981
13982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13983 {
13984 PyThreadState* __tstate = wxPyBeginAllowThreads();
13985 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13986
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13991 return resultobj;
13992 fail:
13993 return NULL;
13994 }
13995
13996
13997 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13998 PyObject *resultobj;
13999 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14000 bool result;
14001 PyObject * obj0 = 0 ;
14002 char *kwnames[] = {
14003 (char *) "self", NULL
14004 };
14005
14006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",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 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14012
14013 wxPyEndAllowThreads(__tstate);
14014 if (PyErr_Occurred()) SWIG_fail;
14015 }
14016 {
14017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14018 }
14019 return resultobj;
14020 fail:
14021 return NULL;
14022 }
14023
14024
14025 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14026 PyObject *resultobj;
14027 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14028 wxString *arg2 = 0 ;
14029 int arg3 = (int) 0 ;
14030 bool temp2 = false ;
14031 PyObject * obj0 = 0 ;
14032 PyObject * obj1 = 0 ;
14033 PyObject * obj2 = 0 ;
14034 char *kwnames[] = {
14035 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14036 };
14037
14038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14040 if (SWIG_arg_fail(1)) SWIG_fail;
14041 {
14042 arg2 = wxString_in_helper(obj1);
14043 if (arg2 == NULL) SWIG_fail;
14044 temp2 = true;
14045 }
14046 if (obj2) {
14047 {
14048 arg3 = (int)(SWIG_As_int(obj2));
14049 if (SWIG_arg_fail(3)) SWIG_fail;
14050 }
14051 }
14052 {
14053 PyThreadState* __tstate = wxPyBeginAllowThreads();
14054 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14055
14056 wxPyEndAllowThreads(__tstate);
14057 if (PyErr_Occurred()) SWIG_fail;
14058 }
14059 Py_INCREF(Py_None); resultobj = Py_None;
14060 {
14061 if (temp2)
14062 delete arg2;
14063 }
14064 return resultobj;
14065 fail:
14066 {
14067 if (temp2)
14068 delete arg2;
14069 }
14070 return NULL;
14071 }
14072
14073
14074 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj;
14076 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14077 wxString *arg2 = 0 ;
14078 bool temp2 = false ;
14079 PyObject * obj0 = 0 ;
14080 PyObject * obj1 = 0 ;
14081 char *kwnames[] = {
14082 (char *) "self",(char *) "shortDesc", NULL
14083 };
14084
14085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14087 if (SWIG_arg_fail(1)) SWIG_fail;
14088 {
14089 arg2 = wxString_in_helper(obj1);
14090 if (arg2 == NULL) SWIG_fail;
14091 temp2 = true;
14092 }
14093 {
14094 PyThreadState* __tstate = wxPyBeginAllowThreads();
14095 (arg1)->SetShortDesc((wxString const &)*arg2);
14096
14097 wxPyEndAllowThreads(__tstate);
14098 if (PyErr_Occurred()) SWIG_fail;
14099 }
14100 Py_INCREF(Py_None); resultobj = Py_None;
14101 {
14102 if (temp2)
14103 delete arg2;
14104 }
14105 return resultobj;
14106 fail:
14107 {
14108 if (temp2)
14109 delete arg2;
14110 }
14111 return NULL;
14112 }
14113
14114
14115 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14116 PyObject *resultobj;
14117 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14118 wxString *result;
14119 PyObject * obj0 = 0 ;
14120 char *kwnames[] = {
14121 (char *) "self", NULL
14122 };
14123
14124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14126 if (SWIG_arg_fail(1)) SWIG_fail;
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 {
14130 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14131 result = (wxString *) &_result_ref;
14132 }
14133
14134 wxPyEndAllowThreads(__tstate);
14135 if (PyErr_Occurred()) SWIG_fail;
14136 }
14137 {
14138 #if wxUSE_UNICODE
14139 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14140 #else
14141 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14142 #endif
14143 }
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14153 wxString *result;
14154 PyObject * obj0 = 0 ;
14155 char *kwnames[] = {
14156 (char *) "self", NULL
14157 };
14158
14159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14161 if (SWIG_arg_fail(1)) SWIG_fail;
14162 {
14163 PyThreadState* __tstate = wxPyBeginAllowThreads();
14164 {
14165 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14166 result = (wxString *) &_result_ref;
14167 }
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 {
14173 #if wxUSE_UNICODE
14174 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14175 #else
14176 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14177 #endif
14178 }
14179 return resultobj;
14180 fail:
14181 return NULL;
14182 }
14183
14184
14185 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14186 PyObject *resultobj;
14187 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14188 wxString *result;
14189 PyObject * obj0 = 0 ;
14190 char *kwnames[] = {
14191 (char *) "self", NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14196 if (SWIG_arg_fail(1)) SWIG_fail;
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 {
14200 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14201 result = (wxString *) &_result_ref;
14202 }
14203
14204 wxPyEndAllowThreads(__tstate);
14205 if (PyErr_Occurred()) SWIG_fail;
14206 }
14207 {
14208 #if wxUSE_UNICODE
14209 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14210 #else
14211 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14212 #endif
14213 }
14214 return resultobj;
14215 fail:
14216 return NULL;
14217 }
14218
14219
14220 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14221 PyObject *resultobj;
14222 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14223 wxString *result;
14224 PyObject * obj0 = 0 ;
14225 char *kwnames[] = {
14226 (char *) "self", NULL
14227 };
14228
14229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14231 if (SWIG_arg_fail(1)) SWIG_fail;
14232 {
14233 PyThreadState* __tstate = wxPyBeginAllowThreads();
14234 {
14235 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14236 result = (wxString *) &_result_ref;
14237 }
14238
14239 wxPyEndAllowThreads(__tstate);
14240 if (PyErr_Occurred()) SWIG_fail;
14241 }
14242 {
14243 #if wxUSE_UNICODE
14244 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14245 #else
14246 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14247 #endif
14248 }
14249 return resultobj;
14250 fail:
14251 return NULL;
14252 }
14253
14254
14255 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj;
14257 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14258 wxString *result;
14259 PyObject * obj0 = 0 ;
14260 char *kwnames[] = {
14261 (char *) "self", NULL
14262 };
14263
14264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14266 if (SWIG_arg_fail(1)) SWIG_fail;
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 {
14270 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14271 result = (wxString *) &_result_ref;
14272 }
14273
14274 wxPyEndAllowThreads(__tstate);
14275 if (PyErr_Occurred()) SWIG_fail;
14276 }
14277 {
14278 #if wxUSE_UNICODE
14279 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14280 #else
14281 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14282 #endif
14283 }
14284 return resultobj;
14285 fail:
14286 return NULL;
14287 }
14288
14289
14290 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14291 PyObject *resultobj;
14292 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14293 wxArrayString *result;
14294 PyObject * obj0 = 0 ;
14295 char *kwnames[] = {
14296 (char *) "self", NULL
14297 };
14298
14299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14301 if (SWIG_arg_fail(1)) SWIG_fail;
14302 {
14303 PyThreadState* __tstate = wxPyBeginAllowThreads();
14304 {
14305 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14306 result = (wxArrayString *) &_result_ref;
14307 }
14308
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 {
14313 resultobj = wxArrayString2PyList_helper(*result);
14314 }
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj;
14323 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14324 int result;
14325 PyObject * obj0 = 0 ;
14326 char *kwnames[] = {
14327 (char *) "self", NULL
14328 };
14329
14330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14332 if (SWIG_arg_fail(1)) SWIG_fail;
14333 {
14334 PyThreadState* __tstate = wxPyBeginAllowThreads();
14335 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14336
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 {
14341 resultobj = SWIG_From_int((int)(result));
14342 }
14343 return resultobj;
14344 fail:
14345 return NULL;
14346 }
14347
14348
14349 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14350 PyObject *resultobj;
14351 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14352 wxString *result;
14353 PyObject * obj0 = 0 ;
14354 char *kwnames[] = {
14355 (char *) "self", NULL
14356 };
14357
14358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14360 if (SWIG_arg_fail(1)) SWIG_fail;
14361 {
14362 PyThreadState* __tstate = wxPyBeginAllowThreads();
14363 {
14364 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14365 result = (wxString *) &_result_ref;
14366 }
14367
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 {
14372 #if wxUSE_UNICODE
14373 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14374 #else
14375 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14376 #endif
14377 }
14378 return resultobj;
14379 fail:
14380 return NULL;
14381 }
14382
14383
14384 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14385 PyObject *resultobj;
14386 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14387 int result;
14388 PyObject * obj0 = 0 ;
14389 char *kwnames[] = {
14390 (char *) "self", NULL
14391 };
14392
14393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14395 if (SWIG_arg_fail(1)) SWIG_fail;
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14399
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 {
14404 resultobj = SWIG_From_int((int)(result));
14405 }
14406 return resultobj;
14407 fail:
14408 return NULL;
14409 }
14410
14411
14412 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14413 PyObject *obj;
14414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14415 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14416 Py_INCREF(obj);
14417 return Py_BuildValue((char *)"");
14418 }
14419 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14420 PyObject *resultobj;
14421 wxFileTypeInfo *arg1 = 0 ;
14422 wxFileType *result;
14423 PyObject * obj0 = 0 ;
14424 char *kwnames[] = {
14425 (char *) "ftInfo", NULL
14426 };
14427
14428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14429 {
14430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14431 if (SWIG_arg_fail(1)) SWIG_fail;
14432 if (arg1 == NULL) {
14433 SWIG_null_ref("wxFileTypeInfo");
14434 }
14435 if (SWIG_arg_fail(1)) SWIG_fail;
14436 }
14437 {
14438 PyThreadState* __tstate = wxPyBeginAllowThreads();
14439 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14440
14441 wxPyEndAllowThreads(__tstate);
14442 if (PyErr_Occurred()) SWIG_fail;
14443 }
14444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14445 return resultobj;
14446 fail:
14447 return NULL;
14448 }
14449
14450
14451 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14452 PyObject *resultobj;
14453 wxFileType *arg1 = (wxFileType *) 0 ;
14454 PyObject * obj0 = 0 ;
14455 char *kwnames[] = {
14456 (char *) "self", NULL
14457 };
14458
14459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14461 if (SWIG_arg_fail(1)) SWIG_fail;
14462 {
14463 PyThreadState* __tstate = wxPyBeginAllowThreads();
14464 delete arg1;
14465
14466 wxPyEndAllowThreads(__tstate);
14467 if (PyErr_Occurred()) SWIG_fail;
14468 }
14469 Py_INCREF(Py_None); resultobj = Py_None;
14470 return resultobj;
14471 fail:
14472 return NULL;
14473 }
14474
14475
14476 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj;
14478 wxFileType *arg1 = (wxFileType *) 0 ;
14479 PyObject *result;
14480 PyObject * obj0 = 0 ;
14481 char *kwnames[] = {
14482 (char *) "self", NULL
14483 };
14484
14485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14487 if (SWIG_arg_fail(1)) SWIG_fail;
14488 {
14489 PyThreadState* __tstate = wxPyBeginAllowThreads();
14490 result = (PyObject *)wxFileType_GetMimeType(arg1);
14491
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 resultobj = result;
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14503 PyObject *resultobj;
14504 wxFileType *arg1 = (wxFileType *) 0 ;
14505 PyObject *result;
14506 PyObject * obj0 = 0 ;
14507 char *kwnames[] = {
14508 (char *) "self", NULL
14509 };
14510
14511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14513 if (SWIG_arg_fail(1)) SWIG_fail;
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14517
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = result;
14522 return resultobj;
14523 fail:
14524 return NULL;
14525 }
14526
14527
14528 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14529 PyObject *resultobj;
14530 wxFileType *arg1 = (wxFileType *) 0 ;
14531 PyObject *result;
14532 PyObject * obj0 = 0 ;
14533 char *kwnames[] = {
14534 (char *) "self", NULL
14535 };
14536
14537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14539 if (SWIG_arg_fail(1)) SWIG_fail;
14540 {
14541 PyThreadState* __tstate = wxPyBeginAllowThreads();
14542 result = (PyObject *)wxFileType_GetExtensions(arg1);
14543
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 resultobj = result;
14548 return resultobj;
14549 fail:
14550 return NULL;
14551 }
14552
14553
14554 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14555 PyObject *resultobj;
14556 wxFileType *arg1 = (wxFileType *) 0 ;
14557 wxIcon *result;
14558 PyObject * obj0 = 0 ;
14559 char *kwnames[] = {
14560 (char *) "self", NULL
14561 };
14562
14563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14565 if (SWIG_arg_fail(1)) SWIG_fail;
14566 {
14567 PyThreadState* __tstate = wxPyBeginAllowThreads();
14568 result = (wxIcon *)wxFileType_GetIcon(arg1);
14569
14570 wxPyEndAllowThreads(__tstate);
14571 if (PyErr_Occurred()) SWIG_fail;
14572 }
14573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14574 return resultobj;
14575 fail:
14576 return NULL;
14577 }
14578
14579
14580 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14581 PyObject *resultobj;
14582 wxFileType *arg1 = (wxFileType *) 0 ;
14583 PyObject *result;
14584 PyObject * obj0 = 0 ;
14585 char *kwnames[] = {
14586 (char *) "self", NULL
14587 };
14588
14589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14591 if (SWIG_arg_fail(1)) SWIG_fail;
14592 {
14593 PyThreadState* __tstate = wxPyBeginAllowThreads();
14594 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14595
14596 wxPyEndAllowThreads(__tstate);
14597 if (PyErr_Occurred()) SWIG_fail;
14598 }
14599 resultobj = result;
14600 return resultobj;
14601 fail:
14602 return NULL;
14603 }
14604
14605
14606 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14607 PyObject *resultobj;
14608 wxFileType *arg1 = (wxFileType *) 0 ;
14609 PyObject *result;
14610 PyObject * obj0 = 0 ;
14611 char *kwnames[] = {
14612 (char *) "self", NULL
14613 };
14614
14615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14617 if (SWIG_arg_fail(1)) SWIG_fail;
14618 {
14619 PyThreadState* __tstate = wxPyBeginAllowThreads();
14620 result = (PyObject *)wxFileType_GetDescription(arg1);
14621
14622 wxPyEndAllowThreads(__tstate);
14623 if (PyErr_Occurred()) SWIG_fail;
14624 }
14625 resultobj = result;
14626 return resultobj;
14627 fail:
14628 return NULL;
14629 }
14630
14631
14632 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14633 PyObject *resultobj;
14634 wxFileType *arg1 = (wxFileType *) 0 ;
14635 wxString *arg2 = 0 ;
14636 wxString const &arg3_defvalue = wxPyEmptyString ;
14637 wxString *arg3 = (wxString *) &arg3_defvalue ;
14638 PyObject *result;
14639 bool temp2 = false ;
14640 bool temp3 = false ;
14641 PyObject * obj0 = 0 ;
14642 PyObject * obj1 = 0 ;
14643 PyObject * obj2 = 0 ;
14644 char *kwnames[] = {
14645 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14646 };
14647
14648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14650 if (SWIG_arg_fail(1)) SWIG_fail;
14651 {
14652 arg2 = wxString_in_helper(obj1);
14653 if (arg2 == NULL) SWIG_fail;
14654 temp2 = true;
14655 }
14656 if (obj2) {
14657 {
14658 arg3 = wxString_in_helper(obj2);
14659 if (arg3 == NULL) SWIG_fail;
14660 temp3 = true;
14661 }
14662 }
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14666
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 resultobj = result;
14671 {
14672 if (temp2)
14673 delete arg2;
14674 }
14675 {
14676 if (temp3)
14677 delete arg3;
14678 }
14679 return resultobj;
14680 fail:
14681 {
14682 if (temp2)
14683 delete arg2;
14684 }
14685 {
14686 if (temp3)
14687 delete arg3;
14688 }
14689 return NULL;
14690 }
14691
14692
14693 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14694 PyObject *resultobj;
14695 wxFileType *arg1 = (wxFileType *) 0 ;
14696 wxString *arg2 = 0 ;
14697 wxString const &arg3_defvalue = wxPyEmptyString ;
14698 wxString *arg3 = (wxString *) &arg3_defvalue ;
14699 PyObject *result;
14700 bool temp2 = false ;
14701 bool temp3 = false ;
14702 PyObject * obj0 = 0 ;
14703 PyObject * obj1 = 0 ;
14704 PyObject * obj2 = 0 ;
14705 char *kwnames[] = {
14706 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14707 };
14708
14709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14711 if (SWIG_arg_fail(1)) SWIG_fail;
14712 {
14713 arg2 = wxString_in_helper(obj1);
14714 if (arg2 == NULL) SWIG_fail;
14715 temp2 = true;
14716 }
14717 if (obj2) {
14718 {
14719 arg3 = wxString_in_helper(obj2);
14720 if (arg3 == NULL) SWIG_fail;
14721 temp3 = true;
14722 }
14723 }
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14727
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 resultobj = result;
14732 {
14733 if (temp2)
14734 delete arg2;
14735 }
14736 {
14737 if (temp3)
14738 delete arg3;
14739 }
14740 return resultobj;
14741 fail:
14742 {
14743 if (temp2)
14744 delete arg2;
14745 }
14746 {
14747 if (temp3)
14748 delete arg3;
14749 }
14750 return NULL;
14751 }
14752
14753
14754 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14755 PyObject *resultobj;
14756 wxFileType *arg1 = (wxFileType *) 0 ;
14757 wxString *arg2 = 0 ;
14758 wxString const &arg3_defvalue = wxPyEmptyString ;
14759 wxString *arg3 = (wxString *) &arg3_defvalue ;
14760 PyObject *result;
14761 bool temp2 = false ;
14762 bool temp3 = false ;
14763 PyObject * obj0 = 0 ;
14764 PyObject * obj1 = 0 ;
14765 PyObject * obj2 = 0 ;
14766 char *kwnames[] = {
14767 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14768 };
14769
14770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14772 if (SWIG_arg_fail(1)) SWIG_fail;
14773 {
14774 arg2 = wxString_in_helper(obj1);
14775 if (arg2 == NULL) SWIG_fail;
14776 temp2 = true;
14777 }
14778 if (obj2) {
14779 {
14780 arg3 = wxString_in_helper(obj2);
14781 if (arg3 == NULL) SWIG_fail;
14782 temp3 = true;
14783 }
14784 }
14785 {
14786 PyThreadState* __tstate = wxPyBeginAllowThreads();
14787 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14788
14789 wxPyEndAllowThreads(__tstate);
14790 if (PyErr_Occurred()) SWIG_fail;
14791 }
14792 resultobj = result;
14793 {
14794 if (temp2)
14795 delete arg2;
14796 }
14797 {
14798 if (temp3)
14799 delete arg3;
14800 }
14801 return resultobj;
14802 fail:
14803 {
14804 if (temp2)
14805 delete arg2;
14806 }
14807 {
14808 if (temp3)
14809 delete arg3;
14810 }
14811 return NULL;
14812 }
14813
14814
14815 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14816 PyObject *resultobj;
14817 wxFileType *arg1 = (wxFileType *) 0 ;
14818 wxString *arg2 = 0 ;
14819 wxString *arg3 = 0 ;
14820 bool arg4 = (bool) true ;
14821 bool result;
14822 bool temp2 = false ;
14823 bool temp3 = false ;
14824 PyObject * obj0 = 0 ;
14825 PyObject * obj1 = 0 ;
14826 PyObject * obj2 = 0 ;
14827 PyObject * obj3 = 0 ;
14828 char *kwnames[] = {
14829 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14830 };
14831
14832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14834 if (SWIG_arg_fail(1)) SWIG_fail;
14835 {
14836 arg2 = wxString_in_helper(obj1);
14837 if (arg2 == NULL) SWIG_fail;
14838 temp2 = true;
14839 }
14840 {
14841 arg3 = wxString_in_helper(obj2);
14842 if (arg3 == NULL) SWIG_fail;
14843 temp3 = true;
14844 }
14845 if (obj3) {
14846 {
14847 arg4 = (bool)(SWIG_As_bool(obj3));
14848 if (SWIG_arg_fail(4)) SWIG_fail;
14849 }
14850 }
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14854
14855 wxPyEndAllowThreads(__tstate);
14856 if (PyErr_Occurred()) SWIG_fail;
14857 }
14858 {
14859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14860 }
14861 {
14862 if (temp2)
14863 delete arg2;
14864 }
14865 {
14866 if (temp3)
14867 delete arg3;
14868 }
14869 return resultobj;
14870 fail:
14871 {
14872 if (temp2)
14873 delete arg2;
14874 }
14875 {
14876 if (temp3)
14877 delete arg3;
14878 }
14879 return NULL;
14880 }
14881
14882
14883 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14884 PyObject *resultobj;
14885 wxFileType *arg1 = (wxFileType *) 0 ;
14886 wxString const &arg2_defvalue = wxPyEmptyString ;
14887 wxString *arg2 = (wxString *) &arg2_defvalue ;
14888 int arg3 = (int) 0 ;
14889 bool result;
14890 bool temp2 = false ;
14891 PyObject * obj0 = 0 ;
14892 PyObject * obj1 = 0 ;
14893 PyObject * obj2 = 0 ;
14894 char *kwnames[] = {
14895 (char *) "self",(char *) "cmd",(char *) "index", NULL
14896 };
14897
14898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14900 if (SWIG_arg_fail(1)) SWIG_fail;
14901 if (obj1) {
14902 {
14903 arg2 = wxString_in_helper(obj1);
14904 if (arg2 == NULL) SWIG_fail;
14905 temp2 = true;
14906 }
14907 }
14908 if (obj2) {
14909 {
14910 arg3 = (int)(SWIG_As_int(obj2));
14911 if (SWIG_arg_fail(3)) SWIG_fail;
14912 }
14913 }
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 {
14922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14923 }
14924 {
14925 if (temp2)
14926 delete arg2;
14927 }
14928 return resultobj;
14929 fail:
14930 {
14931 if (temp2)
14932 delete arg2;
14933 }
14934 return NULL;
14935 }
14936
14937
14938 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14939 PyObject *resultobj;
14940 wxFileType *arg1 = (wxFileType *) 0 ;
14941 bool result;
14942 PyObject * obj0 = 0 ;
14943 char *kwnames[] = {
14944 (char *) "self", NULL
14945 };
14946
14947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14949 if (SWIG_arg_fail(1)) SWIG_fail;
14950 {
14951 PyThreadState* __tstate = wxPyBeginAllowThreads();
14952 result = (bool)(arg1)->Unassociate();
14953
14954 wxPyEndAllowThreads(__tstate);
14955 if (PyErr_Occurred()) SWIG_fail;
14956 }
14957 {
14958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14959 }
14960 return resultobj;
14961 fail:
14962 return NULL;
14963 }
14964
14965
14966 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14967 PyObject *resultobj;
14968 wxString *arg1 = 0 ;
14969 wxString *arg2 = 0 ;
14970 wxString const &arg3_defvalue = wxPyEmptyString ;
14971 wxString *arg3 = (wxString *) &arg3_defvalue ;
14972 wxString result;
14973 bool temp1 = false ;
14974 bool temp2 = false ;
14975 bool temp3 = false ;
14976 PyObject * obj0 = 0 ;
14977 PyObject * obj1 = 0 ;
14978 PyObject * obj2 = 0 ;
14979 char *kwnames[] = {
14980 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14981 };
14982
14983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14984 {
14985 arg1 = wxString_in_helper(obj0);
14986 if (arg1 == NULL) SWIG_fail;
14987 temp1 = true;
14988 }
14989 {
14990 arg2 = wxString_in_helper(obj1);
14991 if (arg2 == NULL) SWIG_fail;
14992 temp2 = true;
14993 }
14994 if (obj2) {
14995 {
14996 arg3 = wxString_in_helper(obj2);
14997 if (arg3 == NULL) SWIG_fail;
14998 temp3 = true;
14999 }
15000 }
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15004
15005 wxPyEndAllowThreads(__tstate);
15006 if (PyErr_Occurred()) SWIG_fail;
15007 }
15008 {
15009 #if wxUSE_UNICODE
15010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15011 #else
15012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15013 #endif
15014 }
15015 {
15016 if (temp1)
15017 delete arg1;
15018 }
15019 {
15020 if (temp2)
15021 delete arg2;
15022 }
15023 {
15024 if (temp3)
15025 delete arg3;
15026 }
15027 return resultobj;
15028 fail:
15029 {
15030 if (temp1)
15031 delete arg1;
15032 }
15033 {
15034 if (temp2)
15035 delete arg2;
15036 }
15037 {
15038 if (temp3)
15039 delete arg3;
15040 }
15041 return NULL;
15042 }
15043
15044
15045 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15046 PyObject *obj;
15047 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15048 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15049 Py_INCREF(obj);
15050 return Py_BuildValue((char *)"");
15051 }
15052 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15053 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15054 return 1;
15055 }
15056
15057
15058 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15059 PyObject *pyobj;
15060
15061 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15062 return pyobj;
15063 }
15064
15065
15066 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15067 PyObject *resultobj;
15068 wxString *arg1 = 0 ;
15069 wxString *arg2 = 0 ;
15070 bool result;
15071 bool temp1 = false ;
15072 bool temp2 = false ;
15073 PyObject * obj0 = 0 ;
15074 PyObject * obj1 = 0 ;
15075 char *kwnames[] = {
15076 (char *) "mimeType",(char *) "wildcard", NULL
15077 };
15078
15079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15080 {
15081 arg1 = wxString_in_helper(obj0);
15082 if (arg1 == NULL) SWIG_fail;
15083 temp1 = true;
15084 }
15085 {
15086 arg2 = wxString_in_helper(obj1);
15087 if (arg2 == NULL) SWIG_fail;
15088 temp2 = true;
15089 }
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15093
15094 wxPyEndAllowThreads(__tstate);
15095 if (PyErr_Occurred()) SWIG_fail;
15096 }
15097 {
15098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15099 }
15100 {
15101 if (temp1)
15102 delete arg1;
15103 }
15104 {
15105 if (temp2)
15106 delete arg2;
15107 }
15108 return resultobj;
15109 fail:
15110 {
15111 if (temp1)
15112 delete arg1;
15113 }
15114 {
15115 if (temp2)
15116 delete arg2;
15117 }
15118 return NULL;
15119 }
15120
15121
15122 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15123 PyObject *resultobj;
15124 wxMimeTypesManager *result;
15125 char *kwnames[] = {
15126 NULL
15127 };
15128
15129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15130 {
15131 PyThreadState* __tstate = wxPyBeginAllowThreads();
15132 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15133
15134 wxPyEndAllowThreads(__tstate);
15135 if (PyErr_Occurred()) SWIG_fail;
15136 }
15137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj;
15146 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15147 int arg2 = (int) wxMAILCAP_ALL ;
15148 wxString const &arg3_defvalue = wxPyEmptyString ;
15149 wxString *arg3 = (wxString *) &arg3_defvalue ;
15150 bool temp3 = false ;
15151 PyObject * obj0 = 0 ;
15152 PyObject * obj1 = 0 ;
15153 PyObject * obj2 = 0 ;
15154 char *kwnames[] = {
15155 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15156 };
15157
15158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15160 if (SWIG_arg_fail(1)) SWIG_fail;
15161 if (obj1) {
15162 {
15163 arg2 = (int)(SWIG_As_int(obj1));
15164 if (SWIG_arg_fail(2)) SWIG_fail;
15165 }
15166 }
15167 if (obj2) {
15168 {
15169 arg3 = wxString_in_helper(obj2);
15170 if (arg3 == NULL) SWIG_fail;
15171 temp3 = true;
15172 }
15173 }
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15177
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 Py_INCREF(Py_None); resultobj = Py_None;
15182 {
15183 if (temp3)
15184 delete arg3;
15185 }
15186 return resultobj;
15187 fail:
15188 {
15189 if (temp3)
15190 delete arg3;
15191 }
15192 return NULL;
15193 }
15194
15195
15196 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15197 PyObject *resultobj;
15198 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15199 PyObject * obj0 = 0 ;
15200 char *kwnames[] = {
15201 (char *) "self", NULL
15202 };
15203
15204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15206 if (SWIG_arg_fail(1)) SWIG_fail;
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 (arg1)->ClearData();
15210
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 Py_INCREF(Py_None); resultobj = Py_None;
15215 return resultobj;
15216 fail:
15217 return NULL;
15218 }
15219
15220
15221 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15222 PyObject *resultobj;
15223 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15224 wxString *arg2 = 0 ;
15225 wxFileType *result;
15226 bool temp2 = false ;
15227 PyObject * obj0 = 0 ;
15228 PyObject * obj1 = 0 ;
15229 char *kwnames[] = {
15230 (char *) "self",(char *) "ext", NULL
15231 };
15232
15233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15235 if (SWIG_arg_fail(1)) SWIG_fail;
15236 {
15237 arg2 = wxString_in_helper(obj1);
15238 if (arg2 == NULL) SWIG_fail;
15239 temp2 = true;
15240 }
15241 {
15242 PyThreadState* __tstate = wxPyBeginAllowThreads();
15243 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15244
15245 wxPyEndAllowThreads(__tstate);
15246 if (PyErr_Occurred()) SWIG_fail;
15247 }
15248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15249 {
15250 if (temp2)
15251 delete arg2;
15252 }
15253 return resultobj;
15254 fail:
15255 {
15256 if (temp2)
15257 delete arg2;
15258 }
15259 return NULL;
15260 }
15261
15262
15263 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15264 PyObject *resultobj;
15265 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15266 wxString *arg2 = 0 ;
15267 wxFileType *result;
15268 bool temp2 = false ;
15269 PyObject * obj0 = 0 ;
15270 PyObject * obj1 = 0 ;
15271 char *kwnames[] = {
15272 (char *) "self",(char *) "mimeType", NULL
15273 };
15274
15275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15277 if (SWIG_arg_fail(1)) SWIG_fail;
15278 {
15279 arg2 = wxString_in_helper(obj1);
15280 if (arg2 == NULL) SWIG_fail;
15281 temp2 = true;
15282 }
15283 {
15284 PyThreadState* __tstate = wxPyBeginAllowThreads();
15285 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15286
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15291 {
15292 if (temp2)
15293 delete arg2;
15294 }
15295 return resultobj;
15296 fail:
15297 {
15298 if (temp2)
15299 delete arg2;
15300 }
15301 return NULL;
15302 }
15303
15304
15305 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15306 PyObject *resultobj;
15307 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15308 wxString *arg2 = 0 ;
15309 bool arg3 = (bool) false ;
15310 bool result;
15311 bool temp2 = false ;
15312 PyObject * obj0 = 0 ;
15313 PyObject * obj1 = 0 ;
15314 PyObject * obj2 = 0 ;
15315 char *kwnames[] = {
15316 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15317 };
15318
15319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15321 if (SWIG_arg_fail(1)) SWIG_fail;
15322 {
15323 arg2 = wxString_in_helper(obj1);
15324 if (arg2 == NULL) SWIG_fail;
15325 temp2 = true;
15326 }
15327 if (obj2) {
15328 {
15329 arg3 = (bool)(SWIG_As_bool(obj2));
15330 if (SWIG_arg_fail(3)) SWIG_fail;
15331 }
15332 }
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15336
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 {
15341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15342 }
15343 {
15344 if (temp2)
15345 delete arg2;
15346 }
15347 return resultobj;
15348 fail:
15349 {
15350 if (temp2)
15351 delete arg2;
15352 }
15353 return NULL;
15354 }
15355
15356
15357 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15358 PyObject *resultobj;
15359 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15360 wxString *arg2 = 0 ;
15361 bool result;
15362 bool temp2 = false ;
15363 PyObject * obj0 = 0 ;
15364 PyObject * obj1 = 0 ;
15365 char *kwnames[] = {
15366 (char *) "self",(char *) "filename", NULL
15367 };
15368
15369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15371 if (SWIG_arg_fail(1)) SWIG_fail;
15372 {
15373 arg2 = wxString_in_helper(obj1);
15374 if (arg2 == NULL) SWIG_fail;
15375 temp2 = true;
15376 }
15377 {
15378 PyThreadState* __tstate = wxPyBeginAllowThreads();
15379 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15380
15381 wxPyEndAllowThreads(__tstate);
15382 if (PyErr_Occurred()) SWIG_fail;
15383 }
15384 {
15385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15386 }
15387 {
15388 if (temp2)
15389 delete arg2;
15390 }
15391 return resultobj;
15392 fail:
15393 {
15394 if (temp2)
15395 delete arg2;
15396 }
15397 return NULL;
15398 }
15399
15400
15401 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15402 PyObject *resultobj;
15403 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15404 PyObject *result;
15405 PyObject * obj0 = 0 ;
15406 char *kwnames[] = {
15407 (char *) "self", NULL
15408 };
15409
15410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15412 if (SWIG_arg_fail(1)) SWIG_fail;
15413 {
15414 PyThreadState* __tstate = wxPyBeginAllowThreads();
15415 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15416
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 resultobj = result;
15421 return resultobj;
15422 fail:
15423 return NULL;
15424 }
15425
15426
15427 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15428 PyObject *resultobj;
15429 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15430 wxFileTypeInfo *arg2 = 0 ;
15431 PyObject * obj0 = 0 ;
15432 PyObject * obj1 = 0 ;
15433 char *kwnames[] = {
15434 (char *) "self",(char *) "ft", NULL
15435 };
15436
15437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15439 if (SWIG_arg_fail(1)) SWIG_fail;
15440 {
15441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15442 if (SWIG_arg_fail(2)) SWIG_fail;
15443 if (arg2 == NULL) {
15444 SWIG_null_ref("wxFileTypeInfo");
15445 }
15446 if (SWIG_arg_fail(2)) SWIG_fail;
15447 }
15448 {
15449 PyThreadState* __tstate = wxPyBeginAllowThreads();
15450 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15451
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 Py_INCREF(Py_None); resultobj = Py_None;
15456 return resultobj;
15457 fail:
15458 return NULL;
15459 }
15460
15461
15462 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15463 PyObject *resultobj;
15464 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15465 wxFileTypeInfo *arg2 = 0 ;
15466 wxFileType *result;
15467 PyObject * obj0 = 0 ;
15468 PyObject * obj1 = 0 ;
15469 char *kwnames[] = {
15470 (char *) "self",(char *) "ftInfo", NULL
15471 };
15472
15473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15475 if (SWIG_arg_fail(1)) SWIG_fail;
15476 {
15477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15478 if (SWIG_arg_fail(2)) SWIG_fail;
15479 if (arg2 == NULL) {
15480 SWIG_null_ref("wxFileTypeInfo");
15481 }
15482 if (SWIG_arg_fail(2)) SWIG_fail;
15483 }
15484 {
15485 PyThreadState* __tstate = wxPyBeginAllowThreads();
15486 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15487
15488 wxPyEndAllowThreads(__tstate);
15489 if (PyErr_Occurred()) SWIG_fail;
15490 }
15491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15499 PyObject *resultobj;
15500 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15501 wxFileType *arg2 = (wxFileType *) 0 ;
15502 bool result;
15503 PyObject * obj0 = 0 ;
15504 PyObject * obj1 = 0 ;
15505 char *kwnames[] = {
15506 (char *) "self",(char *) "ft", NULL
15507 };
15508
15509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15511 if (SWIG_arg_fail(1)) SWIG_fail;
15512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15513 if (SWIG_arg_fail(2)) SWIG_fail;
15514 {
15515 PyThreadState* __tstate = wxPyBeginAllowThreads();
15516 result = (bool)(arg1)->Unassociate(arg2);
15517
15518 wxPyEndAllowThreads(__tstate);
15519 if (PyErr_Occurred()) SWIG_fail;
15520 }
15521 {
15522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15523 }
15524 return resultobj;
15525 fail:
15526 return NULL;
15527 }
15528
15529
15530 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15531 PyObject *resultobj;
15532 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15533 PyObject * obj0 = 0 ;
15534 char *kwnames[] = {
15535 (char *) "self", NULL
15536 };
15537
15538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15540 if (SWIG_arg_fail(1)) SWIG_fail;
15541 {
15542 PyThreadState* __tstate = wxPyBeginAllowThreads();
15543 delete arg1;
15544
15545 wxPyEndAllowThreads(__tstate);
15546 if (PyErr_Occurred()) SWIG_fail;
15547 }
15548 Py_INCREF(Py_None); resultobj = Py_None;
15549 return resultobj;
15550 fail:
15551 return NULL;
15552 }
15553
15554
15555 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15556 PyObject *obj;
15557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15558 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15559 Py_INCREF(obj);
15560 return Py_BuildValue((char *)"");
15561 }
15562 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15563 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15564 return 1;
15565 }
15566
15567
15568 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15569 PyObject *pyobj;
15570
15571 {
15572 #if wxUSE_UNICODE
15573 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15574 #else
15575 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15576 #endif
15577 }
15578 return pyobj;
15579 }
15580
15581
15582 static int _wrap_ART_MENU_set(PyObject *) {
15583 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15584 return 1;
15585 }
15586
15587
15588 static PyObject *_wrap_ART_MENU_get(void) {
15589 PyObject *pyobj;
15590
15591 {
15592 #if wxUSE_UNICODE
15593 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15594 #else
15595 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15596 #endif
15597 }
15598 return pyobj;
15599 }
15600
15601
15602 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15603 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15604 return 1;
15605 }
15606
15607
15608 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15609 PyObject *pyobj;
15610
15611 {
15612 #if wxUSE_UNICODE
15613 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15614 #else
15615 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15616 #endif
15617 }
15618 return pyobj;
15619 }
15620
15621
15622 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15623 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15624 return 1;
15625 }
15626
15627
15628 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15629 PyObject *pyobj;
15630
15631 {
15632 #if wxUSE_UNICODE
15633 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15634 #else
15635 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15636 #endif
15637 }
15638 return pyobj;
15639 }
15640
15641
15642 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15643 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15644 return 1;
15645 }
15646
15647
15648 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15649 PyObject *pyobj;
15650
15651 {
15652 #if wxUSE_UNICODE
15653 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15654 #else
15655 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15656 #endif
15657 }
15658 return pyobj;
15659 }
15660
15661
15662 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15663 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15664 return 1;
15665 }
15666
15667
15668 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15669 PyObject *pyobj;
15670
15671 {
15672 #if wxUSE_UNICODE
15673 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15674 #else
15675 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15676 #endif
15677 }
15678 return pyobj;
15679 }
15680
15681
15682 static int _wrap_ART_BUTTON_set(PyObject *) {
15683 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15684 return 1;
15685 }
15686
15687
15688 static PyObject *_wrap_ART_BUTTON_get(void) {
15689 PyObject *pyobj;
15690
15691 {
15692 #if wxUSE_UNICODE
15693 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15694 #else
15695 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15696 #endif
15697 }
15698 return pyobj;
15699 }
15700
15701
15702 static int _wrap_ART_OTHER_set(PyObject *) {
15703 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15704 return 1;
15705 }
15706
15707
15708 static PyObject *_wrap_ART_OTHER_get(void) {
15709 PyObject *pyobj;
15710
15711 {
15712 #if wxUSE_UNICODE
15713 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15714 #else
15715 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15716 #endif
15717 }
15718 return pyobj;
15719 }
15720
15721
15722 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15723 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15724 return 1;
15725 }
15726
15727
15728 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15729 PyObject *pyobj;
15730
15731 {
15732 #if wxUSE_UNICODE
15733 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15734 #else
15735 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15736 #endif
15737 }
15738 return pyobj;
15739 }
15740
15741
15742 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15743 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15744 return 1;
15745 }
15746
15747
15748 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15749 PyObject *pyobj;
15750
15751 {
15752 #if wxUSE_UNICODE
15753 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15754 #else
15755 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15756 #endif
15757 }
15758 return pyobj;
15759 }
15760
15761
15762 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15763 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15764 return 1;
15765 }
15766
15767
15768 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15769 PyObject *pyobj;
15770
15771 {
15772 #if wxUSE_UNICODE
15773 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15774 #else
15775 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15776 #endif
15777 }
15778 return pyobj;
15779 }
15780
15781
15782 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15783 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15784 return 1;
15785 }
15786
15787
15788 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15789 PyObject *pyobj;
15790
15791 {
15792 #if wxUSE_UNICODE
15793 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15794 #else
15795 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15796 #endif
15797 }
15798 return pyobj;
15799 }
15800
15801
15802 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15803 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15804 return 1;
15805 }
15806
15807
15808 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15809 PyObject *pyobj;
15810
15811 {
15812 #if wxUSE_UNICODE
15813 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15814 #else
15815 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15816 #endif
15817 }
15818 return pyobj;
15819 }
15820
15821
15822 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15823 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15824 return 1;
15825 }
15826
15827
15828 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15829 PyObject *pyobj;
15830
15831 {
15832 #if wxUSE_UNICODE
15833 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15834 #else
15835 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15836 #endif
15837 }
15838 return pyobj;
15839 }
15840
15841
15842 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15843 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15844 return 1;
15845 }
15846
15847
15848 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15849 PyObject *pyobj;
15850
15851 {
15852 #if wxUSE_UNICODE
15853 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15854 #else
15855 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15856 #endif
15857 }
15858 return pyobj;
15859 }
15860
15861
15862 static int _wrap_ART_GO_BACK_set(PyObject *) {
15863 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15864 return 1;
15865 }
15866
15867
15868 static PyObject *_wrap_ART_GO_BACK_get(void) {
15869 PyObject *pyobj;
15870
15871 {
15872 #if wxUSE_UNICODE
15873 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15874 #else
15875 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15876 #endif
15877 }
15878 return pyobj;
15879 }
15880
15881
15882 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15883 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15884 return 1;
15885 }
15886
15887
15888 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15889 PyObject *pyobj;
15890
15891 {
15892 #if wxUSE_UNICODE
15893 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15894 #else
15895 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15896 #endif
15897 }
15898 return pyobj;
15899 }
15900
15901
15902 static int _wrap_ART_GO_UP_set(PyObject *) {
15903 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15904 return 1;
15905 }
15906
15907
15908 static PyObject *_wrap_ART_GO_UP_get(void) {
15909 PyObject *pyobj;
15910
15911 {
15912 #if wxUSE_UNICODE
15913 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15914 #else
15915 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15916 #endif
15917 }
15918 return pyobj;
15919 }
15920
15921
15922 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15923 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15924 return 1;
15925 }
15926
15927
15928 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15929 PyObject *pyobj;
15930
15931 {
15932 #if wxUSE_UNICODE
15933 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15934 #else
15935 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15936 #endif
15937 }
15938 return pyobj;
15939 }
15940
15941
15942 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15943 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15944 return 1;
15945 }
15946
15947
15948 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15949 PyObject *pyobj;
15950
15951 {
15952 #if wxUSE_UNICODE
15953 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15954 #else
15955 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15956 #endif
15957 }
15958 return pyobj;
15959 }
15960
15961
15962 static int _wrap_ART_GO_HOME_set(PyObject *) {
15963 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15964 return 1;
15965 }
15966
15967
15968 static PyObject *_wrap_ART_GO_HOME_get(void) {
15969 PyObject *pyobj;
15970
15971 {
15972 #if wxUSE_UNICODE
15973 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15974 #else
15975 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15976 #endif
15977 }
15978 return pyobj;
15979 }
15980
15981
15982 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15983 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15984 return 1;
15985 }
15986
15987
15988 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15989 PyObject *pyobj;
15990
15991 {
15992 #if wxUSE_UNICODE
15993 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15994 #else
15995 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15996 #endif
15997 }
15998 return pyobj;
15999 }
16000
16001
16002 static int _wrap_ART_PRINT_set(PyObject *) {
16003 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16004 return 1;
16005 }
16006
16007
16008 static PyObject *_wrap_ART_PRINT_get(void) {
16009 PyObject *pyobj;
16010
16011 {
16012 #if wxUSE_UNICODE
16013 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16014 #else
16015 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16016 #endif
16017 }
16018 return pyobj;
16019 }
16020
16021
16022 static int _wrap_ART_HELP_set(PyObject *) {
16023 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16024 return 1;
16025 }
16026
16027
16028 static PyObject *_wrap_ART_HELP_get(void) {
16029 PyObject *pyobj;
16030
16031 {
16032 #if wxUSE_UNICODE
16033 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16034 #else
16035 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16036 #endif
16037 }
16038 return pyobj;
16039 }
16040
16041
16042 static int _wrap_ART_TIP_set(PyObject *) {
16043 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16044 return 1;
16045 }
16046
16047
16048 static PyObject *_wrap_ART_TIP_get(void) {
16049 PyObject *pyobj;
16050
16051 {
16052 #if wxUSE_UNICODE
16053 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16054 #else
16055 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16056 #endif
16057 }
16058 return pyobj;
16059 }
16060
16061
16062 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16063 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16064 return 1;
16065 }
16066
16067
16068 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16069 PyObject *pyobj;
16070
16071 {
16072 #if wxUSE_UNICODE
16073 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16074 #else
16075 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16076 #endif
16077 }
16078 return pyobj;
16079 }
16080
16081
16082 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16083 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16084 return 1;
16085 }
16086
16087
16088 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16089 PyObject *pyobj;
16090
16091 {
16092 #if wxUSE_UNICODE
16093 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16094 #else
16095 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16096 #endif
16097 }
16098 return pyobj;
16099 }
16100
16101
16102 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16103 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16104 return 1;
16105 }
16106
16107
16108 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16109 PyObject *pyobj;
16110
16111 {
16112 #if wxUSE_UNICODE
16113 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16114 #else
16115 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16116 #endif
16117 }
16118 return pyobj;
16119 }
16120
16121
16122 static int _wrap_ART_HARDDISK_set(PyObject *) {
16123 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16124 return 1;
16125 }
16126
16127
16128 static PyObject *_wrap_ART_HARDDISK_get(void) {
16129 PyObject *pyobj;
16130
16131 {
16132 #if wxUSE_UNICODE
16133 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16134 #else
16135 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16136 #endif
16137 }
16138 return pyobj;
16139 }
16140
16141
16142 static int _wrap_ART_FLOPPY_set(PyObject *) {
16143 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16144 return 1;
16145 }
16146
16147
16148 static PyObject *_wrap_ART_FLOPPY_get(void) {
16149 PyObject *pyobj;
16150
16151 {
16152 #if wxUSE_UNICODE
16153 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16154 #else
16155 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16156 #endif
16157 }
16158 return pyobj;
16159 }
16160
16161
16162 static int _wrap_ART_CDROM_set(PyObject *) {
16163 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16164 return 1;
16165 }
16166
16167
16168 static PyObject *_wrap_ART_CDROM_get(void) {
16169 PyObject *pyobj;
16170
16171 {
16172 #if wxUSE_UNICODE
16173 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16174 #else
16175 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16176 #endif
16177 }
16178 return pyobj;
16179 }
16180
16181
16182 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16183 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16184 return 1;
16185 }
16186
16187
16188 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16189 PyObject *pyobj;
16190
16191 {
16192 #if wxUSE_UNICODE
16193 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16194 #else
16195 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16196 #endif
16197 }
16198 return pyobj;
16199 }
16200
16201
16202 static int _wrap_ART_FOLDER_set(PyObject *) {
16203 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16204 return 1;
16205 }
16206
16207
16208 static PyObject *_wrap_ART_FOLDER_get(void) {
16209 PyObject *pyobj;
16210
16211 {
16212 #if wxUSE_UNICODE
16213 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16214 #else
16215 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16216 #endif
16217 }
16218 return pyobj;
16219 }
16220
16221
16222 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16223 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16224 return 1;
16225 }
16226
16227
16228 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16229 PyObject *pyobj;
16230
16231 {
16232 #if wxUSE_UNICODE
16233 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16234 #else
16235 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16236 #endif
16237 }
16238 return pyobj;
16239 }
16240
16241
16242 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16243 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16244 return 1;
16245 }
16246
16247
16248 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16249 PyObject *pyobj;
16250
16251 {
16252 #if wxUSE_UNICODE
16253 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16254 #else
16255 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16256 #endif
16257 }
16258 return pyobj;
16259 }
16260
16261
16262 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16263 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16264 return 1;
16265 }
16266
16267
16268 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16269 PyObject *pyobj;
16270
16271 {
16272 #if wxUSE_UNICODE
16273 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16274 #else
16275 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16276 #endif
16277 }
16278 return pyobj;
16279 }
16280
16281
16282 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16283 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16284 return 1;
16285 }
16286
16287
16288 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16289 PyObject *pyobj;
16290
16291 {
16292 #if wxUSE_UNICODE
16293 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16294 #else
16295 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16296 #endif
16297 }
16298 return pyobj;
16299 }
16300
16301
16302 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16303 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16304 return 1;
16305 }
16306
16307
16308 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16309 PyObject *pyobj;
16310
16311 {
16312 #if wxUSE_UNICODE
16313 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16314 #else
16315 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16316 #endif
16317 }
16318 return pyobj;
16319 }
16320
16321
16322 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16323 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16324 return 1;
16325 }
16326
16327
16328 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16329 PyObject *pyobj;
16330
16331 {
16332 #if wxUSE_UNICODE
16333 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16334 #else
16335 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16336 #endif
16337 }
16338 return pyobj;
16339 }
16340
16341
16342 static int _wrap_ART_ERROR_set(PyObject *) {
16343 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16344 return 1;
16345 }
16346
16347
16348 static PyObject *_wrap_ART_ERROR_get(void) {
16349 PyObject *pyobj;
16350
16351 {
16352 #if wxUSE_UNICODE
16353 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16354 #else
16355 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16356 #endif
16357 }
16358 return pyobj;
16359 }
16360
16361
16362 static int _wrap_ART_QUESTION_set(PyObject *) {
16363 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16364 return 1;
16365 }
16366
16367
16368 static PyObject *_wrap_ART_QUESTION_get(void) {
16369 PyObject *pyobj;
16370
16371 {
16372 #if wxUSE_UNICODE
16373 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16374 #else
16375 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16376 #endif
16377 }
16378 return pyobj;
16379 }
16380
16381
16382 static int _wrap_ART_WARNING_set(PyObject *) {
16383 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16384 return 1;
16385 }
16386
16387
16388 static PyObject *_wrap_ART_WARNING_get(void) {
16389 PyObject *pyobj;
16390
16391 {
16392 #if wxUSE_UNICODE
16393 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16394 #else
16395 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16396 #endif
16397 }
16398 return pyobj;
16399 }
16400
16401
16402 static int _wrap_ART_INFORMATION_set(PyObject *) {
16403 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16404 return 1;
16405 }
16406
16407
16408 static PyObject *_wrap_ART_INFORMATION_get(void) {
16409 PyObject *pyobj;
16410
16411 {
16412 #if wxUSE_UNICODE
16413 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16414 #else
16415 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16416 #endif
16417 }
16418 return pyobj;
16419 }
16420
16421
16422 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16423 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16424 return 1;
16425 }
16426
16427
16428 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16429 PyObject *pyobj;
16430
16431 {
16432 #if wxUSE_UNICODE
16433 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16434 #else
16435 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16436 #endif
16437 }
16438 return pyobj;
16439 }
16440
16441
16442 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16443 PyObject *resultobj;
16444 wxPyArtProvider *result;
16445 char *kwnames[] = {
16446 NULL
16447 };
16448
16449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16450 {
16451 if (!wxPyCheckForApp()) SWIG_fail;
16452 PyThreadState* __tstate = wxPyBeginAllowThreads();
16453 result = (wxPyArtProvider *)new wxPyArtProvider();
16454
16455 wxPyEndAllowThreads(__tstate);
16456 if (PyErr_Occurred()) SWIG_fail;
16457 }
16458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16459 return resultobj;
16460 fail:
16461 return NULL;
16462 }
16463
16464
16465 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj;
16467 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16468 PyObject *arg2 = (PyObject *) 0 ;
16469 PyObject *arg3 = (PyObject *) 0 ;
16470 PyObject * obj0 = 0 ;
16471 PyObject * obj1 = 0 ;
16472 PyObject * obj2 = 0 ;
16473 char *kwnames[] = {
16474 (char *) "self",(char *) "self",(char *) "_class", NULL
16475 };
16476
16477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16479 if (SWIG_arg_fail(1)) SWIG_fail;
16480 arg2 = obj1;
16481 arg3 = obj2;
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 (arg1)->_setCallbackInfo(arg2,arg3);
16485
16486 wxPyEndAllowThreads(__tstate);
16487 if (PyErr_Occurred()) SWIG_fail;
16488 }
16489 Py_INCREF(Py_None); resultobj = Py_None;
16490 return resultobj;
16491 fail:
16492 return NULL;
16493 }
16494
16495
16496 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16497 PyObject *resultobj;
16498 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16499 PyObject * obj0 = 0 ;
16500 char *kwnames[] = {
16501 (char *) "provider", NULL
16502 };
16503
16504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16506 if (SWIG_arg_fail(1)) SWIG_fail;
16507 {
16508 PyThreadState* __tstate = wxPyBeginAllowThreads();
16509 wxPyArtProvider::PushProvider(arg1);
16510
16511 wxPyEndAllowThreads(__tstate);
16512 if (PyErr_Occurred()) SWIG_fail;
16513 }
16514 Py_INCREF(Py_None); resultobj = Py_None;
16515 return resultobj;
16516 fail:
16517 return NULL;
16518 }
16519
16520
16521 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16522 PyObject *resultobj;
16523 bool result;
16524 char *kwnames[] = {
16525 NULL
16526 };
16527
16528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16529 {
16530 PyThreadState* __tstate = wxPyBeginAllowThreads();
16531 result = (bool)wxPyArtProvider::PopProvider();
16532
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 {
16537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16538 }
16539 return resultobj;
16540 fail:
16541 return NULL;
16542 }
16543
16544
16545 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj;
16547 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16548 bool result;
16549 PyObject * obj0 = 0 ;
16550 char *kwnames[] = {
16551 (char *) "provider", NULL
16552 };
16553
16554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16556 if (SWIG_arg_fail(1)) SWIG_fail;
16557 {
16558 PyThreadState* __tstate = wxPyBeginAllowThreads();
16559 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16560
16561 wxPyEndAllowThreads(__tstate);
16562 if (PyErr_Occurred()) SWIG_fail;
16563 }
16564 {
16565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16566 }
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj;
16575 wxString *arg1 = 0 ;
16576 wxString const &arg2_defvalue = wxPyART_OTHER ;
16577 wxString *arg2 = (wxString *) &arg2_defvalue ;
16578 wxSize const &arg3_defvalue = wxDefaultSize ;
16579 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16580 wxBitmap result;
16581 bool temp1 = false ;
16582 bool temp2 = false ;
16583 wxSize temp3 ;
16584 PyObject * obj0 = 0 ;
16585 PyObject * obj1 = 0 ;
16586 PyObject * obj2 = 0 ;
16587 char *kwnames[] = {
16588 (char *) "id",(char *) "client",(char *) "size", NULL
16589 };
16590
16591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16592 {
16593 arg1 = wxString_in_helper(obj0);
16594 if (arg1 == NULL) SWIG_fail;
16595 temp1 = true;
16596 }
16597 if (obj1) {
16598 {
16599 arg2 = wxString_in_helper(obj1);
16600 if (arg2 == NULL) SWIG_fail;
16601 temp2 = true;
16602 }
16603 }
16604 if (obj2) {
16605 {
16606 arg3 = &temp3;
16607 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16608 }
16609 }
16610 {
16611 if (!wxPyCheckForApp()) SWIG_fail;
16612 PyThreadState* __tstate = wxPyBeginAllowThreads();
16613 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16614
16615 wxPyEndAllowThreads(__tstate);
16616 if (PyErr_Occurred()) SWIG_fail;
16617 }
16618 {
16619 wxBitmap * resultptr;
16620 resultptr = new wxBitmap((wxBitmap &)(result));
16621 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16622 }
16623 {
16624 if (temp1)
16625 delete arg1;
16626 }
16627 {
16628 if (temp2)
16629 delete arg2;
16630 }
16631 return resultobj;
16632 fail:
16633 {
16634 if (temp1)
16635 delete arg1;
16636 }
16637 {
16638 if (temp2)
16639 delete arg2;
16640 }
16641 return NULL;
16642 }
16643
16644
16645 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj;
16647 wxString *arg1 = 0 ;
16648 wxString const &arg2_defvalue = wxPyART_OTHER ;
16649 wxString *arg2 = (wxString *) &arg2_defvalue ;
16650 wxSize const &arg3_defvalue = wxDefaultSize ;
16651 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16652 wxIcon result;
16653 bool temp1 = false ;
16654 bool temp2 = false ;
16655 wxSize temp3 ;
16656 PyObject * obj0 = 0 ;
16657 PyObject * obj1 = 0 ;
16658 PyObject * obj2 = 0 ;
16659 char *kwnames[] = {
16660 (char *) "id",(char *) "client",(char *) "size", NULL
16661 };
16662
16663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16664 {
16665 arg1 = wxString_in_helper(obj0);
16666 if (arg1 == NULL) SWIG_fail;
16667 temp1 = true;
16668 }
16669 if (obj1) {
16670 {
16671 arg2 = wxString_in_helper(obj1);
16672 if (arg2 == NULL) SWIG_fail;
16673 temp2 = true;
16674 }
16675 }
16676 if (obj2) {
16677 {
16678 arg3 = &temp3;
16679 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16680 }
16681 }
16682 {
16683 if (!wxPyCheckForApp()) SWIG_fail;
16684 PyThreadState* __tstate = wxPyBeginAllowThreads();
16685 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16686
16687 wxPyEndAllowThreads(__tstate);
16688 if (PyErr_Occurred()) SWIG_fail;
16689 }
16690 {
16691 wxIcon * resultptr;
16692 resultptr = new wxIcon((wxIcon &)(result));
16693 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16694 }
16695 {
16696 if (temp1)
16697 delete arg1;
16698 }
16699 {
16700 if (temp2)
16701 delete arg2;
16702 }
16703 return resultobj;
16704 fail:
16705 {
16706 if (temp1)
16707 delete arg1;
16708 }
16709 {
16710 if (temp2)
16711 delete arg2;
16712 }
16713 return NULL;
16714 }
16715
16716
16717 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16718 PyObject *resultobj;
16719 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16720 PyObject * obj0 = 0 ;
16721 char *kwnames[] = {
16722 (char *) "self", NULL
16723 };
16724
16725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16727 if (SWIG_arg_fail(1)) SWIG_fail;
16728 {
16729 PyThreadState* __tstate = wxPyBeginAllowThreads();
16730 wxPyArtProvider_Destroy(arg1);
16731
16732 wxPyEndAllowThreads(__tstate);
16733 if (PyErr_Occurred()) SWIG_fail;
16734 }
16735 Py_INCREF(Py_None); resultobj = Py_None;
16736 return resultobj;
16737 fail:
16738 return NULL;
16739 }
16740
16741
16742 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16743 PyObject *obj;
16744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16745 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16746 Py_INCREF(obj);
16747 return Py_BuildValue((char *)"");
16748 }
16749 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj;
16751 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16752 PyObject * obj0 = 0 ;
16753 char *kwnames[] = {
16754 (char *) "self", NULL
16755 };
16756
16757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16759 if (SWIG_arg_fail(1)) SWIG_fail;
16760 {
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 delete arg1;
16763
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 Py_INCREF(Py_None); resultobj = Py_None;
16768 return resultobj;
16769 fail:
16770 return NULL;
16771 }
16772
16773
16774 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16775 PyObject *resultobj;
16776 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16777 wxConfigBase *result;
16778 PyObject * obj0 = 0 ;
16779 char *kwnames[] = {
16780 (char *) "config", NULL
16781 };
16782
16783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16785 if (SWIG_arg_fail(1)) SWIG_fail;
16786 {
16787 PyThreadState* __tstate = wxPyBeginAllowThreads();
16788 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16789
16790 wxPyEndAllowThreads(__tstate);
16791 if (PyErr_Occurred()) SWIG_fail;
16792 }
16793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16794 return resultobj;
16795 fail:
16796 return NULL;
16797 }
16798
16799
16800 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16801 PyObject *resultobj;
16802 bool arg1 = (bool) true ;
16803 wxConfigBase *result;
16804 PyObject * obj0 = 0 ;
16805 char *kwnames[] = {
16806 (char *) "createOnDemand", NULL
16807 };
16808
16809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16810 if (obj0) {
16811 {
16812 arg1 = (bool)(SWIG_As_bool(obj0));
16813 if (SWIG_arg_fail(1)) SWIG_fail;
16814 }
16815 }
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16819
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16824 return resultobj;
16825 fail:
16826 return NULL;
16827 }
16828
16829
16830 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16831 PyObject *resultobj;
16832 wxConfigBase *result;
16833 char *kwnames[] = {
16834 NULL
16835 };
16836
16837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 result = (wxConfigBase *)wxConfigBase::Create();
16841
16842 wxPyEndAllowThreads(__tstate);
16843 if (PyErr_Occurred()) SWIG_fail;
16844 }
16845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16846 return resultobj;
16847 fail:
16848 return NULL;
16849 }
16850
16851
16852 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16853 PyObject *resultobj;
16854 char *kwnames[] = {
16855 NULL
16856 };
16857
16858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16859 {
16860 PyThreadState* __tstate = wxPyBeginAllowThreads();
16861 wxConfigBase::DontCreateOnDemand();
16862
16863 wxPyEndAllowThreads(__tstate);
16864 if (PyErr_Occurred()) SWIG_fail;
16865 }
16866 Py_INCREF(Py_None); resultobj = Py_None;
16867 return resultobj;
16868 fail:
16869 return NULL;
16870 }
16871
16872
16873 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16874 PyObject *resultobj;
16875 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16876 wxString *arg2 = 0 ;
16877 bool temp2 = false ;
16878 PyObject * obj0 = 0 ;
16879 PyObject * obj1 = 0 ;
16880 char *kwnames[] = {
16881 (char *) "self",(char *) "path", NULL
16882 };
16883
16884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16886 if (SWIG_arg_fail(1)) SWIG_fail;
16887 {
16888 arg2 = wxString_in_helper(obj1);
16889 if (arg2 == NULL) SWIG_fail;
16890 temp2 = true;
16891 }
16892 {
16893 PyThreadState* __tstate = wxPyBeginAllowThreads();
16894 (arg1)->SetPath((wxString const &)*arg2);
16895
16896 wxPyEndAllowThreads(__tstate);
16897 if (PyErr_Occurred()) SWIG_fail;
16898 }
16899 Py_INCREF(Py_None); resultobj = Py_None;
16900 {
16901 if (temp2)
16902 delete arg2;
16903 }
16904 return resultobj;
16905 fail:
16906 {
16907 if (temp2)
16908 delete arg2;
16909 }
16910 return NULL;
16911 }
16912
16913
16914 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16915 PyObject *resultobj;
16916 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16917 wxString *result;
16918 PyObject * obj0 = 0 ;
16919 char *kwnames[] = {
16920 (char *) "self", NULL
16921 };
16922
16923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16925 if (SWIG_arg_fail(1)) SWIG_fail;
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 {
16929 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16930 result = (wxString *) &_result_ref;
16931 }
16932
16933 wxPyEndAllowThreads(__tstate);
16934 if (PyErr_Occurred()) SWIG_fail;
16935 }
16936 {
16937 #if wxUSE_UNICODE
16938 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16939 #else
16940 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16941 #endif
16942 }
16943 return resultobj;
16944 fail:
16945 return NULL;
16946 }
16947
16948
16949 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16950 PyObject *resultobj;
16951 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16952 PyObject *result;
16953 PyObject * obj0 = 0 ;
16954 char *kwnames[] = {
16955 (char *) "self", NULL
16956 };
16957
16958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16960 if (SWIG_arg_fail(1)) SWIG_fail;
16961 {
16962 PyThreadState* __tstate = wxPyBeginAllowThreads();
16963 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16964
16965 wxPyEndAllowThreads(__tstate);
16966 if (PyErr_Occurred()) SWIG_fail;
16967 }
16968 resultobj = result;
16969 return resultobj;
16970 fail:
16971 return NULL;
16972 }
16973
16974
16975 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16976 PyObject *resultobj;
16977 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16978 long arg2 ;
16979 PyObject *result;
16980 PyObject * obj0 = 0 ;
16981 PyObject * obj1 = 0 ;
16982 char *kwnames[] = {
16983 (char *) "self",(char *) "index", NULL
16984 };
16985
16986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16988 if (SWIG_arg_fail(1)) SWIG_fail;
16989 {
16990 arg2 = (long)(SWIG_As_long(obj1));
16991 if (SWIG_arg_fail(2)) SWIG_fail;
16992 }
16993 {
16994 PyThreadState* __tstate = wxPyBeginAllowThreads();
16995 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16996
16997 wxPyEndAllowThreads(__tstate);
16998 if (PyErr_Occurred()) SWIG_fail;
16999 }
17000 resultobj = result;
17001 return resultobj;
17002 fail:
17003 return NULL;
17004 }
17005
17006
17007 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17008 PyObject *resultobj;
17009 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17010 PyObject *result;
17011 PyObject * obj0 = 0 ;
17012 char *kwnames[] = {
17013 (char *) "self", NULL
17014 };
17015
17016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17018 if (SWIG_arg_fail(1)) SWIG_fail;
17019 {
17020 PyThreadState* __tstate = wxPyBeginAllowThreads();
17021 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17022
17023 wxPyEndAllowThreads(__tstate);
17024 if (PyErr_Occurred()) SWIG_fail;
17025 }
17026 resultobj = result;
17027 return resultobj;
17028 fail:
17029 return NULL;
17030 }
17031
17032
17033 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17034 PyObject *resultobj;
17035 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17036 long arg2 ;
17037 PyObject *result;
17038 PyObject * obj0 = 0 ;
17039 PyObject * obj1 = 0 ;
17040 char *kwnames[] = {
17041 (char *) "self",(char *) "index", NULL
17042 };
17043
17044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17046 if (SWIG_arg_fail(1)) SWIG_fail;
17047 {
17048 arg2 = (long)(SWIG_As_long(obj1));
17049 if (SWIG_arg_fail(2)) SWIG_fail;
17050 }
17051 {
17052 PyThreadState* __tstate = wxPyBeginAllowThreads();
17053 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17054
17055 wxPyEndAllowThreads(__tstate);
17056 if (PyErr_Occurred()) SWIG_fail;
17057 }
17058 resultobj = result;
17059 return resultobj;
17060 fail:
17061 return NULL;
17062 }
17063
17064
17065 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17066 PyObject *resultobj;
17067 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17068 bool arg2 = (bool) false ;
17069 size_t result;
17070 PyObject * obj0 = 0 ;
17071 PyObject * obj1 = 0 ;
17072 char *kwnames[] = {
17073 (char *) "self",(char *) "recursive", NULL
17074 };
17075
17076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17078 if (SWIG_arg_fail(1)) SWIG_fail;
17079 if (obj1) {
17080 {
17081 arg2 = (bool)(SWIG_As_bool(obj1));
17082 if (SWIG_arg_fail(2)) SWIG_fail;
17083 }
17084 }
17085 {
17086 PyThreadState* __tstate = wxPyBeginAllowThreads();
17087 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17088
17089 wxPyEndAllowThreads(__tstate);
17090 if (PyErr_Occurred()) SWIG_fail;
17091 }
17092 {
17093 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17094 }
17095 return resultobj;
17096 fail:
17097 return NULL;
17098 }
17099
17100
17101 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17102 PyObject *resultobj;
17103 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17104 bool arg2 = (bool) false ;
17105 size_t result;
17106 PyObject * obj0 = 0 ;
17107 PyObject * obj1 = 0 ;
17108 char *kwnames[] = {
17109 (char *) "self",(char *) "recursive", NULL
17110 };
17111
17112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17114 if (SWIG_arg_fail(1)) SWIG_fail;
17115 if (obj1) {
17116 {
17117 arg2 = (bool)(SWIG_As_bool(obj1));
17118 if (SWIG_arg_fail(2)) SWIG_fail;
17119 }
17120 }
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17124
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 {
17129 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17130 }
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17138 PyObject *resultobj;
17139 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17140 wxString *arg2 = 0 ;
17141 bool result;
17142 bool temp2 = false ;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 char *kwnames[] = {
17146 (char *) "self",(char *) "name", NULL
17147 };
17148
17149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17151 if (SWIG_arg_fail(1)) SWIG_fail;
17152 {
17153 arg2 = wxString_in_helper(obj1);
17154 if (arg2 == NULL) SWIG_fail;
17155 temp2 = true;
17156 }
17157 {
17158 PyThreadState* __tstate = wxPyBeginAllowThreads();
17159 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17160
17161 wxPyEndAllowThreads(__tstate);
17162 if (PyErr_Occurred()) SWIG_fail;
17163 }
17164 {
17165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17166 }
17167 {
17168 if (temp2)
17169 delete arg2;
17170 }
17171 return resultobj;
17172 fail:
17173 {
17174 if (temp2)
17175 delete arg2;
17176 }
17177 return NULL;
17178 }
17179
17180
17181 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj;
17183 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17184 wxString *arg2 = 0 ;
17185 bool result;
17186 bool temp2 = false ;
17187 PyObject * obj0 = 0 ;
17188 PyObject * obj1 = 0 ;
17189 char *kwnames[] = {
17190 (char *) "self",(char *) "name", NULL
17191 };
17192
17193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17195 if (SWIG_arg_fail(1)) SWIG_fail;
17196 {
17197 arg2 = wxString_in_helper(obj1);
17198 if (arg2 == NULL) SWIG_fail;
17199 temp2 = true;
17200 }
17201 {
17202 PyThreadState* __tstate = wxPyBeginAllowThreads();
17203 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17204
17205 wxPyEndAllowThreads(__tstate);
17206 if (PyErr_Occurred()) SWIG_fail;
17207 }
17208 {
17209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17210 }
17211 {
17212 if (temp2)
17213 delete arg2;
17214 }
17215 return resultobj;
17216 fail:
17217 {
17218 if (temp2)
17219 delete arg2;
17220 }
17221 return NULL;
17222 }
17223
17224
17225 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17226 PyObject *resultobj;
17227 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17228 wxString *arg2 = 0 ;
17229 bool result;
17230 bool temp2 = false ;
17231 PyObject * obj0 = 0 ;
17232 PyObject * obj1 = 0 ;
17233 char *kwnames[] = {
17234 (char *) "self",(char *) "name", NULL
17235 };
17236
17237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17239 if (SWIG_arg_fail(1)) SWIG_fail;
17240 {
17241 arg2 = wxString_in_helper(obj1);
17242 if (arg2 == NULL) SWIG_fail;
17243 temp2 = true;
17244 }
17245 {
17246 PyThreadState* __tstate = wxPyBeginAllowThreads();
17247 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17248
17249 wxPyEndAllowThreads(__tstate);
17250 if (PyErr_Occurred()) SWIG_fail;
17251 }
17252 {
17253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17254 }
17255 {
17256 if (temp2)
17257 delete arg2;
17258 }
17259 return resultobj;
17260 fail:
17261 {
17262 if (temp2)
17263 delete arg2;
17264 }
17265 return NULL;
17266 }
17267
17268
17269 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17270 PyObject *resultobj;
17271 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17272 wxString *arg2 = 0 ;
17273 wxConfigBase::EntryType result;
17274 bool temp2 = false ;
17275 PyObject * obj0 = 0 ;
17276 PyObject * obj1 = 0 ;
17277 char *kwnames[] = {
17278 (char *) "self",(char *) "name", NULL
17279 };
17280
17281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17283 if (SWIG_arg_fail(1)) SWIG_fail;
17284 {
17285 arg2 = wxString_in_helper(obj1);
17286 if (arg2 == NULL) SWIG_fail;
17287 temp2 = true;
17288 }
17289 {
17290 PyThreadState* __tstate = wxPyBeginAllowThreads();
17291 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17292
17293 wxPyEndAllowThreads(__tstate);
17294 if (PyErr_Occurred()) SWIG_fail;
17295 }
17296 resultobj = SWIG_From_int((result));
17297 {
17298 if (temp2)
17299 delete arg2;
17300 }
17301 return resultobj;
17302 fail:
17303 {
17304 if (temp2)
17305 delete arg2;
17306 }
17307 return NULL;
17308 }
17309
17310
17311 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17312 PyObject *resultobj;
17313 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17314 wxString *arg2 = 0 ;
17315 wxString const &arg3_defvalue = wxPyEmptyString ;
17316 wxString *arg3 = (wxString *) &arg3_defvalue ;
17317 wxString result;
17318 bool temp2 = false ;
17319 bool temp3 = false ;
17320 PyObject * obj0 = 0 ;
17321 PyObject * obj1 = 0 ;
17322 PyObject * obj2 = 0 ;
17323 char *kwnames[] = {
17324 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17325 };
17326
17327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17329 if (SWIG_arg_fail(1)) SWIG_fail;
17330 {
17331 arg2 = wxString_in_helper(obj1);
17332 if (arg2 == NULL) SWIG_fail;
17333 temp2 = true;
17334 }
17335 if (obj2) {
17336 {
17337 arg3 = wxString_in_helper(obj2);
17338 if (arg3 == NULL) SWIG_fail;
17339 temp3 = true;
17340 }
17341 }
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17345
17346 wxPyEndAllowThreads(__tstate);
17347 if (PyErr_Occurred()) SWIG_fail;
17348 }
17349 {
17350 #if wxUSE_UNICODE
17351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17352 #else
17353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17354 #endif
17355 }
17356 {
17357 if (temp2)
17358 delete arg2;
17359 }
17360 {
17361 if (temp3)
17362 delete arg3;
17363 }
17364 return resultobj;
17365 fail:
17366 {
17367 if (temp2)
17368 delete arg2;
17369 }
17370 {
17371 if (temp3)
17372 delete arg3;
17373 }
17374 return NULL;
17375 }
17376
17377
17378 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17379 PyObject *resultobj;
17380 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17381 wxString *arg2 = 0 ;
17382 long arg3 = (long) 0 ;
17383 long result;
17384 bool temp2 = false ;
17385 PyObject * obj0 = 0 ;
17386 PyObject * obj1 = 0 ;
17387 PyObject * obj2 = 0 ;
17388 char *kwnames[] = {
17389 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17390 };
17391
17392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17394 if (SWIG_arg_fail(1)) SWIG_fail;
17395 {
17396 arg2 = wxString_in_helper(obj1);
17397 if (arg2 == NULL) SWIG_fail;
17398 temp2 = true;
17399 }
17400 if (obj2) {
17401 {
17402 arg3 = (long)(SWIG_As_long(obj2));
17403 if (SWIG_arg_fail(3)) SWIG_fail;
17404 }
17405 }
17406 {
17407 PyThreadState* __tstate = wxPyBeginAllowThreads();
17408 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17409
17410 wxPyEndAllowThreads(__tstate);
17411 if (PyErr_Occurred()) SWIG_fail;
17412 }
17413 {
17414 resultobj = SWIG_From_long((long)(result));
17415 }
17416 {
17417 if (temp2)
17418 delete arg2;
17419 }
17420 return resultobj;
17421 fail:
17422 {
17423 if (temp2)
17424 delete arg2;
17425 }
17426 return NULL;
17427 }
17428
17429
17430 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17431 PyObject *resultobj;
17432 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17433 wxString *arg2 = 0 ;
17434 double arg3 = (double) 0.0 ;
17435 double result;
17436 bool temp2 = false ;
17437 PyObject * obj0 = 0 ;
17438 PyObject * obj1 = 0 ;
17439 PyObject * obj2 = 0 ;
17440 char *kwnames[] = {
17441 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17442 };
17443
17444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17446 if (SWIG_arg_fail(1)) SWIG_fail;
17447 {
17448 arg2 = wxString_in_helper(obj1);
17449 if (arg2 == NULL) SWIG_fail;
17450 temp2 = true;
17451 }
17452 if (obj2) {
17453 {
17454 arg3 = (double)(SWIG_As_double(obj2));
17455 if (SWIG_arg_fail(3)) SWIG_fail;
17456 }
17457 }
17458 {
17459 PyThreadState* __tstate = wxPyBeginAllowThreads();
17460 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17461
17462 wxPyEndAllowThreads(__tstate);
17463 if (PyErr_Occurred()) SWIG_fail;
17464 }
17465 {
17466 resultobj = SWIG_From_double((double)(result));
17467 }
17468 {
17469 if (temp2)
17470 delete arg2;
17471 }
17472 return resultobj;
17473 fail:
17474 {
17475 if (temp2)
17476 delete arg2;
17477 }
17478 return NULL;
17479 }
17480
17481
17482 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj;
17484 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17485 wxString *arg2 = 0 ;
17486 bool arg3 = (bool) false ;
17487 bool result;
17488 bool temp2 = false ;
17489 PyObject * obj0 = 0 ;
17490 PyObject * obj1 = 0 ;
17491 PyObject * obj2 = 0 ;
17492 char *kwnames[] = {
17493 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17494 };
17495
17496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17498 if (SWIG_arg_fail(1)) SWIG_fail;
17499 {
17500 arg2 = wxString_in_helper(obj1);
17501 if (arg2 == NULL) SWIG_fail;
17502 temp2 = true;
17503 }
17504 if (obj2) {
17505 {
17506 arg3 = (bool)(SWIG_As_bool(obj2));
17507 if (SWIG_arg_fail(3)) SWIG_fail;
17508 }
17509 }
17510 {
17511 PyThreadState* __tstate = wxPyBeginAllowThreads();
17512 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17513
17514 wxPyEndAllowThreads(__tstate);
17515 if (PyErr_Occurred()) SWIG_fail;
17516 }
17517 {
17518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17519 }
17520 {
17521 if (temp2)
17522 delete arg2;
17523 }
17524 return resultobj;
17525 fail:
17526 {
17527 if (temp2)
17528 delete arg2;
17529 }
17530 return NULL;
17531 }
17532
17533
17534 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17535 PyObject *resultobj;
17536 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17537 wxString *arg2 = 0 ;
17538 wxString *arg3 = 0 ;
17539 bool result;
17540 bool temp2 = false ;
17541 bool temp3 = false ;
17542 PyObject * obj0 = 0 ;
17543 PyObject * obj1 = 0 ;
17544 PyObject * obj2 = 0 ;
17545 char *kwnames[] = {
17546 (char *) "self",(char *) "key",(char *) "value", NULL
17547 };
17548
17549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17551 if (SWIG_arg_fail(1)) SWIG_fail;
17552 {
17553 arg2 = wxString_in_helper(obj1);
17554 if (arg2 == NULL) SWIG_fail;
17555 temp2 = true;
17556 }
17557 {
17558 arg3 = wxString_in_helper(obj2);
17559 if (arg3 == NULL) SWIG_fail;
17560 temp3 = true;
17561 }
17562 {
17563 PyThreadState* __tstate = wxPyBeginAllowThreads();
17564 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17565
17566 wxPyEndAllowThreads(__tstate);
17567 if (PyErr_Occurred()) SWIG_fail;
17568 }
17569 {
17570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17571 }
17572 {
17573 if (temp2)
17574 delete arg2;
17575 }
17576 {
17577 if (temp3)
17578 delete arg3;
17579 }
17580 return resultobj;
17581 fail:
17582 {
17583 if (temp2)
17584 delete arg2;
17585 }
17586 {
17587 if (temp3)
17588 delete arg3;
17589 }
17590 return NULL;
17591 }
17592
17593
17594 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17595 PyObject *resultobj;
17596 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17597 wxString *arg2 = 0 ;
17598 long arg3 ;
17599 bool result;
17600 bool temp2 = false ;
17601 PyObject * obj0 = 0 ;
17602 PyObject * obj1 = 0 ;
17603 PyObject * obj2 = 0 ;
17604 char *kwnames[] = {
17605 (char *) "self",(char *) "key",(char *) "value", NULL
17606 };
17607
17608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17610 if (SWIG_arg_fail(1)) SWIG_fail;
17611 {
17612 arg2 = wxString_in_helper(obj1);
17613 if (arg2 == NULL) SWIG_fail;
17614 temp2 = true;
17615 }
17616 {
17617 arg3 = (long)(SWIG_As_long(obj2));
17618 if (SWIG_arg_fail(3)) SWIG_fail;
17619 }
17620 {
17621 PyThreadState* __tstate = wxPyBeginAllowThreads();
17622 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17623
17624 wxPyEndAllowThreads(__tstate);
17625 if (PyErr_Occurred()) SWIG_fail;
17626 }
17627 {
17628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17629 }
17630 {
17631 if (temp2)
17632 delete arg2;
17633 }
17634 return resultobj;
17635 fail:
17636 {
17637 if (temp2)
17638 delete arg2;
17639 }
17640 return NULL;
17641 }
17642
17643
17644 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17645 PyObject *resultobj;
17646 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17647 wxString *arg2 = 0 ;
17648 double arg3 ;
17649 bool result;
17650 bool temp2 = false ;
17651 PyObject * obj0 = 0 ;
17652 PyObject * obj1 = 0 ;
17653 PyObject * obj2 = 0 ;
17654 char *kwnames[] = {
17655 (char *) "self",(char *) "key",(char *) "value", NULL
17656 };
17657
17658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17660 if (SWIG_arg_fail(1)) SWIG_fail;
17661 {
17662 arg2 = wxString_in_helper(obj1);
17663 if (arg2 == NULL) SWIG_fail;
17664 temp2 = true;
17665 }
17666 {
17667 arg3 = (double)(SWIG_As_double(obj2));
17668 if (SWIG_arg_fail(3)) SWIG_fail;
17669 }
17670 {
17671 PyThreadState* __tstate = wxPyBeginAllowThreads();
17672 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17673
17674 wxPyEndAllowThreads(__tstate);
17675 if (PyErr_Occurred()) SWIG_fail;
17676 }
17677 {
17678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17679 }
17680 {
17681 if (temp2)
17682 delete arg2;
17683 }
17684 return resultobj;
17685 fail:
17686 {
17687 if (temp2)
17688 delete arg2;
17689 }
17690 return NULL;
17691 }
17692
17693
17694 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17695 PyObject *resultobj;
17696 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17697 wxString *arg2 = 0 ;
17698 bool arg3 ;
17699 bool result;
17700 bool temp2 = false ;
17701 PyObject * obj0 = 0 ;
17702 PyObject * obj1 = 0 ;
17703 PyObject * obj2 = 0 ;
17704 char *kwnames[] = {
17705 (char *) "self",(char *) "key",(char *) "value", NULL
17706 };
17707
17708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17710 if (SWIG_arg_fail(1)) SWIG_fail;
17711 {
17712 arg2 = wxString_in_helper(obj1);
17713 if (arg2 == NULL) SWIG_fail;
17714 temp2 = true;
17715 }
17716 {
17717 arg3 = (bool)(SWIG_As_bool(obj2));
17718 if (SWIG_arg_fail(3)) SWIG_fail;
17719 }
17720 {
17721 PyThreadState* __tstate = wxPyBeginAllowThreads();
17722 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17723
17724 wxPyEndAllowThreads(__tstate);
17725 if (PyErr_Occurred()) SWIG_fail;
17726 }
17727 {
17728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17729 }
17730 {
17731 if (temp2)
17732 delete arg2;
17733 }
17734 return resultobj;
17735 fail:
17736 {
17737 if (temp2)
17738 delete arg2;
17739 }
17740 return NULL;
17741 }
17742
17743
17744 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17745 PyObject *resultobj;
17746 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17747 bool arg2 = (bool) false ;
17748 bool result;
17749 PyObject * obj0 = 0 ;
17750 PyObject * obj1 = 0 ;
17751 char *kwnames[] = {
17752 (char *) "self",(char *) "currentOnly", NULL
17753 };
17754
17755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17757 if (SWIG_arg_fail(1)) SWIG_fail;
17758 if (obj1) {
17759 {
17760 arg2 = (bool)(SWIG_As_bool(obj1));
17761 if (SWIG_arg_fail(2)) SWIG_fail;
17762 }
17763 }
17764 {
17765 PyThreadState* __tstate = wxPyBeginAllowThreads();
17766 result = (bool)(arg1)->Flush(arg2);
17767
17768 wxPyEndAllowThreads(__tstate);
17769 if (PyErr_Occurred()) SWIG_fail;
17770 }
17771 {
17772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17773 }
17774 return resultobj;
17775 fail:
17776 return NULL;
17777 }
17778
17779
17780 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17781 PyObject *resultobj;
17782 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17783 wxString *arg2 = 0 ;
17784 wxString *arg3 = 0 ;
17785 bool result;
17786 bool temp2 = false ;
17787 bool temp3 = false ;
17788 PyObject * obj0 = 0 ;
17789 PyObject * obj1 = 0 ;
17790 PyObject * obj2 = 0 ;
17791 char *kwnames[] = {
17792 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17793 };
17794
17795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17797 if (SWIG_arg_fail(1)) SWIG_fail;
17798 {
17799 arg2 = wxString_in_helper(obj1);
17800 if (arg2 == NULL) SWIG_fail;
17801 temp2 = true;
17802 }
17803 {
17804 arg3 = wxString_in_helper(obj2);
17805 if (arg3 == NULL) SWIG_fail;
17806 temp3 = true;
17807 }
17808 {
17809 PyThreadState* __tstate = wxPyBeginAllowThreads();
17810 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17811
17812 wxPyEndAllowThreads(__tstate);
17813 if (PyErr_Occurred()) SWIG_fail;
17814 }
17815 {
17816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17817 }
17818 {
17819 if (temp2)
17820 delete arg2;
17821 }
17822 {
17823 if (temp3)
17824 delete arg3;
17825 }
17826 return resultobj;
17827 fail:
17828 {
17829 if (temp2)
17830 delete arg2;
17831 }
17832 {
17833 if (temp3)
17834 delete arg3;
17835 }
17836 return NULL;
17837 }
17838
17839
17840 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17841 PyObject *resultobj;
17842 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17843 wxString *arg2 = 0 ;
17844 wxString *arg3 = 0 ;
17845 bool result;
17846 bool temp2 = false ;
17847 bool temp3 = false ;
17848 PyObject * obj0 = 0 ;
17849 PyObject * obj1 = 0 ;
17850 PyObject * obj2 = 0 ;
17851 char *kwnames[] = {
17852 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17853 };
17854
17855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17857 if (SWIG_arg_fail(1)) SWIG_fail;
17858 {
17859 arg2 = wxString_in_helper(obj1);
17860 if (arg2 == NULL) SWIG_fail;
17861 temp2 = true;
17862 }
17863 {
17864 arg3 = wxString_in_helper(obj2);
17865 if (arg3 == NULL) SWIG_fail;
17866 temp3 = true;
17867 }
17868 {
17869 PyThreadState* __tstate = wxPyBeginAllowThreads();
17870 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17871
17872 wxPyEndAllowThreads(__tstate);
17873 if (PyErr_Occurred()) SWIG_fail;
17874 }
17875 {
17876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17877 }
17878 {
17879 if (temp2)
17880 delete arg2;
17881 }
17882 {
17883 if (temp3)
17884 delete arg3;
17885 }
17886 return resultobj;
17887 fail:
17888 {
17889 if (temp2)
17890 delete arg2;
17891 }
17892 {
17893 if (temp3)
17894 delete arg3;
17895 }
17896 return NULL;
17897 }
17898
17899
17900 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17901 PyObject *resultobj;
17902 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17903 wxString *arg2 = 0 ;
17904 bool arg3 = (bool) true ;
17905 bool result;
17906 bool temp2 = false ;
17907 PyObject * obj0 = 0 ;
17908 PyObject * obj1 = 0 ;
17909 PyObject * obj2 = 0 ;
17910 char *kwnames[] = {
17911 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17912 };
17913
17914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17916 if (SWIG_arg_fail(1)) SWIG_fail;
17917 {
17918 arg2 = wxString_in_helper(obj1);
17919 if (arg2 == NULL) SWIG_fail;
17920 temp2 = true;
17921 }
17922 if (obj2) {
17923 {
17924 arg3 = (bool)(SWIG_As_bool(obj2));
17925 if (SWIG_arg_fail(3)) SWIG_fail;
17926 }
17927 }
17928 {
17929 PyThreadState* __tstate = wxPyBeginAllowThreads();
17930 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17931
17932 wxPyEndAllowThreads(__tstate);
17933 if (PyErr_Occurred()) SWIG_fail;
17934 }
17935 {
17936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17937 }
17938 {
17939 if (temp2)
17940 delete arg2;
17941 }
17942 return resultobj;
17943 fail:
17944 {
17945 if (temp2)
17946 delete arg2;
17947 }
17948 return NULL;
17949 }
17950
17951
17952 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17953 PyObject *resultobj;
17954 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17955 wxString *arg2 = 0 ;
17956 bool result;
17957 bool temp2 = false ;
17958 PyObject * obj0 = 0 ;
17959 PyObject * obj1 = 0 ;
17960 char *kwnames[] = {
17961 (char *) "self",(char *) "key", NULL
17962 };
17963
17964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17966 if (SWIG_arg_fail(1)) SWIG_fail;
17967 {
17968 arg2 = wxString_in_helper(obj1);
17969 if (arg2 == NULL) SWIG_fail;
17970 temp2 = true;
17971 }
17972 {
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17975
17976 wxPyEndAllowThreads(__tstate);
17977 if (PyErr_Occurred()) SWIG_fail;
17978 }
17979 {
17980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17981 }
17982 {
17983 if (temp2)
17984 delete arg2;
17985 }
17986 return resultobj;
17987 fail:
17988 {
17989 if (temp2)
17990 delete arg2;
17991 }
17992 return NULL;
17993 }
17994
17995
17996 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17997 PyObject *resultobj;
17998 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17999 bool result;
18000 PyObject * obj0 = 0 ;
18001 char *kwnames[] = {
18002 (char *) "self", NULL
18003 };
18004
18005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18007 if (SWIG_arg_fail(1)) SWIG_fail;
18008 {
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 result = (bool)(arg1)->DeleteAll();
18011
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 {
18016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18017 }
18018 return resultobj;
18019 fail:
18020 return NULL;
18021 }
18022
18023
18024 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18025 PyObject *resultobj;
18026 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18027 bool arg2 = (bool) true ;
18028 PyObject * obj0 = 0 ;
18029 PyObject * obj1 = 0 ;
18030 char *kwnames[] = {
18031 (char *) "self",(char *) "doIt", NULL
18032 };
18033
18034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18036 if (SWIG_arg_fail(1)) SWIG_fail;
18037 if (obj1) {
18038 {
18039 arg2 = (bool)(SWIG_As_bool(obj1));
18040 if (SWIG_arg_fail(2)) SWIG_fail;
18041 }
18042 }
18043 {
18044 PyThreadState* __tstate = wxPyBeginAllowThreads();
18045 (arg1)->SetExpandEnvVars(arg2);
18046
18047 wxPyEndAllowThreads(__tstate);
18048 if (PyErr_Occurred()) SWIG_fail;
18049 }
18050 Py_INCREF(Py_None); resultobj = Py_None;
18051 return resultobj;
18052 fail:
18053 return NULL;
18054 }
18055
18056
18057 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18058 PyObject *resultobj;
18059 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18060 bool result;
18061 PyObject * obj0 = 0 ;
18062 char *kwnames[] = {
18063 (char *) "self", NULL
18064 };
18065
18066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18068 if (SWIG_arg_fail(1)) SWIG_fail;
18069 {
18070 PyThreadState* __tstate = wxPyBeginAllowThreads();
18071 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18072
18073 wxPyEndAllowThreads(__tstate);
18074 if (PyErr_Occurred()) SWIG_fail;
18075 }
18076 {
18077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18078 }
18079 return resultobj;
18080 fail:
18081 return NULL;
18082 }
18083
18084
18085 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18086 PyObject *resultobj;
18087 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18088 bool arg2 = (bool) true ;
18089 PyObject * obj0 = 0 ;
18090 PyObject * obj1 = 0 ;
18091 char *kwnames[] = {
18092 (char *) "self",(char *) "doIt", NULL
18093 };
18094
18095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18097 if (SWIG_arg_fail(1)) SWIG_fail;
18098 if (obj1) {
18099 {
18100 arg2 = (bool)(SWIG_As_bool(obj1));
18101 if (SWIG_arg_fail(2)) SWIG_fail;
18102 }
18103 }
18104 {
18105 PyThreadState* __tstate = wxPyBeginAllowThreads();
18106 (arg1)->SetRecordDefaults(arg2);
18107
18108 wxPyEndAllowThreads(__tstate);
18109 if (PyErr_Occurred()) SWIG_fail;
18110 }
18111 Py_INCREF(Py_None); resultobj = Py_None;
18112 return resultobj;
18113 fail:
18114 return NULL;
18115 }
18116
18117
18118 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18119 PyObject *resultobj;
18120 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18121 bool result;
18122 PyObject * obj0 = 0 ;
18123 char *kwnames[] = {
18124 (char *) "self", NULL
18125 };
18126
18127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18129 if (SWIG_arg_fail(1)) SWIG_fail;
18130 {
18131 PyThreadState* __tstate = wxPyBeginAllowThreads();
18132 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18133
18134 wxPyEndAllowThreads(__tstate);
18135 if (PyErr_Occurred()) SWIG_fail;
18136 }
18137 {
18138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18139 }
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18147 PyObject *resultobj;
18148 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18149 wxString *arg2 = 0 ;
18150 wxString result;
18151 bool temp2 = false ;
18152 PyObject * obj0 = 0 ;
18153 PyObject * obj1 = 0 ;
18154 char *kwnames[] = {
18155 (char *) "self",(char *) "str", NULL
18156 };
18157
18158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18160 if (SWIG_arg_fail(1)) SWIG_fail;
18161 {
18162 arg2 = wxString_in_helper(obj1);
18163 if (arg2 == NULL) SWIG_fail;
18164 temp2 = true;
18165 }
18166 {
18167 PyThreadState* __tstate = wxPyBeginAllowThreads();
18168 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18169
18170 wxPyEndAllowThreads(__tstate);
18171 if (PyErr_Occurred()) SWIG_fail;
18172 }
18173 {
18174 #if wxUSE_UNICODE
18175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18176 #else
18177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18178 #endif
18179 }
18180 {
18181 if (temp2)
18182 delete arg2;
18183 }
18184 return resultobj;
18185 fail:
18186 {
18187 if (temp2)
18188 delete arg2;
18189 }
18190 return NULL;
18191 }
18192
18193
18194 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18195 PyObject *resultobj;
18196 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18197 wxString result;
18198 PyObject * obj0 = 0 ;
18199 char *kwnames[] = {
18200 (char *) "self", NULL
18201 };
18202
18203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18205 if (SWIG_arg_fail(1)) SWIG_fail;
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 result = ((wxConfigBase const *)arg1)->GetAppName();
18209
18210 wxPyEndAllowThreads(__tstate);
18211 if (PyErr_Occurred()) SWIG_fail;
18212 }
18213 {
18214 #if wxUSE_UNICODE
18215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18216 #else
18217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18218 #endif
18219 }
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18227 PyObject *resultobj;
18228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18229 wxString result;
18230 PyObject * obj0 = 0 ;
18231 char *kwnames[] = {
18232 (char *) "self", NULL
18233 };
18234
18235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18237 if (SWIG_arg_fail(1)) SWIG_fail;
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 result = ((wxConfigBase const *)arg1)->GetVendorName();
18241
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 {
18246 #if wxUSE_UNICODE
18247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18248 #else
18249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18250 #endif
18251 }
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj;
18260 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18261 wxString *arg2 = 0 ;
18262 bool temp2 = false ;
18263 PyObject * obj0 = 0 ;
18264 PyObject * obj1 = 0 ;
18265 char *kwnames[] = {
18266 (char *) "self",(char *) "appName", NULL
18267 };
18268
18269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18271 if (SWIG_arg_fail(1)) SWIG_fail;
18272 {
18273 arg2 = wxString_in_helper(obj1);
18274 if (arg2 == NULL) SWIG_fail;
18275 temp2 = true;
18276 }
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 (arg1)->SetAppName((wxString const &)*arg2);
18280
18281 wxPyEndAllowThreads(__tstate);
18282 if (PyErr_Occurred()) SWIG_fail;
18283 }
18284 Py_INCREF(Py_None); resultobj = Py_None;
18285 {
18286 if (temp2)
18287 delete arg2;
18288 }
18289 return resultobj;
18290 fail:
18291 {
18292 if (temp2)
18293 delete arg2;
18294 }
18295 return NULL;
18296 }
18297
18298
18299 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18300 PyObject *resultobj;
18301 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18302 wxString *arg2 = 0 ;
18303 bool temp2 = false ;
18304 PyObject * obj0 = 0 ;
18305 PyObject * obj1 = 0 ;
18306 char *kwnames[] = {
18307 (char *) "self",(char *) "vendorName", NULL
18308 };
18309
18310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18312 if (SWIG_arg_fail(1)) SWIG_fail;
18313 {
18314 arg2 = wxString_in_helper(obj1);
18315 if (arg2 == NULL) SWIG_fail;
18316 temp2 = true;
18317 }
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 (arg1)->SetVendorName((wxString const &)*arg2);
18321
18322 wxPyEndAllowThreads(__tstate);
18323 if (PyErr_Occurred()) SWIG_fail;
18324 }
18325 Py_INCREF(Py_None); resultobj = Py_None;
18326 {
18327 if (temp2)
18328 delete arg2;
18329 }
18330 return resultobj;
18331 fail:
18332 {
18333 if (temp2)
18334 delete arg2;
18335 }
18336 return NULL;
18337 }
18338
18339
18340 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18341 PyObject *resultobj;
18342 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18343 long arg2 ;
18344 PyObject * obj0 = 0 ;
18345 PyObject * obj1 = 0 ;
18346 char *kwnames[] = {
18347 (char *) "self",(char *) "style", NULL
18348 };
18349
18350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18352 if (SWIG_arg_fail(1)) SWIG_fail;
18353 {
18354 arg2 = (long)(SWIG_As_long(obj1));
18355 if (SWIG_arg_fail(2)) SWIG_fail;
18356 }
18357 {
18358 PyThreadState* __tstate = wxPyBeginAllowThreads();
18359 (arg1)->SetStyle(arg2);
18360
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 Py_INCREF(Py_None); resultobj = Py_None;
18365 return resultobj;
18366 fail:
18367 return NULL;
18368 }
18369
18370
18371 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18372 PyObject *resultobj;
18373 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18374 long result;
18375 PyObject * obj0 = 0 ;
18376 char *kwnames[] = {
18377 (char *) "self", NULL
18378 };
18379
18380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18382 if (SWIG_arg_fail(1)) SWIG_fail;
18383 {
18384 PyThreadState* __tstate = wxPyBeginAllowThreads();
18385 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18386
18387 wxPyEndAllowThreads(__tstate);
18388 if (PyErr_Occurred()) SWIG_fail;
18389 }
18390 {
18391 resultobj = SWIG_From_long((long)(result));
18392 }
18393 return resultobj;
18394 fail:
18395 return NULL;
18396 }
18397
18398
18399 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18400 PyObject *obj;
18401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18402 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18403 Py_INCREF(obj);
18404 return Py_BuildValue((char *)"");
18405 }
18406 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj;
18408 wxString const &arg1_defvalue = wxPyEmptyString ;
18409 wxString *arg1 = (wxString *) &arg1_defvalue ;
18410 wxString const &arg2_defvalue = wxPyEmptyString ;
18411 wxString *arg2 = (wxString *) &arg2_defvalue ;
18412 wxString const &arg3_defvalue = wxPyEmptyString ;
18413 wxString *arg3 = (wxString *) &arg3_defvalue ;
18414 wxString const &arg4_defvalue = wxPyEmptyString ;
18415 wxString *arg4 = (wxString *) &arg4_defvalue ;
18416 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18417 wxConfig *result;
18418 bool temp1 = false ;
18419 bool temp2 = false ;
18420 bool temp3 = false ;
18421 bool temp4 = false ;
18422 PyObject * obj0 = 0 ;
18423 PyObject * obj1 = 0 ;
18424 PyObject * obj2 = 0 ;
18425 PyObject * obj3 = 0 ;
18426 PyObject * obj4 = 0 ;
18427 char *kwnames[] = {
18428 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18429 };
18430
18431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18432 if (obj0) {
18433 {
18434 arg1 = wxString_in_helper(obj0);
18435 if (arg1 == NULL) SWIG_fail;
18436 temp1 = true;
18437 }
18438 }
18439 if (obj1) {
18440 {
18441 arg2 = wxString_in_helper(obj1);
18442 if (arg2 == NULL) SWIG_fail;
18443 temp2 = true;
18444 }
18445 }
18446 if (obj2) {
18447 {
18448 arg3 = wxString_in_helper(obj2);
18449 if (arg3 == NULL) SWIG_fail;
18450 temp3 = true;
18451 }
18452 }
18453 if (obj3) {
18454 {
18455 arg4 = wxString_in_helper(obj3);
18456 if (arg4 == NULL) SWIG_fail;
18457 temp4 = true;
18458 }
18459 }
18460 if (obj4) {
18461 {
18462 arg5 = (long)(SWIG_As_long(obj4));
18463 if (SWIG_arg_fail(5)) SWIG_fail;
18464 }
18465 }
18466 {
18467 PyThreadState* __tstate = wxPyBeginAllowThreads();
18468 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18469
18470 wxPyEndAllowThreads(__tstate);
18471 if (PyErr_Occurred()) SWIG_fail;
18472 }
18473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18474 {
18475 if (temp1)
18476 delete arg1;
18477 }
18478 {
18479 if (temp2)
18480 delete arg2;
18481 }
18482 {
18483 if (temp3)
18484 delete arg3;
18485 }
18486 {
18487 if (temp4)
18488 delete arg4;
18489 }
18490 return resultobj;
18491 fail:
18492 {
18493 if (temp1)
18494 delete arg1;
18495 }
18496 {
18497 if (temp2)
18498 delete arg2;
18499 }
18500 {
18501 if (temp3)
18502 delete arg3;
18503 }
18504 {
18505 if (temp4)
18506 delete arg4;
18507 }
18508 return NULL;
18509 }
18510
18511
18512 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18513 PyObject *resultobj;
18514 wxConfig *arg1 = (wxConfig *) 0 ;
18515 PyObject * obj0 = 0 ;
18516 char *kwnames[] = {
18517 (char *) "self", NULL
18518 };
18519
18520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18522 if (SWIG_arg_fail(1)) SWIG_fail;
18523 {
18524 PyThreadState* __tstate = wxPyBeginAllowThreads();
18525 delete arg1;
18526
18527 wxPyEndAllowThreads(__tstate);
18528 if (PyErr_Occurred()) SWIG_fail;
18529 }
18530 Py_INCREF(Py_None); resultobj = Py_None;
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18538 PyObject *obj;
18539 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18540 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18541 Py_INCREF(obj);
18542 return Py_BuildValue((char *)"");
18543 }
18544 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18545 PyObject *resultobj;
18546 wxString const &arg1_defvalue = wxPyEmptyString ;
18547 wxString *arg1 = (wxString *) &arg1_defvalue ;
18548 wxString const &arg2_defvalue = wxPyEmptyString ;
18549 wxString *arg2 = (wxString *) &arg2_defvalue ;
18550 wxString const &arg3_defvalue = wxPyEmptyString ;
18551 wxString *arg3 = (wxString *) &arg3_defvalue ;
18552 wxString const &arg4_defvalue = wxPyEmptyString ;
18553 wxString *arg4 = (wxString *) &arg4_defvalue ;
18554 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18555 wxFileConfig *result;
18556 bool temp1 = false ;
18557 bool temp2 = false ;
18558 bool temp3 = false ;
18559 bool temp4 = false ;
18560 PyObject * obj0 = 0 ;
18561 PyObject * obj1 = 0 ;
18562 PyObject * obj2 = 0 ;
18563 PyObject * obj3 = 0 ;
18564 PyObject * obj4 = 0 ;
18565 char *kwnames[] = {
18566 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18567 };
18568
18569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18570 if (obj0) {
18571 {
18572 arg1 = wxString_in_helper(obj0);
18573 if (arg1 == NULL) SWIG_fail;
18574 temp1 = true;
18575 }
18576 }
18577 if (obj1) {
18578 {
18579 arg2 = wxString_in_helper(obj1);
18580 if (arg2 == NULL) SWIG_fail;
18581 temp2 = true;
18582 }
18583 }
18584 if (obj2) {
18585 {
18586 arg3 = wxString_in_helper(obj2);
18587 if (arg3 == NULL) SWIG_fail;
18588 temp3 = true;
18589 }
18590 }
18591 if (obj3) {
18592 {
18593 arg4 = wxString_in_helper(obj3);
18594 if (arg4 == NULL) SWIG_fail;
18595 temp4 = true;
18596 }
18597 }
18598 if (obj4) {
18599 {
18600 arg5 = (long)(SWIG_As_long(obj4));
18601 if (SWIG_arg_fail(5)) SWIG_fail;
18602 }
18603 }
18604 {
18605 PyThreadState* __tstate = wxPyBeginAllowThreads();
18606 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18607
18608 wxPyEndAllowThreads(__tstate);
18609 if (PyErr_Occurred()) SWIG_fail;
18610 }
18611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18612 {
18613 if (temp1)
18614 delete arg1;
18615 }
18616 {
18617 if (temp2)
18618 delete arg2;
18619 }
18620 {
18621 if (temp3)
18622 delete arg3;
18623 }
18624 {
18625 if (temp4)
18626 delete arg4;
18627 }
18628 return resultobj;
18629 fail:
18630 {
18631 if (temp1)
18632 delete arg1;
18633 }
18634 {
18635 if (temp2)
18636 delete arg2;
18637 }
18638 {
18639 if (temp3)
18640 delete arg3;
18641 }
18642 {
18643 if (temp4)
18644 delete arg4;
18645 }
18646 return NULL;
18647 }
18648
18649
18650 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18651 PyObject *resultobj;
18652 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18653 PyObject * obj0 = 0 ;
18654 char *kwnames[] = {
18655 (char *) "self", NULL
18656 };
18657
18658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18660 if (SWIG_arg_fail(1)) SWIG_fail;
18661 {
18662 PyThreadState* __tstate = wxPyBeginAllowThreads();
18663 delete arg1;
18664
18665 wxPyEndAllowThreads(__tstate);
18666 if (PyErr_Occurred()) SWIG_fail;
18667 }
18668 Py_INCREF(Py_None); resultobj = Py_None;
18669 return resultobj;
18670 fail:
18671 return NULL;
18672 }
18673
18674
18675 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18676 PyObject *obj;
18677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18678 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18679 Py_INCREF(obj);
18680 return Py_BuildValue((char *)"");
18681 }
18682 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18683 PyObject *resultobj;
18684 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18685 wxString *arg2 = 0 ;
18686 wxConfigPathChanger *result;
18687 bool temp2 = false ;
18688 PyObject * obj0 = 0 ;
18689 PyObject * obj1 = 0 ;
18690 char *kwnames[] = {
18691 (char *) "config",(char *) "entry", NULL
18692 };
18693
18694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18696 if (SWIG_arg_fail(1)) SWIG_fail;
18697 {
18698 arg2 = wxString_in_helper(obj1);
18699 if (arg2 == NULL) SWIG_fail;
18700 temp2 = true;
18701 }
18702 {
18703 PyThreadState* __tstate = wxPyBeginAllowThreads();
18704 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18705
18706 wxPyEndAllowThreads(__tstate);
18707 if (PyErr_Occurred()) SWIG_fail;
18708 }
18709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18710 {
18711 if (temp2)
18712 delete arg2;
18713 }
18714 return resultobj;
18715 fail:
18716 {
18717 if (temp2)
18718 delete arg2;
18719 }
18720 return NULL;
18721 }
18722
18723
18724 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18725 PyObject *resultobj;
18726 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18727 PyObject * obj0 = 0 ;
18728 char *kwnames[] = {
18729 (char *) "self", NULL
18730 };
18731
18732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18734 if (SWIG_arg_fail(1)) SWIG_fail;
18735 {
18736 PyThreadState* __tstate = wxPyBeginAllowThreads();
18737 delete arg1;
18738
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 Py_INCREF(Py_None); resultobj = Py_None;
18743 return resultobj;
18744 fail:
18745 return NULL;
18746 }
18747
18748
18749 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18750 PyObject *resultobj;
18751 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18752 wxString *result;
18753 PyObject * obj0 = 0 ;
18754 char *kwnames[] = {
18755 (char *) "self", NULL
18756 };
18757
18758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18760 if (SWIG_arg_fail(1)) SWIG_fail;
18761 {
18762 PyThreadState* __tstate = wxPyBeginAllowThreads();
18763 {
18764 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18765 result = (wxString *) &_result_ref;
18766 }
18767
18768 wxPyEndAllowThreads(__tstate);
18769 if (PyErr_Occurred()) SWIG_fail;
18770 }
18771 {
18772 #if wxUSE_UNICODE
18773 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18774 #else
18775 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18776 #endif
18777 }
18778 return resultobj;
18779 fail:
18780 return NULL;
18781 }
18782
18783
18784 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18785 PyObject *obj;
18786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18787 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18788 Py_INCREF(obj);
18789 return Py_BuildValue((char *)"");
18790 }
18791 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18792 PyObject *resultobj;
18793 wxString *arg1 = 0 ;
18794 wxString result;
18795 bool temp1 = false ;
18796 PyObject * obj0 = 0 ;
18797 char *kwnames[] = {
18798 (char *) "sz", NULL
18799 };
18800
18801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18802 {
18803 arg1 = wxString_in_helper(obj0);
18804 if (arg1 == NULL) SWIG_fail;
18805 temp1 = true;
18806 }
18807 {
18808 PyThreadState* __tstate = wxPyBeginAllowThreads();
18809 result = wxExpandEnvVars((wxString const &)*arg1);
18810
18811 wxPyEndAllowThreads(__tstate);
18812 if (PyErr_Occurred()) SWIG_fail;
18813 }
18814 {
18815 #if wxUSE_UNICODE
18816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18817 #else
18818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18819 #endif
18820 }
18821 {
18822 if (temp1)
18823 delete arg1;
18824 }
18825 return resultobj;
18826 fail:
18827 {
18828 if (temp1)
18829 delete arg1;
18830 }
18831 return NULL;
18832 }
18833
18834
18835 static int _wrap_DateFormatStr_set(PyObject *) {
18836 PyErr_SetString(PyExc_TypeError,"Variable DateFormatStr is read-only.");
18837 return 1;
18838 }
18839
18840
18841 static PyObject *_wrap_DateFormatStr_get(void) {
18842 PyObject *pyobj;
18843
18844 {
18845 #if wxUSE_UNICODE
18846 pyobj = PyUnicode_FromWideChar((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18847 #else
18848 pyobj = PyString_FromStringAndSize((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
18849 #endif
18850 }
18851 return pyobj;
18852 }
18853
18854
18855 static int _wrap_TimeSpanFormatStr_set(PyObject *) {
18856 PyErr_SetString(PyExc_TypeError,"Variable TimeSpanFormatStr is read-only.");
18857 return 1;
18858 }
18859
18860
18861 static PyObject *_wrap_TimeSpanFormatStr_get(void) {
18862 PyObject *pyobj;
18863
18864 {
18865 #if wxUSE_UNICODE
18866 pyobj = PyUnicode_FromWideChar((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18867 #else
18868 pyobj = PyString_FromStringAndSize((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
18869 #endif
18870 }
18871 return pyobj;
18872 }
18873
18874
18875 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18876 PyObject *resultobj;
18877 wxDateTime::Country arg1 ;
18878 PyObject * obj0 = 0 ;
18879 char *kwnames[] = {
18880 (char *) "country", NULL
18881 };
18882
18883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18884 {
18885 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18886 if (SWIG_arg_fail(1)) SWIG_fail;
18887 }
18888 {
18889 PyThreadState* __tstate = wxPyBeginAllowThreads();
18890 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18891
18892 wxPyEndAllowThreads(__tstate);
18893 if (PyErr_Occurred()) SWIG_fail;
18894 }
18895 Py_INCREF(Py_None); resultobj = Py_None;
18896 return resultobj;
18897 fail:
18898 return NULL;
18899 }
18900
18901
18902 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18903 PyObject *resultobj;
18904 wxDateTime::Country result;
18905 char *kwnames[] = {
18906 NULL
18907 };
18908
18909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18910 {
18911 PyThreadState* __tstate = wxPyBeginAllowThreads();
18912 result = (wxDateTime::Country)wxDateTime::GetCountry();
18913
18914 wxPyEndAllowThreads(__tstate);
18915 if (PyErr_Occurred()) SWIG_fail;
18916 }
18917 resultobj = SWIG_From_int((result));
18918 return resultobj;
18919 fail:
18920 return NULL;
18921 }
18922
18923
18924 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18925 PyObject *resultobj;
18926 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18927 bool result;
18928 PyObject * obj0 = 0 ;
18929 char *kwnames[] = {
18930 (char *) "country", NULL
18931 };
18932
18933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18934 if (obj0) {
18935 {
18936 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18937 if (SWIG_arg_fail(1)) SWIG_fail;
18938 }
18939 }
18940 {
18941 PyThreadState* __tstate = wxPyBeginAllowThreads();
18942 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18943
18944 wxPyEndAllowThreads(__tstate);
18945 if (PyErr_Occurred()) SWIG_fail;
18946 }
18947 {
18948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18949 }
18950 return resultobj;
18951 fail:
18952 return NULL;
18953 }
18954
18955
18956 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18957 PyObject *resultobj;
18958 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18959 int result;
18960 PyObject * obj0 = 0 ;
18961 char *kwnames[] = {
18962 (char *) "cal", NULL
18963 };
18964
18965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18966 if (obj0) {
18967 {
18968 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18969 if (SWIG_arg_fail(1)) SWIG_fail;
18970 }
18971 }
18972 {
18973 PyThreadState* __tstate = wxPyBeginAllowThreads();
18974 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18975
18976 wxPyEndAllowThreads(__tstate);
18977 if (PyErr_Occurred()) SWIG_fail;
18978 }
18979 {
18980 resultobj = SWIG_From_int((int)(result));
18981 }
18982 return resultobj;
18983 fail:
18984 return NULL;
18985 }
18986
18987
18988 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18989 PyObject *resultobj;
18990 int arg1 ;
18991 int result;
18992 PyObject * obj0 = 0 ;
18993 char *kwnames[] = {
18994 (char *) "year", NULL
18995 };
18996
18997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18998 {
18999 arg1 = (int)(SWIG_As_int(obj0));
19000 if (SWIG_arg_fail(1)) SWIG_fail;
19001 }
19002 {
19003 PyThreadState* __tstate = wxPyBeginAllowThreads();
19004 result = (int)wxDateTime::ConvertYearToBC(arg1);
19005
19006 wxPyEndAllowThreads(__tstate);
19007 if (PyErr_Occurred()) SWIG_fail;
19008 }
19009 {
19010 resultobj = SWIG_From_int((int)(result));
19011 }
19012 return resultobj;
19013 fail:
19014 return NULL;
19015 }
19016
19017
19018 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19019 PyObject *resultobj;
19020 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19021 wxDateTime::Month result;
19022 PyObject * obj0 = 0 ;
19023 char *kwnames[] = {
19024 (char *) "cal", NULL
19025 };
19026
19027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19028 if (obj0) {
19029 {
19030 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19031 if (SWIG_arg_fail(1)) SWIG_fail;
19032 }
19033 }
19034 {
19035 PyThreadState* __tstate = wxPyBeginAllowThreads();
19036 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19037
19038 wxPyEndAllowThreads(__tstate);
19039 if (PyErr_Occurred()) SWIG_fail;
19040 }
19041 resultobj = SWIG_From_int((result));
19042 return resultobj;
19043 fail:
19044 return NULL;
19045 }
19046
19047
19048 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19049 PyObject *resultobj;
19050 int arg1 = (int) wxDateTime::Inv_Year ;
19051 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19052 bool result;
19053 PyObject * obj0 = 0 ;
19054 PyObject * obj1 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "year",(char *) "cal", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19060 if (obj0) {
19061 {
19062 arg1 = (int)(SWIG_As_int(obj0));
19063 if (SWIG_arg_fail(1)) SWIG_fail;
19064 }
19065 }
19066 if (obj1) {
19067 {
19068 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19069 if (SWIG_arg_fail(2)) SWIG_fail;
19070 }
19071 }
19072 {
19073 PyThreadState* __tstate = wxPyBeginAllowThreads();
19074 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19075
19076 wxPyEndAllowThreads(__tstate);
19077 if (PyErr_Occurred()) SWIG_fail;
19078 }
19079 {
19080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19081 }
19082 return resultobj;
19083 fail:
19084 return NULL;
19085 }
19086
19087
19088 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19089 PyObject *resultobj;
19090 int arg1 = (int) wxDateTime::Inv_Year ;
19091 int result;
19092 PyObject * obj0 = 0 ;
19093 char *kwnames[] = {
19094 (char *) "year", NULL
19095 };
19096
19097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19098 if (obj0) {
19099 {
19100 arg1 = (int)(SWIG_As_int(obj0));
19101 if (SWIG_arg_fail(1)) SWIG_fail;
19102 }
19103 }
19104 {
19105 PyThreadState* __tstate = wxPyBeginAllowThreads();
19106 result = (int)wxDateTime::GetCentury(arg1);
19107
19108 wxPyEndAllowThreads(__tstate);
19109 if (PyErr_Occurred()) SWIG_fail;
19110 }
19111 {
19112 resultobj = SWIG_From_int((int)(result));
19113 }
19114 return resultobj;
19115 fail:
19116 return NULL;
19117 }
19118
19119
19120 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19121 PyObject *resultobj;
19122 int arg1 ;
19123 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19124 int result;
19125 PyObject * obj0 = 0 ;
19126 PyObject * obj1 = 0 ;
19127 char *kwnames[] = {
19128 (char *) "year",(char *) "cal", NULL
19129 };
19130
19131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19132 {
19133 arg1 = (int)(SWIG_As_int(obj0));
19134 if (SWIG_arg_fail(1)) SWIG_fail;
19135 }
19136 if (obj1) {
19137 {
19138 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19139 if (SWIG_arg_fail(2)) SWIG_fail;
19140 }
19141 }
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19145
19146 wxPyEndAllowThreads(__tstate);
19147 if (PyErr_Occurred()) SWIG_fail;
19148 }
19149 {
19150 resultobj = SWIG_From_int((int)(result));
19151 }
19152 return resultobj;
19153 fail:
19154 return NULL;
19155 }
19156
19157
19158 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19159 PyObject *resultobj;
19160 wxDateTime::Month arg1 ;
19161 int arg2 = (int) wxDateTime::Inv_Year ;
19162 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19163 int result;
19164 PyObject * obj0 = 0 ;
19165 PyObject * obj1 = 0 ;
19166 PyObject * obj2 = 0 ;
19167 char *kwnames[] = {
19168 (char *) "month",(char *) "year",(char *) "cal", NULL
19169 };
19170
19171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19172 {
19173 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19174 if (SWIG_arg_fail(1)) SWIG_fail;
19175 }
19176 if (obj1) {
19177 {
19178 arg2 = (int)(SWIG_As_int(obj1));
19179 if (SWIG_arg_fail(2)) SWIG_fail;
19180 }
19181 }
19182 if (obj2) {
19183 {
19184 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19185 if (SWIG_arg_fail(3)) SWIG_fail;
19186 }
19187 }
19188 {
19189 PyThreadState* __tstate = wxPyBeginAllowThreads();
19190 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19191
19192 wxPyEndAllowThreads(__tstate);
19193 if (PyErr_Occurred()) SWIG_fail;
19194 }
19195 {
19196 resultobj = SWIG_From_int((int)(result));
19197 }
19198 return resultobj;
19199 fail:
19200 return NULL;
19201 }
19202
19203
19204 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19205 PyObject *resultobj;
19206 wxDateTime::Month arg1 ;
19207 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19208 wxString result;
19209 PyObject * obj0 = 0 ;
19210 PyObject * obj1 = 0 ;
19211 char *kwnames[] = {
19212 (char *) "month",(char *) "flags", NULL
19213 };
19214
19215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19216 {
19217 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19218 if (SWIG_arg_fail(1)) SWIG_fail;
19219 }
19220 if (obj1) {
19221 {
19222 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19223 if (SWIG_arg_fail(2)) SWIG_fail;
19224 }
19225 }
19226 {
19227 PyThreadState* __tstate = wxPyBeginAllowThreads();
19228 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19229
19230 wxPyEndAllowThreads(__tstate);
19231 if (PyErr_Occurred()) SWIG_fail;
19232 }
19233 {
19234 #if wxUSE_UNICODE
19235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19236 #else
19237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19238 #endif
19239 }
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19247 PyObject *resultobj;
19248 wxDateTime::WeekDay arg1 ;
19249 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19250 wxString result;
19251 PyObject * obj0 = 0 ;
19252 PyObject * obj1 = 0 ;
19253 char *kwnames[] = {
19254 (char *) "weekday",(char *) "flags", NULL
19255 };
19256
19257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19258 {
19259 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19260 if (SWIG_arg_fail(1)) SWIG_fail;
19261 }
19262 if (obj1) {
19263 {
19264 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19265 if (SWIG_arg_fail(2)) SWIG_fail;
19266 }
19267 }
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19271
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 {
19276 #if wxUSE_UNICODE
19277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19278 #else
19279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19280 #endif
19281 }
19282 return resultobj;
19283 fail:
19284 return NULL;
19285 }
19286
19287
19288 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19289 PyObject *resultobj;
19290 wxString *arg1 = (wxString *) 0 ;
19291 wxString *arg2 = (wxString *) 0 ;
19292 bool temp1 = false ;
19293 bool temp2 = false ;
19294 PyObject * obj0 = 0 ;
19295 PyObject * obj1 = 0 ;
19296 char *kwnames[] = {
19297 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19298 };
19299
19300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19301 {
19302 arg1 = wxString_in_helper(obj0);
19303 if (arg1 == NULL) SWIG_fail;
19304 temp1 = true;
19305 }
19306 {
19307 arg2 = wxString_in_helper(obj1);
19308 if (arg2 == NULL) SWIG_fail;
19309 temp2 = true;
19310 }
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 wxDateTime::GetAmPmStrings(arg1,arg2);
19314
19315 wxPyEndAllowThreads(__tstate);
19316 if (PyErr_Occurred()) SWIG_fail;
19317 }
19318 Py_INCREF(Py_None); resultobj = Py_None;
19319 {
19320 if (temp1)
19321 delete arg1;
19322 }
19323 {
19324 if (temp2)
19325 delete arg2;
19326 }
19327 return resultobj;
19328 fail:
19329 {
19330 if (temp1)
19331 delete arg1;
19332 }
19333 {
19334 if (temp2)
19335 delete arg2;
19336 }
19337 return NULL;
19338 }
19339
19340
19341 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19342 PyObject *resultobj;
19343 int arg1 = (int) wxDateTime::Inv_Year ;
19344 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19345 bool result;
19346 PyObject * obj0 = 0 ;
19347 PyObject * obj1 = 0 ;
19348 char *kwnames[] = {
19349 (char *) "year",(char *) "country", NULL
19350 };
19351
19352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19353 if (obj0) {
19354 {
19355 arg1 = (int)(SWIG_As_int(obj0));
19356 if (SWIG_arg_fail(1)) SWIG_fail;
19357 }
19358 }
19359 if (obj1) {
19360 {
19361 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19362 if (SWIG_arg_fail(2)) SWIG_fail;
19363 }
19364 }
19365 {
19366 PyThreadState* __tstate = wxPyBeginAllowThreads();
19367 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19368
19369 wxPyEndAllowThreads(__tstate);
19370 if (PyErr_Occurred()) SWIG_fail;
19371 }
19372 {
19373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19374 }
19375 return resultobj;
19376 fail:
19377 return NULL;
19378 }
19379
19380
19381 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19382 PyObject *resultobj;
19383 int arg1 = (int) wxDateTime::Inv_Year ;
19384 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19385 wxDateTime result;
19386 PyObject * obj0 = 0 ;
19387 PyObject * obj1 = 0 ;
19388 char *kwnames[] = {
19389 (char *) "year",(char *) "country", NULL
19390 };
19391
19392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19393 if (obj0) {
19394 {
19395 arg1 = (int)(SWIG_As_int(obj0));
19396 if (SWIG_arg_fail(1)) SWIG_fail;
19397 }
19398 }
19399 if (obj1) {
19400 {
19401 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19402 if (SWIG_arg_fail(2)) SWIG_fail;
19403 }
19404 }
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19408
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 {
19413 wxDateTime * resultptr;
19414 resultptr = new wxDateTime((wxDateTime &)(result));
19415 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19416 }
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19424 PyObject *resultobj;
19425 int arg1 = (int) wxDateTime::Inv_Year ;
19426 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19427 wxDateTime result;
19428 PyObject * obj0 = 0 ;
19429 PyObject * obj1 = 0 ;
19430 char *kwnames[] = {
19431 (char *) "year",(char *) "country", NULL
19432 };
19433
19434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19435 if (obj0) {
19436 {
19437 arg1 = (int)(SWIG_As_int(obj0));
19438 if (SWIG_arg_fail(1)) SWIG_fail;
19439 }
19440 }
19441 if (obj1) {
19442 {
19443 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19444 if (SWIG_arg_fail(2)) SWIG_fail;
19445 }
19446 }
19447 {
19448 PyThreadState* __tstate = wxPyBeginAllowThreads();
19449 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19450
19451 wxPyEndAllowThreads(__tstate);
19452 if (PyErr_Occurred()) SWIG_fail;
19453 }
19454 {
19455 wxDateTime * resultptr;
19456 resultptr = new wxDateTime((wxDateTime &)(result));
19457 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19458 }
19459 return resultobj;
19460 fail:
19461 return NULL;
19462 }
19463
19464
19465 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19466 PyObject *resultobj;
19467 wxDateTime result;
19468 char *kwnames[] = {
19469 NULL
19470 };
19471
19472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19473 {
19474 PyThreadState* __tstate = wxPyBeginAllowThreads();
19475 result = wxDateTime::Now();
19476
19477 wxPyEndAllowThreads(__tstate);
19478 if (PyErr_Occurred()) SWIG_fail;
19479 }
19480 {
19481 wxDateTime * resultptr;
19482 resultptr = new wxDateTime((wxDateTime &)(result));
19483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19484 }
19485 return resultobj;
19486 fail:
19487 return NULL;
19488 }
19489
19490
19491 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19492 PyObject *resultobj;
19493 wxDateTime result;
19494 char *kwnames[] = {
19495 NULL
19496 };
19497
19498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19499 {
19500 PyThreadState* __tstate = wxPyBeginAllowThreads();
19501 result = wxDateTime::UNow();
19502
19503 wxPyEndAllowThreads(__tstate);
19504 if (PyErr_Occurred()) SWIG_fail;
19505 }
19506 {
19507 wxDateTime * resultptr;
19508 resultptr = new wxDateTime((wxDateTime &)(result));
19509 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19510 }
19511 return resultobj;
19512 fail:
19513 return NULL;
19514 }
19515
19516
19517 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19518 PyObject *resultobj;
19519 wxDateTime result;
19520 char *kwnames[] = {
19521 NULL
19522 };
19523
19524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19525 {
19526 PyThreadState* __tstate = wxPyBeginAllowThreads();
19527 result = wxDateTime::Today();
19528
19529 wxPyEndAllowThreads(__tstate);
19530 if (PyErr_Occurred()) SWIG_fail;
19531 }
19532 {
19533 wxDateTime * resultptr;
19534 resultptr = new wxDateTime((wxDateTime &)(result));
19535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19536 }
19537 return resultobj;
19538 fail:
19539 return NULL;
19540 }
19541
19542
19543 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19544 PyObject *resultobj;
19545 wxDateTime *result;
19546 char *kwnames[] = {
19547 NULL
19548 };
19549
19550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19551 {
19552 PyThreadState* __tstate = wxPyBeginAllowThreads();
19553 result = (wxDateTime *)new wxDateTime();
19554
19555 wxPyEndAllowThreads(__tstate);
19556 if (PyErr_Occurred()) SWIG_fail;
19557 }
19558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19559 return resultobj;
19560 fail:
19561 return NULL;
19562 }
19563
19564
19565 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19566 PyObject *resultobj;
19567 time_t arg1 ;
19568 wxDateTime *result;
19569 PyObject * obj0 = 0 ;
19570 char *kwnames[] = {
19571 (char *) "timet", NULL
19572 };
19573
19574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19575 {
19576 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19577 if (SWIG_arg_fail(1)) SWIG_fail;
19578 }
19579 {
19580 PyThreadState* __tstate = wxPyBeginAllowThreads();
19581 result = (wxDateTime *)new wxDateTime(arg1);
19582
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19587 return resultobj;
19588 fail:
19589 return NULL;
19590 }
19591
19592
19593 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19594 PyObject *resultobj;
19595 double arg1 ;
19596 wxDateTime *result;
19597 PyObject * obj0 = 0 ;
19598 char *kwnames[] = {
19599 (char *) "jdn", NULL
19600 };
19601
19602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19603 {
19604 arg1 = (double)(SWIG_As_double(obj0));
19605 if (SWIG_arg_fail(1)) SWIG_fail;
19606 }
19607 {
19608 PyThreadState* __tstate = wxPyBeginAllowThreads();
19609 result = (wxDateTime *)new wxDateTime(arg1);
19610
19611 wxPyEndAllowThreads(__tstate);
19612 if (PyErr_Occurred()) SWIG_fail;
19613 }
19614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19615 return resultobj;
19616 fail:
19617 return NULL;
19618 }
19619
19620
19621 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19622 PyObject *resultobj;
19623 int arg1 ;
19624 int arg2 = (int) 0 ;
19625 int arg3 = (int) 0 ;
19626 int arg4 = (int) 0 ;
19627 wxDateTime *result;
19628 PyObject * obj0 = 0 ;
19629 PyObject * obj1 = 0 ;
19630 PyObject * obj2 = 0 ;
19631 PyObject * obj3 = 0 ;
19632 char *kwnames[] = {
19633 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19634 };
19635
19636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19637 {
19638 arg1 = (int)(SWIG_As_int(obj0));
19639 if (SWIG_arg_fail(1)) SWIG_fail;
19640 }
19641 if (obj1) {
19642 {
19643 arg2 = (int)(SWIG_As_int(obj1));
19644 if (SWIG_arg_fail(2)) SWIG_fail;
19645 }
19646 }
19647 if (obj2) {
19648 {
19649 arg3 = (int)(SWIG_As_int(obj2));
19650 if (SWIG_arg_fail(3)) SWIG_fail;
19651 }
19652 }
19653 if (obj3) {
19654 {
19655 arg4 = (int)(SWIG_As_int(obj3));
19656 if (SWIG_arg_fail(4)) SWIG_fail;
19657 }
19658 }
19659 {
19660 PyThreadState* __tstate = wxPyBeginAllowThreads();
19661 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19662
19663 wxPyEndAllowThreads(__tstate);
19664 if (PyErr_Occurred()) SWIG_fail;
19665 }
19666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19667 return resultobj;
19668 fail:
19669 return NULL;
19670 }
19671
19672
19673 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19674 PyObject *resultobj;
19675 int arg1 ;
19676 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19677 int arg3 = (int) wxDateTime::Inv_Year ;
19678 int arg4 = (int) 0 ;
19679 int arg5 = (int) 0 ;
19680 int arg6 = (int) 0 ;
19681 int arg7 = (int) 0 ;
19682 wxDateTime *result;
19683 PyObject * obj0 = 0 ;
19684 PyObject * obj1 = 0 ;
19685 PyObject * obj2 = 0 ;
19686 PyObject * obj3 = 0 ;
19687 PyObject * obj4 = 0 ;
19688 PyObject * obj5 = 0 ;
19689 PyObject * obj6 = 0 ;
19690 char *kwnames[] = {
19691 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19692 };
19693
19694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19695 {
19696 arg1 = (int)(SWIG_As_int(obj0));
19697 if (SWIG_arg_fail(1)) SWIG_fail;
19698 }
19699 if (obj1) {
19700 {
19701 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19702 if (SWIG_arg_fail(2)) SWIG_fail;
19703 }
19704 }
19705 if (obj2) {
19706 {
19707 arg3 = (int)(SWIG_As_int(obj2));
19708 if (SWIG_arg_fail(3)) SWIG_fail;
19709 }
19710 }
19711 if (obj3) {
19712 {
19713 arg4 = (int)(SWIG_As_int(obj3));
19714 if (SWIG_arg_fail(4)) SWIG_fail;
19715 }
19716 }
19717 if (obj4) {
19718 {
19719 arg5 = (int)(SWIG_As_int(obj4));
19720 if (SWIG_arg_fail(5)) SWIG_fail;
19721 }
19722 }
19723 if (obj5) {
19724 {
19725 arg6 = (int)(SWIG_As_int(obj5));
19726 if (SWIG_arg_fail(6)) SWIG_fail;
19727 }
19728 }
19729 if (obj6) {
19730 {
19731 arg7 = (int)(SWIG_As_int(obj6));
19732 if (SWIG_arg_fail(7)) SWIG_fail;
19733 }
19734 }
19735 {
19736 PyThreadState* __tstate = wxPyBeginAllowThreads();
19737 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19738
19739 wxPyEndAllowThreads(__tstate);
19740 if (PyErr_Occurred()) SWIG_fail;
19741 }
19742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19743 return resultobj;
19744 fail:
19745 return NULL;
19746 }
19747
19748
19749 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19750 PyObject *resultobj;
19751 wxDateTime *arg1 = (wxDateTime *) 0 ;
19752 PyObject * obj0 = 0 ;
19753 char *kwnames[] = {
19754 (char *) "self", NULL
19755 };
19756
19757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19759 if (SWIG_arg_fail(1)) SWIG_fail;
19760 {
19761 PyThreadState* __tstate = wxPyBeginAllowThreads();
19762 delete arg1;
19763
19764 wxPyEndAllowThreads(__tstate);
19765 if (PyErr_Occurred()) SWIG_fail;
19766 }
19767 Py_INCREF(Py_None); resultobj = Py_None;
19768 return resultobj;
19769 fail:
19770 return NULL;
19771 }
19772
19773
19774 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19775 PyObject *resultobj;
19776 wxDateTime *arg1 = (wxDateTime *) 0 ;
19777 wxDateTime *result;
19778 PyObject * obj0 = 0 ;
19779 char *kwnames[] = {
19780 (char *) "self", NULL
19781 };
19782
19783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19785 if (SWIG_arg_fail(1)) SWIG_fail;
19786 {
19787 PyThreadState* __tstate = wxPyBeginAllowThreads();
19788 {
19789 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19790 result = (wxDateTime *) &_result_ref;
19791 }
19792
19793 wxPyEndAllowThreads(__tstate);
19794 if (PyErr_Occurred()) SWIG_fail;
19795 }
19796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19797 return resultobj;
19798 fail:
19799 return NULL;
19800 }
19801
19802
19803 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19804 PyObject *resultobj;
19805 wxDateTime *arg1 = (wxDateTime *) 0 ;
19806 time_t arg2 ;
19807 wxDateTime *result;
19808 PyObject * obj0 = 0 ;
19809 PyObject * obj1 = 0 ;
19810 char *kwnames[] = {
19811 (char *) "self",(char *) "timet", NULL
19812 };
19813
19814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19816 if (SWIG_arg_fail(1)) SWIG_fail;
19817 {
19818 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19819 if (SWIG_arg_fail(2)) SWIG_fail;
19820 }
19821 {
19822 PyThreadState* __tstate = wxPyBeginAllowThreads();
19823 {
19824 wxDateTime &_result_ref = (arg1)->Set(arg2);
19825 result = (wxDateTime *) &_result_ref;
19826 }
19827
19828 wxPyEndAllowThreads(__tstate);
19829 if (PyErr_Occurred()) SWIG_fail;
19830 }
19831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19832 return resultobj;
19833 fail:
19834 return NULL;
19835 }
19836
19837
19838 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19839 PyObject *resultobj;
19840 wxDateTime *arg1 = (wxDateTime *) 0 ;
19841 double arg2 ;
19842 wxDateTime *result;
19843 PyObject * obj0 = 0 ;
19844 PyObject * obj1 = 0 ;
19845 char *kwnames[] = {
19846 (char *) "self",(char *) "jdn", NULL
19847 };
19848
19849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19851 if (SWIG_arg_fail(1)) SWIG_fail;
19852 {
19853 arg2 = (double)(SWIG_As_double(obj1));
19854 if (SWIG_arg_fail(2)) SWIG_fail;
19855 }
19856 {
19857 PyThreadState* __tstate = wxPyBeginAllowThreads();
19858 {
19859 wxDateTime &_result_ref = (arg1)->Set(arg2);
19860 result = (wxDateTime *) &_result_ref;
19861 }
19862
19863 wxPyEndAllowThreads(__tstate);
19864 if (PyErr_Occurred()) SWIG_fail;
19865 }
19866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19867 return resultobj;
19868 fail:
19869 return NULL;
19870 }
19871
19872
19873 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19874 PyObject *resultobj;
19875 wxDateTime *arg1 = (wxDateTime *) 0 ;
19876 int arg2 ;
19877 int arg3 = (int) 0 ;
19878 int arg4 = (int) 0 ;
19879 int arg5 = (int) 0 ;
19880 wxDateTime *result;
19881 PyObject * obj0 = 0 ;
19882 PyObject * obj1 = 0 ;
19883 PyObject * obj2 = 0 ;
19884 PyObject * obj3 = 0 ;
19885 PyObject * obj4 = 0 ;
19886 char *kwnames[] = {
19887 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19888 };
19889
19890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19892 if (SWIG_arg_fail(1)) SWIG_fail;
19893 {
19894 arg2 = (int)(SWIG_As_int(obj1));
19895 if (SWIG_arg_fail(2)) SWIG_fail;
19896 }
19897 if (obj2) {
19898 {
19899 arg3 = (int)(SWIG_As_int(obj2));
19900 if (SWIG_arg_fail(3)) SWIG_fail;
19901 }
19902 }
19903 if (obj3) {
19904 {
19905 arg4 = (int)(SWIG_As_int(obj3));
19906 if (SWIG_arg_fail(4)) SWIG_fail;
19907 }
19908 }
19909 if (obj4) {
19910 {
19911 arg5 = (int)(SWIG_As_int(obj4));
19912 if (SWIG_arg_fail(5)) SWIG_fail;
19913 }
19914 }
19915 {
19916 PyThreadState* __tstate = wxPyBeginAllowThreads();
19917 {
19918 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19919 result = (wxDateTime *) &_result_ref;
19920 }
19921
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19926 return resultobj;
19927 fail:
19928 return NULL;
19929 }
19930
19931
19932 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19933 PyObject *resultobj;
19934 wxDateTime *arg1 = (wxDateTime *) 0 ;
19935 int arg2 ;
19936 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19937 int arg4 = (int) wxDateTime::Inv_Year ;
19938 int arg5 = (int) 0 ;
19939 int arg6 = (int) 0 ;
19940 int arg7 = (int) 0 ;
19941 int arg8 = (int) 0 ;
19942 wxDateTime *result;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 PyObject * obj2 = 0 ;
19946 PyObject * obj3 = 0 ;
19947 PyObject * obj4 = 0 ;
19948 PyObject * obj5 = 0 ;
19949 PyObject * obj6 = 0 ;
19950 PyObject * obj7 = 0 ;
19951 char *kwnames[] = {
19952 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19953 };
19954
19955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19957 if (SWIG_arg_fail(1)) SWIG_fail;
19958 {
19959 arg2 = (int)(SWIG_As_int(obj1));
19960 if (SWIG_arg_fail(2)) SWIG_fail;
19961 }
19962 if (obj2) {
19963 {
19964 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19965 if (SWIG_arg_fail(3)) SWIG_fail;
19966 }
19967 }
19968 if (obj3) {
19969 {
19970 arg4 = (int)(SWIG_As_int(obj3));
19971 if (SWIG_arg_fail(4)) SWIG_fail;
19972 }
19973 }
19974 if (obj4) {
19975 {
19976 arg5 = (int)(SWIG_As_int(obj4));
19977 if (SWIG_arg_fail(5)) SWIG_fail;
19978 }
19979 }
19980 if (obj5) {
19981 {
19982 arg6 = (int)(SWIG_As_int(obj5));
19983 if (SWIG_arg_fail(6)) SWIG_fail;
19984 }
19985 }
19986 if (obj6) {
19987 {
19988 arg7 = (int)(SWIG_As_int(obj6));
19989 if (SWIG_arg_fail(7)) SWIG_fail;
19990 }
19991 }
19992 if (obj7) {
19993 {
19994 arg8 = (int)(SWIG_As_int(obj7));
19995 if (SWIG_arg_fail(8)) SWIG_fail;
19996 }
19997 }
19998 {
19999 PyThreadState* __tstate = wxPyBeginAllowThreads();
20000 {
20001 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20002 result = (wxDateTime *) &_result_ref;
20003 }
20004
20005 wxPyEndAllowThreads(__tstate);
20006 if (PyErr_Occurred()) SWIG_fail;
20007 }
20008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20009 return resultobj;
20010 fail:
20011 return NULL;
20012 }
20013
20014
20015 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20016 PyObject *resultobj;
20017 wxDateTime *arg1 = (wxDateTime *) 0 ;
20018 wxDateTime *result;
20019 PyObject * obj0 = 0 ;
20020 char *kwnames[] = {
20021 (char *) "self", NULL
20022 };
20023
20024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20026 if (SWIG_arg_fail(1)) SWIG_fail;
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 {
20030 wxDateTime &_result_ref = (arg1)->ResetTime();
20031 result = (wxDateTime *) &_result_ref;
20032 }
20033
20034 wxPyEndAllowThreads(__tstate);
20035 if (PyErr_Occurred()) SWIG_fail;
20036 }
20037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20038 return resultobj;
20039 fail:
20040 return NULL;
20041 }
20042
20043
20044 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20045 PyObject *resultobj;
20046 wxDateTime *arg1 = (wxDateTime *) 0 ;
20047 int arg2 ;
20048 wxDateTime *result;
20049 PyObject * obj0 = 0 ;
20050 PyObject * obj1 = 0 ;
20051 char *kwnames[] = {
20052 (char *) "self",(char *) "year", NULL
20053 };
20054
20055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20057 if (SWIG_arg_fail(1)) SWIG_fail;
20058 {
20059 arg2 = (int)(SWIG_As_int(obj1));
20060 if (SWIG_arg_fail(2)) SWIG_fail;
20061 }
20062 {
20063 PyThreadState* __tstate = wxPyBeginAllowThreads();
20064 {
20065 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20066 result = (wxDateTime *) &_result_ref;
20067 }
20068
20069 wxPyEndAllowThreads(__tstate);
20070 if (PyErr_Occurred()) SWIG_fail;
20071 }
20072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20073 return resultobj;
20074 fail:
20075 return NULL;
20076 }
20077
20078
20079 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20080 PyObject *resultobj;
20081 wxDateTime *arg1 = (wxDateTime *) 0 ;
20082 wxDateTime::Month arg2 ;
20083 wxDateTime *result;
20084 PyObject * obj0 = 0 ;
20085 PyObject * obj1 = 0 ;
20086 char *kwnames[] = {
20087 (char *) "self",(char *) "month", NULL
20088 };
20089
20090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20092 if (SWIG_arg_fail(1)) SWIG_fail;
20093 {
20094 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20095 if (SWIG_arg_fail(2)) SWIG_fail;
20096 }
20097 {
20098 PyThreadState* __tstate = wxPyBeginAllowThreads();
20099 {
20100 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20101 result = (wxDateTime *) &_result_ref;
20102 }
20103
20104 wxPyEndAllowThreads(__tstate);
20105 if (PyErr_Occurred()) SWIG_fail;
20106 }
20107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20108 return resultobj;
20109 fail:
20110 return NULL;
20111 }
20112
20113
20114 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20115 PyObject *resultobj;
20116 wxDateTime *arg1 = (wxDateTime *) 0 ;
20117 int arg2 ;
20118 wxDateTime *result;
20119 PyObject * obj0 = 0 ;
20120 PyObject * obj1 = 0 ;
20121 char *kwnames[] = {
20122 (char *) "self",(char *) "day", NULL
20123 };
20124
20125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20127 if (SWIG_arg_fail(1)) SWIG_fail;
20128 {
20129 arg2 = (int)(SWIG_As_int(obj1));
20130 if (SWIG_arg_fail(2)) SWIG_fail;
20131 }
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 {
20135 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20136 result = (wxDateTime *) &_result_ref;
20137 }
20138
20139 wxPyEndAllowThreads(__tstate);
20140 if (PyErr_Occurred()) SWIG_fail;
20141 }
20142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20143 return resultobj;
20144 fail:
20145 return NULL;
20146 }
20147
20148
20149 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20150 PyObject *resultobj;
20151 wxDateTime *arg1 = (wxDateTime *) 0 ;
20152 int arg2 ;
20153 wxDateTime *result;
20154 PyObject * obj0 = 0 ;
20155 PyObject * obj1 = 0 ;
20156 char *kwnames[] = {
20157 (char *) "self",(char *) "hour", NULL
20158 };
20159
20160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20162 if (SWIG_arg_fail(1)) SWIG_fail;
20163 {
20164 arg2 = (int)(SWIG_As_int(obj1));
20165 if (SWIG_arg_fail(2)) SWIG_fail;
20166 }
20167 {
20168 PyThreadState* __tstate = wxPyBeginAllowThreads();
20169 {
20170 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20171 result = (wxDateTime *) &_result_ref;
20172 }
20173
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20178 return resultobj;
20179 fail:
20180 return NULL;
20181 }
20182
20183
20184 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20185 PyObject *resultobj;
20186 wxDateTime *arg1 = (wxDateTime *) 0 ;
20187 int arg2 ;
20188 wxDateTime *result;
20189 PyObject * obj0 = 0 ;
20190 PyObject * obj1 = 0 ;
20191 char *kwnames[] = {
20192 (char *) "self",(char *) "minute", NULL
20193 };
20194
20195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20197 if (SWIG_arg_fail(1)) SWIG_fail;
20198 {
20199 arg2 = (int)(SWIG_As_int(obj1));
20200 if (SWIG_arg_fail(2)) SWIG_fail;
20201 }
20202 {
20203 PyThreadState* __tstate = wxPyBeginAllowThreads();
20204 {
20205 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20206 result = (wxDateTime *) &_result_ref;
20207 }
20208
20209 wxPyEndAllowThreads(__tstate);
20210 if (PyErr_Occurred()) SWIG_fail;
20211 }
20212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20213 return resultobj;
20214 fail:
20215 return NULL;
20216 }
20217
20218
20219 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20220 PyObject *resultobj;
20221 wxDateTime *arg1 = (wxDateTime *) 0 ;
20222 int arg2 ;
20223 wxDateTime *result;
20224 PyObject * obj0 = 0 ;
20225 PyObject * obj1 = 0 ;
20226 char *kwnames[] = {
20227 (char *) "self",(char *) "second", NULL
20228 };
20229
20230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20232 if (SWIG_arg_fail(1)) SWIG_fail;
20233 {
20234 arg2 = (int)(SWIG_As_int(obj1));
20235 if (SWIG_arg_fail(2)) SWIG_fail;
20236 }
20237 {
20238 PyThreadState* __tstate = wxPyBeginAllowThreads();
20239 {
20240 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20241 result = (wxDateTime *) &_result_ref;
20242 }
20243
20244 wxPyEndAllowThreads(__tstate);
20245 if (PyErr_Occurred()) SWIG_fail;
20246 }
20247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20248 return resultobj;
20249 fail:
20250 return NULL;
20251 }
20252
20253
20254 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20255 PyObject *resultobj;
20256 wxDateTime *arg1 = (wxDateTime *) 0 ;
20257 int arg2 ;
20258 wxDateTime *result;
20259 PyObject * obj0 = 0 ;
20260 PyObject * obj1 = 0 ;
20261 char *kwnames[] = {
20262 (char *) "self",(char *) "millisecond", NULL
20263 };
20264
20265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20267 if (SWIG_arg_fail(1)) SWIG_fail;
20268 {
20269 arg2 = (int)(SWIG_As_int(obj1));
20270 if (SWIG_arg_fail(2)) SWIG_fail;
20271 }
20272 {
20273 PyThreadState* __tstate = wxPyBeginAllowThreads();
20274 {
20275 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20276 result = (wxDateTime *) &_result_ref;
20277 }
20278
20279 wxPyEndAllowThreads(__tstate);
20280 if (PyErr_Occurred()) SWIG_fail;
20281 }
20282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20283 return resultobj;
20284 fail:
20285 return NULL;
20286 }
20287
20288
20289 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20290 PyObject *resultobj;
20291 wxDateTime *arg1 = (wxDateTime *) 0 ;
20292 wxDateTime::WeekDay arg2 ;
20293 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20294 wxDateTime *result;
20295 PyObject * obj0 = 0 ;
20296 PyObject * obj1 = 0 ;
20297 PyObject * obj2 = 0 ;
20298 char *kwnames[] = {
20299 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20300 };
20301
20302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20304 if (SWIG_arg_fail(1)) SWIG_fail;
20305 {
20306 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20307 if (SWIG_arg_fail(2)) SWIG_fail;
20308 }
20309 if (obj2) {
20310 {
20311 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20312 if (SWIG_arg_fail(3)) SWIG_fail;
20313 }
20314 }
20315 {
20316 PyThreadState* __tstate = wxPyBeginAllowThreads();
20317 {
20318 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20319 result = (wxDateTime *) &_result_ref;
20320 }
20321
20322 wxPyEndAllowThreads(__tstate);
20323 if (PyErr_Occurred()) SWIG_fail;
20324 }
20325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20326 return resultobj;
20327 fail:
20328 return NULL;
20329 }
20330
20331
20332 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20333 PyObject *resultobj;
20334 wxDateTime *arg1 = (wxDateTime *) 0 ;
20335 wxDateTime::WeekDay arg2 ;
20336 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20337 wxDateTime result;
20338 PyObject * obj0 = 0 ;
20339 PyObject * obj1 = 0 ;
20340 PyObject * obj2 = 0 ;
20341 char *kwnames[] = {
20342 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20343 };
20344
20345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(1)) SWIG_fail;
20348 {
20349 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20350 if (SWIG_arg_fail(2)) SWIG_fail;
20351 }
20352 if (obj2) {
20353 {
20354 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20355 if (SWIG_arg_fail(3)) SWIG_fail;
20356 }
20357 }
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20361
20362 wxPyEndAllowThreads(__tstate);
20363 if (PyErr_Occurred()) SWIG_fail;
20364 }
20365 {
20366 wxDateTime * resultptr;
20367 resultptr = new wxDateTime((wxDateTime &)(result));
20368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20369 }
20370 return resultobj;
20371 fail:
20372 return NULL;
20373 }
20374
20375
20376 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20377 PyObject *resultobj;
20378 wxDateTime *arg1 = (wxDateTime *) 0 ;
20379 wxDateTime::WeekDay arg2 ;
20380 wxDateTime *result;
20381 PyObject * obj0 = 0 ;
20382 PyObject * obj1 = 0 ;
20383 char *kwnames[] = {
20384 (char *) "self",(char *) "weekday", NULL
20385 };
20386
20387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20389 if (SWIG_arg_fail(1)) SWIG_fail;
20390 {
20391 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20392 if (SWIG_arg_fail(2)) SWIG_fail;
20393 }
20394 {
20395 PyThreadState* __tstate = wxPyBeginAllowThreads();
20396 {
20397 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20398 result = (wxDateTime *) &_result_ref;
20399 }
20400
20401 wxPyEndAllowThreads(__tstate);
20402 if (PyErr_Occurred()) SWIG_fail;
20403 }
20404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20405 return resultobj;
20406 fail:
20407 return NULL;
20408 }
20409
20410
20411 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20412 PyObject *resultobj;
20413 wxDateTime *arg1 = (wxDateTime *) 0 ;
20414 wxDateTime::WeekDay arg2 ;
20415 wxDateTime result;
20416 PyObject * obj0 = 0 ;
20417 PyObject * obj1 = 0 ;
20418 char *kwnames[] = {
20419 (char *) "self",(char *) "weekday", NULL
20420 };
20421
20422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20424 if (SWIG_arg_fail(1)) SWIG_fail;
20425 {
20426 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20427 if (SWIG_arg_fail(2)) SWIG_fail;
20428 }
20429 {
20430 PyThreadState* __tstate = wxPyBeginAllowThreads();
20431 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20432
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 {
20437 wxDateTime * resultptr;
20438 resultptr = new wxDateTime((wxDateTime &)(result));
20439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20440 }
20441 return resultobj;
20442 fail:
20443 return NULL;
20444 }
20445
20446
20447 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20448 PyObject *resultobj;
20449 wxDateTime *arg1 = (wxDateTime *) 0 ;
20450 wxDateTime::WeekDay arg2 ;
20451 wxDateTime *result;
20452 PyObject * obj0 = 0 ;
20453 PyObject * obj1 = 0 ;
20454 char *kwnames[] = {
20455 (char *) "self",(char *) "weekday", NULL
20456 };
20457
20458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20460 if (SWIG_arg_fail(1)) SWIG_fail;
20461 {
20462 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20463 if (SWIG_arg_fail(2)) SWIG_fail;
20464 }
20465 {
20466 PyThreadState* __tstate = wxPyBeginAllowThreads();
20467 {
20468 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20469 result = (wxDateTime *) &_result_ref;
20470 }
20471
20472 wxPyEndAllowThreads(__tstate);
20473 if (PyErr_Occurred()) SWIG_fail;
20474 }
20475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20476 return resultobj;
20477 fail:
20478 return NULL;
20479 }
20480
20481
20482 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20483 PyObject *resultobj;
20484 wxDateTime *arg1 = (wxDateTime *) 0 ;
20485 wxDateTime::WeekDay arg2 ;
20486 wxDateTime result;
20487 PyObject * obj0 = 0 ;
20488 PyObject * obj1 = 0 ;
20489 char *kwnames[] = {
20490 (char *) "self",(char *) "weekday", NULL
20491 };
20492
20493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20495 if (SWIG_arg_fail(1)) SWIG_fail;
20496 {
20497 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20498 if (SWIG_arg_fail(2)) SWIG_fail;
20499 }
20500 {
20501 PyThreadState* __tstate = wxPyBeginAllowThreads();
20502 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20503
20504 wxPyEndAllowThreads(__tstate);
20505 if (PyErr_Occurred()) SWIG_fail;
20506 }
20507 {
20508 wxDateTime * resultptr;
20509 resultptr = new wxDateTime((wxDateTime &)(result));
20510 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20511 }
20512 return resultobj;
20513 fail:
20514 return NULL;
20515 }
20516
20517
20518 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20519 PyObject *resultobj;
20520 wxDateTime *arg1 = (wxDateTime *) 0 ;
20521 wxDateTime::WeekDay arg2 ;
20522 int arg3 = (int) 1 ;
20523 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20524 int arg5 = (int) wxDateTime::Inv_Year ;
20525 bool result;
20526 PyObject * obj0 = 0 ;
20527 PyObject * obj1 = 0 ;
20528 PyObject * obj2 = 0 ;
20529 PyObject * obj3 = 0 ;
20530 PyObject * obj4 = 0 ;
20531 char *kwnames[] = {
20532 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20533 };
20534
20535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20537 if (SWIG_arg_fail(1)) SWIG_fail;
20538 {
20539 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20540 if (SWIG_arg_fail(2)) SWIG_fail;
20541 }
20542 if (obj2) {
20543 {
20544 arg3 = (int)(SWIG_As_int(obj2));
20545 if (SWIG_arg_fail(3)) SWIG_fail;
20546 }
20547 }
20548 if (obj3) {
20549 {
20550 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20551 if (SWIG_arg_fail(4)) SWIG_fail;
20552 }
20553 }
20554 if (obj4) {
20555 {
20556 arg5 = (int)(SWIG_As_int(obj4));
20557 if (SWIG_arg_fail(5)) SWIG_fail;
20558 }
20559 }
20560 {
20561 PyThreadState* __tstate = wxPyBeginAllowThreads();
20562 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20563
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 {
20568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20569 }
20570 return resultobj;
20571 fail:
20572 return NULL;
20573 }
20574
20575
20576 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20577 PyObject *resultobj;
20578 wxDateTime *arg1 = (wxDateTime *) 0 ;
20579 wxDateTime::WeekDay arg2 ;
20580 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20581 int arg4 = (int) wxDateTime::Inv_Year ;
20582 bool result;
20583 PyObject * obj0 = 0 ;
20584 PyObject * obj1 = 0 ;
20585 PyObject * obj2 = 0 ;
20586 PyObject * obj3 = 0 ;
20587 char *kwnames[] = {
20588 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20589 };
20590
20591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20593 if (SWIG_arg_fail(1)) SWIG_fail;
20594 {
20595 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20596 if (SWIG_arg_fail(2)) SWIG_fail;
20597 }
20598 if (obj2) {
20599 {
20600 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20601 if (SWIG_arg_fail(3)) SWIG_fail;
20602 }
20603 }
20604 if (obj3) {
20605 {
20606 arg4 = (int)(SWIG_As_int(obj3));
20607 if (SWIG_arg_fail(4)) SWIG_fail;
20608 }
20609 }
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20613
20614 wxPyEndAllowThreads(__tstate);
20615 if (PyErr_Occurred()) SWIG_fail;
20616 }
20617 {
20618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20619 }
20620 return resultobj;
20621 fail:
20622 return NULL;
20623 }
20624
20625
20626 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20627 PyObject *resultobj;
20628 wxDateTime *arg1 = (wxDateTime *) 0 ;
20629 wxDateTime::WeekDay arg2 ;
20630 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20631 int arg4 = (int) wxDateTime::Inv_Year ;
20632 wxDateTime result;
20633 PyObject * obj0 = 0 ;
20634 PyObject * obj1 = 0 ;
20635 PyObject * obj2 = 0 ;
20636 PyObject * obj3 = 0 ;
20637 char *kwnames[] = {
20638 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20639 };
20640
20641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20643 if (SWIG_arg_fail(1)) SWIG_fail;
20644 {
20645 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20646 if (SWIG_arg_fail(2)) SWIG_fail;
20647 }
20648 if (obj2) {
20649 {
20650 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20651 if (SWIG_arg_fail(3)) SWIG_fail;
20652 }
20653 }
20654 if (obj3) {
20655 {
20656 arg4 = (int)(SWIG_As_int(obj3));
20657 if (SWIG_arg_fail(4)) SWIG_fail;
20658 }
20659 }
20660 {
20661 PyThreadState* __tstate = wxPyBeginAllowThreads();
20662 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20663
20664 wxPyEndAllowThreads(__tstate);
20665 if (PyErr_Occurred()) SWIG_fail;
20666 }
20667 {
20668 wxDateTime * resultptr;
20669 resultptr = new wxDateTime((wxDateTime &)(result));
20670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20671 }
20672 return resultobj;
20673 fail:
20674 return NULL;
20675 }
20676
20677
20678 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20679 PyObject *resultobj;
20680 wxDateTime *arg1 = (wxDateTime *) 0 ;
20681 int arg2 ;
20682 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20683 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20684 bool result;
20685 PyObject * obj0 = 0 ;
20686 PyObject * obj1 = 0 ;
20687 PyObject * obj2 = 0 ;
20688 PyObject * obj3 = 0 ;
20689 char *kwnames[] = {
20690 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20691 };
20692
20693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20695 if (SWIG_arg_fail(1)) SWIG_fail;
20696 {
20697 arg2 = (int)(SWIG_As_int(obj1));
20698 if (SWIG_arg_fail(2)) SWIG_fail;
20699 }
20700 if (obj2) {
20701 {
20702 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20703 if (SWIG_arg_fail(3)) SWIG_fail;
20704 }
20705 }
20706 if (obj3) {
20707 {
20708 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20709 if (SWIG_arg_fail(4)) SWIG_fail;
20710 }
20711 }
20712 {
20713 PyThreadState* __tstate = wxPyBeginAllowThreads();
20714 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20715
20716 wxPyEndAllowThreads(__tstate);
20717 if (PyErr_Occurred()) SWIG_fail;
20718 }
20719 {
20720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20721 }
20722 return resultobj;
20723 fail:
20724 return NULL;
20725 }
20726
20727
20728 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20729 PyObject *resultobj;
20730 wxDateTime *arg1 = (wxDateTime *) 0 ;
20731 int arg2 ;
20732 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20733 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20734 wxDateTime result;
20735 PyObject * obj0 = 0 ;
20736 PyObject * obj1 = 0 ;
20737 PyObject * obj2 = 0 ;
20738 PyObject * obj3 = 0 ;
20739 char *kwnames[] = {
20740 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20741 };
20742
20743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20745 if (SWIG_arg_fail(1)) SWIG_fail;
20746 {
20747 arg2 = (int)(SWIG_As_int(obj1));
20748 if (SWIG_arg_fail(2)) SWIG_fail;
20749 }
20750 if (obj2) {
20751 {
20752 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20753 if (SWIG_arg_fail(3)) SWIG_fail;
20754 }
20755 }
20756 if (obj3) {
20757 {
20758 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20759 if (SWIG_arg_fail(4)) SWIG_fail;
20760 }
20761 }
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20765
20766 wxPyEndAllowThreads(__tstate);
20767 if (PyErr_Occurred()) SWIG_fail;
20768 }
20769 {
20770 wxDateTime * resultptr;
20771 resultptr = new wxDateTime((wxDateTime &)(result));
20772 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20773 }
20774 return resultobj;
20775 fail:
20776 return NULL;
20777 }
20778
20779
20780 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20781 PyObject *resultobj;
20782 int arg1 ;
20783 int arg2 ;
20784 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20785 wxDateTime result;
20786 PyObject * obj0 = 0 ;
20787 PyObject * obj1 = 0 ;
20788 PyObject * obj2 = 0 ;
20789 char *kwnames[] = {
20790 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20791 };
20792
20793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20794 {
20795 arg1 = (int)(SWIG_As_int(obj0));
20796 if (SWIG_arg_fail(1)) SWIG_fail;
20797 }
20798 {
20799 arg2 = (int)(SWIG_As_int(obj1));
20800 if (SWIG_arg_fail(2)) SWIG_fail;
20801 }
20802 if (obj2) {
20803 {
20804 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20805 if (SWIG_arg_fail(3)) SWIG_fail;
20806 }
20807 }
20808 {
20809 PyThreadState* __tstate = wxPyBeginAllowThreads();
20810 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20811
20812 wxPyEndAllowThreads(__tstate);
20813 if (PyErr_Occurred()) SWIG_fail;
20814 }
20815 {
20816 wxDateTime * resultptr;
20817 resultptr = new wxDateTime((wxDateTime &)(result));
20818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20819 }
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj;
20828 wxDateTime *arg1 = (wxDateTime *) 0 ;
20829 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20830 int arg3 = (int) wxDateTime::Inv_Year ;
20831 wxDateTime *result;
20832 PyObject * obj0 = 0 ;
20833 PyObject * obj1 = 0 ;
20834 PyObject * obj2 = 0 ;
20835 char *kwnames[] = {
20836 (char *) "self",(char *) "month",(char *) "year", NULL
20837 };
20838
20839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20841 if (SWIG_arg_fail(1)) SWIG_fail;
20842 if (obj1) {
20843 {
20844 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20845 if (SWIG_arg_fail(2)) SWIG_fail;
20846 }
20847 }
20848 if (obj2) {
20849 {
20850 arg3 = (int)(SWIG_As_int(obj2));
20851 if (SWIG_arg_fail(3)) SWIG_fail;
20852 }
20853 }
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 {
20857 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20858 result = (wxDateTime *) &_result_ref;
20859 }
20860
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20872 PyObject *resultobj;
20873 wxDateTime *arg1 = (wxDateTime *) 0 ;
20874 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20875 int arg3 = (int) wxDateTime::Inv_Year ;
20876 wxDateTime result;
20877 PyObject * obj0 = 0 ;
20878 PyObject * obj1 = 0 ;
20879 PyObject * obj2 = 0 ;
20880 char *kwnames[] = {
20881 (char *) "self",(char *) "month",(char *) "year", NULL
20882 };
20883
20884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20886 if (SWIG_arg_fail(1)) SWIG_fail;
20887 if (obj1) {
20888 {
20889 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20890 if (SWIG_arg_fail(2)) SWIG_fail;
20891 }
20892 }
20893 if (obj2) {
20894 {
20895 arg3 = (int)(SWIG_As_int(obj2));
20896 if (SWIG_arg_fail(3)) SWIG_fail;
20897 }
20898 }
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20902
20903 wxPyEndAllowThreads(__tstate);
20904 if (PyErr_Occurred()) SWIG_fail;
20905 }
20906 {
20907 wxDateTime * resultptr;
20908 resultptr = new wxDateTime((wxDateTime &)(result));
20909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20910 }
20911 return resultobj;
20912 fail:
20913 return NULL;
20914 }
20915
20916
20917 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20918 PyObject *resultobj;
20919 wxDateTime *arg1 = (wxDateTime *) 0 ;
20920 int arg2 ;
20921 wxDateTime *result;
20922 PyObject * obj0 = 0 ;
20923 PyObject * obj1 = 0 ;
20924 char *kwnames[] = {
20925 (char *) "self",(char *) "yday", NULL
20926 };
20927
20928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20930 if (SWIG_arg_fail(1)) SWIG_fail;
20931 {
20932 arg2 = (int)(SWIG_As_int(obj1));
20933 if (SWIG_arg_fail(2)) SWIG_fail;
20934 }
20935 {
20936 PyThreadState* __tstate = wxPyBeginAllowThreads();
20937 {
20938 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20939 result = (wxDateTime *) &_result_ref;
20940 }
20941
20942 wxPyEndAllowThreads(__tstate);
20943 if (PyErr_Occurred()) SWIG_fail;
20944 }
20945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20953 PyObject *resultobj;
20954 wxDateTime *arg1 = (wxDateTime *) 0 ;
20955 int arg2 ;
20956 wxDateTime result;
20957 PyObject * obj0 = 0 ;
20958 PyObject * obj1 = 0 ;
20959 char *kwnames[] = {
20960 (char *) "self",(char *) "yday", NULL
20961 };
20962
20963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20965 if (SWIG_arg_fail(1)) SWIG_fail;
20966 {
20967 arg2 = (int)(SWIG_As_int(obj1));
20968 if (SWIG_arg_fail(2)) SWIG_fail;
20969 }
20970 {
20971 PyThreadState* __tstate = wxPyBeginAllowThreads();
20972 result = (arg1)->GetYearDay(arg2);
20973
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 {
20978 wxDateTime * resultptr;
20979 resultptr = new wxDateTime((wxDateTime &)(result));
20980 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20981 }
20982 return resultobj;
20983 fail:
20984 return NULL;
20985 }
20986
20987
20988 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20989 PyObject *resultobj;
20990 wxDateTime *arg1 = (wxDateTime *) 0 ;
20991 double result;
20992 PyObject * obj0 = 0 ;
20993 char *kwnames[] = {
20994 (char *) "self", NULL
20995 };
20996
20997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20999 if (SWIG_arg_fail(1)) SWIG_fail;
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 result = (double)(arg1)->GetJulianDayNumber();
21003
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 {
21008 resultobj = SWIG_From_double((double)(result));
21009 }
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21017 PyObject *resultobj;
21018 wxDateTime *arg1 = (wxDateTime *) 0 ;
21019 double result;
21020 PyObject * obj0 = 0 ;
21021 char *kwnames[] = {
21022 (char *) "self", NULL
21023 };
21024
21025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21027 if (SWIG_arg_fail(1)) SWIG_fail;
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 result = (double)(arg1)->GetJDN();
21031
21032 wxPyEndAllowThreads(__tstate);
21033 if (PyErr_Occurred()) SWIG_fail;
21034 }
21035 {
21036 resultobj = SWIG_From_double((double)(result));
21037 }
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21045 PyObject *resultobj;
21046 wxDateTime *arg1 = (wxDateTime *) 0 ;
21047 double result;
21048 PyObject * obj0 = 0 ;
21049 char *kwnames[] = {
21050 (char *) "self", NULL
21051 };
21052
21053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21055 if (SWIG_arg_fail(1)) SWIG_fail;
21056 {
21057 PyThreadState* __tstate = wxPyBeginAllowThreads();
21058 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21059
21060 wxPyEndAllowThreads(__tstate);
21061 if (PyErr_Occurred()) SWIG_fail;
21062 }
21063 {
21064 resultobj = SWIG_From_double((double)(result));
21065 }
21066 return resultobj;
21067 fail:
21068 return NULL;
21069 }
21070
21071
21072 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21073 PyObject *resultobj;
21074 wxDateTime *arg1 = (wxDateTime *) 0 ;
21075 double result;
21076 PyObject * obj0 = 0 ;
21077 char *kwnames[] = {
21078 (char *) "self", NULL
21079 };
21080
21081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21083 if (SWIG_arg_fail(1)) SWIG_fail;
21084 {
21085 PyThreadState* __tstate = wxPyBeginAllowThreads();
21086 result = (double)(arg1)->GetMJD();
21087
21088 wxPyEndAllowThreads(__tstate);
21089 if (PyErr_Occurred()) SWIG_fail;
21090 }
21091 {
21092 resultobj = SWIG_From_double((double)(result));
21093 }
21094 return resultobj;
21095 fail:
21096 return NULL;
21097 }
21098
21099
21100 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21101 PyObject *resultobj;
21102 wxDateTime *arg1 = (wxDateTime *) 0 ;
21103 double result;
21104 PyObject * obj0 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "self", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21111 if (SWIG_arg_fail(1)) SWIG_fail;
21112 {
21113 PyThreadState* __tstate = wxPyBeginAllowThreads();
21114 result = (double)(arg1)->GetRataDie();
21115
21116 wxPyEndAllowThreads(__tstate);
21117 if (PyErr_Occurred()) SWIG_fail;
21118 }
21119 {
21120 resultobj = SWIG_From_double((double)(result));
21121 }
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21129 PyObject *resultobj;
21130 wxDateTime *arg1 = (wxDateTime *) 0 ;
21131 wxDateTime::TimeZone *arg2 = 0 ;
21132 bool arg3 = (bool) false ;
21133 wxDateTime result;
21134 bool temp2 = false ;
21135 PyObject * obj0 = 0 ;
21136 PyObject * obj1 = 0 ;
21137 PyObject * obj2 = 0 ;
21138 char *kwnames[] = {
21139 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21140 };
21141
21142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21144 if (SWIG_arg_fail(1)) SWIG_fail;
21145 {
21146 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21147 temp2 = true;
21148 }
21149 if (obj2) {
21150 {
21151 arg3 = (bool)(SWIG_As_bool(obj2));
21152 if (SWIG_arg_fail(3)) SWIG_fail;
21153 }
21154 }
21155 {
21156 PyThreadState* __tstate = wxPyBeginAllowThreads();
21157 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21158
21159 wxPyEndAllowThreads(__tstate);
21160 if (PyErr_Occurred()) SWIG_fail;
21161 }
21162 {
21163 wxDateTime * resultptr;
21164 resultptr = new wxDateTime((wxDateTime &)(result));
21165 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21166 }
21167 {
21168 if (temp2) delete arg2;
21169 }
21170 return resultobj;
21171 fail:
21172 {
21173 if (temp2) delete arg2;
21174 }
21175 return NULL;
21176 }
21177
21178
21179 static PyObject *_wrap_DateTime_MakeTimezone(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_MakeTimezone",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 {
21209 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21210 result = (wxDateTime *) &_result_ref;
21211 }
21212
21213 wxPyEndAllowThreads(__tstate);
21214 if (PyErr_Occurred()) SWIG_fail;
21215 }
21216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21217 {
21218 if (temp2) delete arg2;
21219 }
21220 return resultobj;
21221 fail:
21222 {
21223 if (temp2) delete arg2;
21224 }
21225 return NULL;
21226 }
21227
21228
21229 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21230 PyObject *resultobj;
21231 wxDateTime *arg1 = (wxDateTime *) 0 ;
21232 bool arg2 = (bool) false ;
21233 wxDateTime result;
21234 PyObject * obj0 = 0 ;
21235 PyObject * obj1 = 0 ;
21236 char *kwnames[] = {
21237 (char *) "self",(char *) "noDST", NULL
21238 };
21239
21240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21242 if (SWIG_arg_fail(1)) SWIG_fail;
21243 if (obj1) {
21244 {
21245 arg2 = (bool)(SWIG_As_bool(obj1));
21246 if (SWIG_arg_fail(2)) SWIG_fail;
21247 }
21248 }
21249 {
21250 PyThreadState* __tstate = wxPyBeginAllowThreads();
21251 result = (arg1)->ToGMT(arg2);
21252
21253 wxPyEndAllowThreads(__tstate);
21254 if (PyErr_Occurred()) SWIG_fail;
21255 }
21256 {
21257 wxDateTime * resultptr;
21258 resultptr = new wxDateTime((wxDateTime &)(result));
21259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21260 }
21261 return resultobj;
21262 fail:
21263 return NULL;
21264 }
21265
21266
21267 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21268 PyObject *resultobj;
21269 wxDateTime *arg1 = (wxDateTime *) 0 ;
21270 bool arg2 = (bool) false ;
21271 wxDateTime *result;
21272 PyObject * obj0 = 0 ;
21273 PyObject * obj1 = 0 ;
21274 char *kwnames[] = {
21275 (char *) "self",(char *) "noDST", NULL
21276 };
21277
21278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21280 if (SWIG_arg_fail(1)) SWIG_fail;
21281 if (obj1) {
21282 {
21283 arg2 = (bool)(SWIG_As_bool(obj1));
21284 if (SWIG_arg_fail(2)) SWIG_fail;
21285 }
21286 }
21287 {
21288 PyThreadState* __tstate = wxPyBeginAllowThreads();
21289 {
21290 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21291 result = (wxDateTime *) &_result_ref;
21292 }
21293
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21298 return resultobj;
21299 fail:
21300 return NULL;
21301 }
21302
21303
21304 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21305 PyObject *resultobj;
21306 wxDateTime *arg1 = (wxDateTime *) 0 ;
21307 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21308 int result;
21309 PyObject * obj0 = 0 ;
21310 PyObject * obj1 = 0 ;
21311 char *kwnames[] = {
21312 (char *) "self",(char *) "country", NULL
21313 };
21314
21315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21317 if (SWIG_arg_fail(1)) SWIG_fail;
21318 if (obj1) {
21319 {
21320 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21321 if (SWIG_arg_fail(2)) SWIG_fail;
21322 }
21323 }
21324 {
21325 PyThreadState* __tstate = wxPyBeginAllowThreads();
21326 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21327
21328 wxPyEndAllowThreads(__tstate);
21329 if (PyErr_Occurred()) SWIG_fail;
21330 }
21331 {
21332 resultobj = SWIG_From_int((int)(result));
21333 }
21334 return resultobj;
21335 fail:
21336 return NULL;
21337 }
21338
21339
21340 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21341 PyObject *resultobj;
21342 wxDateTime *arg1 = (wxDateTime *) 0 ;
21343 bool result;
21344 PyObject * obj0 = 0 ;
21345 char *kwnames[] = {
21346 (char *) "self", NULL
21347 };
21348
21349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21351 if (SWIG_arg_fail(1)) SWIG_fail;
21352 {
21353 PyThreadState* __tstate = wxPyBeginAllowThreads();
21354 result = (bool)((wxDateTime const *)arg1)->IsValid();
21355
21356 wxPyEndAllowThreads(__tstate);
21357 if (PyErr_Occurred()) SWIG_fail;
21358 }
21359 {
21360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21361 }
21362 return resultobj;
21363 fail:
21364 return NULL;
21365 }
21366
21367
21368 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21369 PyObject *resultobj;
21370 wxDateTime *arg1 = (wxDateTime *) 0 ;
21371 time_t result;
21372 PyObject * obj0 = 0 ;
21373 char *kwnames[] = {
21374 (char *) "self", NULL
21375 };
21376
21377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21379 if (SWIG_arg_fail(1)) SWIG_fail;
21380 {
21381 PyThreadState* __tstate = wxPyBeginAllowThreads();
21382 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21383
21384 wxPyEndAllowThreads(__tstate);
21385 if (PyErr_Occurred()) SWIG_fail;
21386 }
21387 {
21388 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21389 }
21390 return resultobj;
21391 fail:
21392 return NULL;
21393 }
21394
21395
21396 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21397 PyObject *resultobj;
21398 wxDateTime *arg1 = (wxDateTime *) 0 ;
21399 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21400 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21401 int result;
21402 bool temp2 = false ;
21403 PyObject * obj0 = 0 ;
21404 PyObject * obj1 = 0 ;
21405 char *kwnames[] = {
21406 (char *) "self",(char *) "tz", NULL
21407 };
21408
21409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21411 if (SWIG_arg_fail(1)) SWIG_fail;
21412 if (obj1) {
21413 {
21414 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21415 temp2 = true;
21416 }
21417 }
21418 {
21419 PyThreadState* __tstate = wxPyBeginAllowThreads();
21420 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21421
21422 wxPyEndAllowThreads(__tstate);
21423 if (PyErr_Occurred()) SWIG_fail;
21424 }
21425 {
21426 resultobj = SWIG_From_int((int)(result));
21427 }
21428 {
21429 if (temp2) delete arg2;
21430 }
21431 return resultobj;
21432 fail:
21433 {
21434 if (temp2) delete arg2;
21435 }
21436 return NULL;
21437 }
21438
21439
21440 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21441 PyObject *resultobj;
21442 wxDateTime *arg1 = (wxDateTime *) 0 ;
21443 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21444 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21445 wxDateTime::Month result;
21446 bool temp2 = false ;
21447 PyObject * obj0 = 0 ;
21448 PyObject * obj1 = 0 ;
21449 char *kwnames[] = {
21450 (char *) "self",(char *) "tz", NULL
21451 };
21452
21453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21455 if (SWIG_arg_fail(1)) SWIG_fail;
21456 if (obj1) {
21457 {
21458 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21459 temp2 = true;
21460 }
21461 }
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21465
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 resultobj = SWIG_From_int((result));
21470 {
21471 if (temp2) delete arg2;
21472 }
21473 return resultobj;
21474 fail:
21475 {
21476 if (temp2) delete arg2;
21477 }
21478 return NULL;
21479 }
21480
21481
21482 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21483 PyObject *resultobj;
21484 wxDateTime *arg1 = (wxDateTime *) 0 ;
21485 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21486 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21487 int result;
21488 bool temp2 = false ;
21489 PyObject * obj0 = 0 ;
21490 PyObject * obj1 = 0 ;
21491 char *kwnames[] = {
21492 (char *) "self",(char *) "tz", NULL
21493 };
21494
21495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21497 if (SWIG_arg_fail(1)) SWIG_fail;
21498 if (obj1) {
21499 {
21500 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21501 temp2 = true;
21502 }
21503 }
21504 {
21505 PyThreadState* __tstate = wxPyBeginAllowThreads();
21506 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21507
21508 wxPyEndAllowThreads(__tstate);
21509 if (PyErr_Occurred()) SWIG_fail;
21510 }
21511 {
21512 resultobj = SWIG_From_int((int)(result));
21513 }
21514 {
21515 if (temp2) delete arg2;
21516 }
21517 return resultobj;
21518 fail:
21519 {
21520 if (temp2) delete arg2;
21521 }
21522 return NULL;
21523 }
21524
21525
21526 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21527 PyObject *resultobj;
21528 wxDateTime *arg1 = (wxDateTime *) 0 ;
21529 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21530 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21531 wxDateTime::WeekDay result;
21532 bool temp2 = false ;
21533 PyObject * obj0 = 0 ;
21534 PyObject * obj1 = 0 ;
21535 char *kwnames[] = {
21536 (char *) "self",(char *) "tz", NULL
21537 };
21538
21539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21541 if (SWIG_arg_fail(1)) SWIG_fail;
21542 if (obj1) {
21543 {
21544 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21545 temp2 = true;
21546 }
21547 }
21548 {
21549 PyThreadState* __tstate = wxPyBeginAllowThreads();
21550 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21551
21552 wxPyEndAllowThreads(__tstate);
21553 if (PyErr_Occurred()) SWIG_fail;
21554 }
21555 resultobj = SWIG_From_int((result));
21556 {
21557 if (temp2) delete arg2;
21558 }
21559 return resultobj;
21560 fail:
21561 {
21562 if (temp2) delete arg2;
21563 }
21564 return NULL;
21565 }
21566
21567
21568 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21569 PyObject *resultobj;
21570 wxDateTime *arg1 = (wxDateTime *) 0 ;
21571 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21572 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21573 int result;
21574 bool temp2 = false ;
21575 PyObject * obj0 = 0 ;
21576 PyObject * obj1 = 0 ;
21577 char *kwnames[] = {
21578 (char *) "self",(char *) "tz", NULL
21579 };
21580
21581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21583 if (SWIG_arg_fail(1)) SWIG_fail;
21584 if (obj1) {
21585 {
21586 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21587 temp2 = true;
21588 }
21589 }
21590 {
21591 PyThreadState* __tstate = wxPyBeginAllowThreads();
21592 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21593
21594 wxPyEndAllowThreads(__tstate);
21595 if (PyErr_Occurred()) SWIG_fail;
21596 }
21597 {
21598 resultobj = SWIG_From_int((int)(result));
21599 }
21600 {
21601 if (temp2) delete arg2;
21602 }
21603 return resultobj;
21604 fail:
21605 {
21606 if (temp2) delete arg2;
21607 }
21608 return NULL;
21609 }
21610
21611
21612 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21613 PyObject *resultobj;
21614 wxDateTime *arg1 = (wxDateTime *) 0 ;
21615 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21616 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21617 int result;
21618 bool temp2 = false ;
21619 PyObject * obj0 = 0 ;
21620 PyObject * obj1 = 0 ;
21621 char *kwnames[] = {
21622 (char *) "self",(char *) "tz", NULL
21623 };
21624
21625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21627 if (SWIG_arg_fail(1)) SWIG_fail;
21628 if (obj1) {
21629 {
21630 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21631 temp2 = true;
21632 }
21633 }
21634 {
21635 PyThreadState* __tstate = wxPyBeginAllowThreads();
21636 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21637
21638 wxPyEndAllowThreads(__tstate);
21639 if (PyErr_Occurred()) SWIG_fail;
21640 }
21641 {
21642 resultobj = SWIG_From_int((int)(result));
21643 }
21644 {
21645 if (temp2) delete arg2;
21646 }
21647 return resultobj;
21648 fail:
21649 {
21650 if (temp2) delete arg2;
21651 }
21652 return NULL;
21653 }
21654
21655
21656 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21657 PyObject *resultobj;
21658 wxDateTime *arg1 = (wxDateTime *) 0 ;
21659 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21660 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21661 int result;
21662 bool temp2 = false ;
21663 PyObject * obj0 = 0 ;
21664 PyObject * obj1 = 0 ;
21665 char *kwnames[] = {
21666 (char *) "self",(char *) "tz", NULL
21667 };
21668
21669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21671 if (SWIG_arg_fail(1)) SWIG_fail;
21672 if (obj1) {
21673 {
21674 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21675 temp2 = true;
21676 }
21677 }
21678 {
21679 PyThreadState* __tstate = wxPyBeginAllowThreads();
21680 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21681
21682 wxPyEndAllowThreads(__tstate);
21683 if (PyErr_Occurred()) SWIG_fail;
21684 }
21685 {
21686 resultobj = SWIG_From_int((int)(result));
21687 }
21688 {
21689 if (temp2) delete arg2;
21690 }
21691 return resultobj;
21692 fail:
21693 {
21694 if (temp2) delete arg2;
21695 }
21696 return NULL;
21697 }
21698
21699
21700 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21701 PyObject *resultobj;
21702 wxDateTime *arg1 = (wxDateTime *) 0 ;
21703 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21704 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21705 int result;
21706 bool temp2 = false ;
21707 PyObject * obj0 = 0 ;
21708 PyObject * obj1 = 0 ;
21709 char *kwnames[] = {
21710 (char *) "self",(char *) "tz", NULL
21711 };
21712
21713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21715 if (SWIG_arg_fail(1)) SWIG_fail;
21716 if (obj1) {
21717 {
21718 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21719 temp2 = true;
21720 }
21721 }
21722 {
21723 PyThreadState* __tstate = wxPyBeginAllowThreads();
21724 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21725
21726 wxPyEndAllowThreads(__tstate);
21727 if (PyErr_Occurred()) SWIG_fail;
21728 }
21729 {
21730 resultobj = SWIG_From_int((int)(result));
21731 }
21732 {
21733 if (temp2) delete arg2;
21734 }
21735 return resultobj;
21736 fail:
21737 {
21738 if (temp2) delete arg2;
21739 }
21740 return NULL;
21741 }
21742
21743
21744 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj;
21746 wxDateTime *arg1 = (wxDateTime *) 0 ;
21747 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21748 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21749 int result;
21750 bool temp2 = false ;
21751 PyObject * obj0 = 0 ;
21752 PyObject * obj1 = 0 ;
21753 char *kwnames[] = {
21754 (char *) "self",(char *) "tz", NULL
21755 };
21756
21757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21759 if (SWIG_arg_fail(1)) SWIG_fail;
21760 if (obj1) {
21761 {
21762 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21763 temp2 = true;
21764 }
21765 }
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21769
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 {
21774 resultobj = SWIG_From_int((int)(result));
21775 }
21776 {
21777 if (temp2) delete arg2;
21778 }
21779 return resultobj;
21780 fail:
21781 {
21782 if (temp2) delete arg2;
21783 }
21784 return NULL;
21785 }
21786
21787
21788 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21789 PyObject *resultobj;
21790 wxDateTime *arg1 = (wxDateTime *) 0 ;
21791 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21792 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21793 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21794 int result;
21795 bool temp3 = false ;
21796 PyObject * obj0 = 0 ;
21797 PyObject * obj1 = 0 ;
21798 PyObject * obj2 = 0 ;
21799 char *kwnames[] = {
21800 (char *) "self",(char *) "flags",(char *) "tz", NULL
21801 };
21802
21803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21805 if (SWIG_arg_fail(1)) SWIG_fail;
21806 if (obj1) {
21807 {
21808 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21809 if (SWIG_arg_fail(2)) SWIG_fail;
21810 }
21811 }
21812 if (obj2) {
21813 {
21814 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21815 temp3 = true;
21816 }
21817 }
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 {
21826 resultobj = SWIG_From_int((int)(result));
21827 }
21828 {
21829 if (temp3) delete arg3;
21830 }
21831 return resultobj;
21832 fail:
21833 {
21834 if (temp3) delete arg3;
21835 }
21836 return NULL;
21837 }
21838
21839
21840 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21841 PyObject *resultobj;
21842 wxDateTime *arg1 = (wxDateTime *) 0 ;
21843 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21844 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21845 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21846 int result;
21847 bool temp3 = false ;
21848 PyObject * obj0 = 0 ;
21849 PyObject * obj1 = 0 ;
21850 PyObject * obj2 = 0 ;
21851 char *kwnames[] = {
21852 (char *) "self",(char *) "flags",(char *) "tz", NULL
21853 };
21854
21855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21857 if (SWIG_arg_fail(1)) SWIG_fail;
21858 if (obj1) {
21859 {
21860 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21861 if (SWIG_arg_fail(2)) SWIG_fail;
21862 }
21863 }
21864 if (obj2) {
21865 {
21866 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21867 temp3 = true;
21868 }
21869 }
21870 {
21871 PyThreadState* __tstate = wxPyBeginAllowThreads();
21872 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21873
21874 wxPyEndAllowThreads(__tstate);
21875 if (PyErr_Occurred()) SWIG_fail;
21876 }
21877 {
21878 resultobj = SWIG_From_int((int)(result));
21879 }
21880 {
21881 if (temp3) delete arg3;
21882 }
21883 return resultobj;
21884 fail:
21885 {
21886 if (temp3) delete arg3;
21887 }
21888 return NULL;
21889 }
21890
21891
21892 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21893 PyObject *resultobj;
21894 wxDateTime *arg1 = (wxDateTime *) 0 ;
21895 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21896 bool result;
21897 PyObject * obj0 = 0 ;
21898 PyObject * obj1 = 0 ;
21899 char *kwnames[] = {
21900 (char *) "self",(char *) "country", NULL
21901 };
21902
21903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21905 if (SWIG_arg_fail(1)) SWIG_fail;
21906 if (obj1) {
21907 {
21908 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21909 if (SWIG_arg_fail(2)) SWIG_fail;
21910 }
21911 }
21912 {
21913 PyThreadState* __tstate = wxPyBeginAllowThreads();
21914 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21915
21916 wxPyEndAllowThreads(__tstate);
21917 if (PyErr_Occurred()) SWIG_fail;
21918 }
21919 {
21920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21921 }
21922 return resultobj;
21923 fail:
21924 return NULL;
21925 }
21926
21927
21928 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21929 PyObject *resultobj;
21930 wxDateTime *arg1 = (wxDateTime *) 0 ;
21931 wxDateTime *arg2 = 0 ;
21932 bool result;
21933 PyObject * obj0 = 0 ;
21934 PyObject * obj1 = 0 ;
21935 char *kwnames[] = {
21936 (char *) "self",(char *) "datetime", NULL
21937 };
21938
21939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21941 if (SWIG_arg_fail(1)) SWIG_fail;
21942 {
21943 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21944 if (SWIG_arg_fail(2)) SWIG_fail;
21945 if (arg2 == NULL) {
21946 SWIG_null_ref("wxDateTime");
21947 }
21948 if (SWIG_arg_fail(2)) SWIG_fail;
21949 }
21950 {
21951 PyThreadState* __tstate = wxPyBeginAllowThreads();
21952 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21953
21954 wxPyEndAllowThreads(__tstate);
21955 if (PyErr_Occurred()) SWIG_fail;
21956 }
21957 {
21958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21959 }
21960 return resultobj;
21961 fail:
21962 return NULL;
21963 }
21964
21965
21966 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21967 PyObject *resultobj;
21968 wxDateTime *arg1 = (wxDateTime *) 0 ;
21969 wxDateTime *arg2 = 0 ;
21970 bool result;
21971 PyObject * obj0 = 0 ;
21972 PyObject * obj1 = 0 ;
21973 char *kwnames[] = {
21974 (char *) "self",(char *) "datetime", NULL
21975 };
21976
21977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21979 if (SWIG_arg_fail(1)) SWIG_fail;
21980 {
21981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21982 if (SWIG_arg_fail(2)) SWIG_fail;
21983 if (arg2 == NULL) {
21984 SWIG_null_ref("wxDateTime");
21985 }
21986 if (SWIG_arg_fail(2)) SWIG_fail;
21987 }
21988 {
21989 PyThreadState* __tstate = wxPyBeginAllowThreads();
21990 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21991
21992 wxPyEndAllowThreads(__tstate);
21993 if (PyErr_Occurred()) SWIG_fail;
21994 }
21995 {
21996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21997 }
21998 return resultobj;
21999 fail:
22000 return NULL;
22001 }
22002
22003
22004 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22005 PyObject *resultobj;
22006 wxDateTime *arg1 = (wxDateTime *) 0 ;
22007 wxDateTime *arg2 = 0 ;
22008 bool result;
22009 PyObject * obj0 = 0 ;
22010 PyObject * obj1 = 0 ;
22011 char *kwnames[] = {
22012 (char *) "self",(char *) "datetime", NULL
22013 };
22014
22015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22017 if (SWIG_arg_fail(1)) SWIG_fail;
22018 {
22019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22020 if (SWIG_arg_fail(2)) SWIG_fail;
22021 if (arg2 == NULL) {
22022 SWIG_null_ref("wxDateTime");
22023 }
22024 if (SWIG_arg_fail(2)) SWIG_fail;
22025 }
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22029
22030 wxPyEndAllowThreads(__tstate);
22031 if (PyErr_Occurred()) SWIG_fail;
22032 }
22033 {
22034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22035 }
22036 return resultobj;
22037 fail:
22038 return NULL;
22039 }
22040
22041
22042 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22043 PyObject *resultobj;
22044 wxDateTime *arg1 = (wxDateTime *) 0 ;
22045 wxDateTime *arg2 = 0 ;
22046 wxDateTime *arg3 = 0 ;
22047 bool result;
22048 PyObject * obj0 = 0 ;
22049 PyObject * obj1 = 0 ;
22050 PyObject * obj2 = 0 ;
22051 char *kwnames[] = {
22052 (char *) "self",(char *) "t1",(char *) "t2", NULL
22053 };
22054
22055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22057 if (SWIG_arg_fail(1)) SWIG_fail;
22058 {
22059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22060 if (SWIG_arg_fail(2)) SWIG_fail;
22061 if (arg2 == NULL) {
22062 SWIG_null_ref("wxDateTime");
22063 }
22064 if (SWIG_arg_fail(2)) SWIG_fail;
22065 }
22066 {
22067 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22068 if (SWIG_arg_fail(3)) SWIG_fail;
22069 if (arg3 == NULL) {
22070 SWIG_null_ref("wxDateTime");
22071 }
22072 if (SWIG_arg_fail(3)) SWIG_fail;
22073 }
22074 {
22075 PyThreadState* __tstate = wxPyBeginAllowThreads();
22076 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22077
22078 wxPyEndAllowThreads(__tstate);
22079 if (PyErr_Occurred()) SWIG_fail;
22080 }
22081 {
22082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22083 }
22084 return resultobj;
22085 fail:
22086 return NULL;
22087 }
22088
22089
22090 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22091 PyObject *resultobj;
22092 wxDateTime *arg1 = (wxDateTime *) 0 ;
22093 wxDateTime *arg2 = 0 ;
22094 wxDateTime *arg3 = 0 ;
22095 bool result;
22096 PyObject * obj0 = 0 ;
22097 PyObject * obj1 = 0 ;
22098 PyObject * obj2 = 0 ;
22099 char *kwnames[] = {
22100 (char *) "self",(char *) "t1",(char *) "t2", NULL
22101 };
22102
22103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22105 if (SWIG_arg_fail(1)) SWIG_fail;
22106 {
22107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22108 if (SWIG_arg_fail(2)) SWIG_fail;
22109 if (arg2 == NULL) {
22110 SWIG_null_ref("wxDateTime");
22111 }
22112 if (SWIG_arg_fail(2)) SWIG_fail;
22113 }
22114 {
22115 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22116 if (SWIG_arg_fail(3)) SWIG_fail;
22117 if (arg3 == NULL) {
22118 SWIG_null_ref("wxDateTime");
22119 }
22120 if (SWIG_arg_fail(3)) SWIG_fail;
22121 }
22122 {
22123 PyThreadState* __tstate = wxPyBeginAllowThreads();
22124 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22125
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 {
22130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22131 }
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22139 PyObject *resultobj;
22140 wxDateTime *arg1 = (wxDateTime *) 0 ;
22141 wxDateTime *arg2 = 0 ;
22142 bool result;
22143 PyObject * obj0 = 0 ;
22144 PyObject * obj1 = 0 ;
22145 char *kwnames[] = {
22146 (char *) "self",(char *) "dt", NULL
22147 };
22148
22149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22151 if (SWIG_arg_fail(1)) SWIG_fail;
22152 {
22153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22154 if (SWIG_arg_fail(2)) SWIG_fail;
22155 if (arg2 == NULL) {
22156 SWIG_null_ref("wxDateTime");
22157 }
22158 if (SWIG_arg_fail(2)) SWIG_fail;
22159 }
22160 {
22161 PyThreadState* __tstate = wxPyBeginAllowThreads();
22162 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22163
22164 wxPyEndAllowThreads(__tstate);
22165 if (PyErr_Occurred()) SWIG_fail;
22166 }
22167 {
22168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22169 }
22170 return resultobj;
22171 fail:
22172 return NULL;
22173 }
22174
22175
22176 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22177 PyObject *resultobj;
22178 wxDateTime *arg1 = (wxDateTime *) 0 ;
22179 wxDateTime *arg2 = 0 ;
22180 bool result;
22181 PyObject * obj0 = 0 ;
22182 PyObject * obj1 = 0 ;
22183 char *kwnames[] = {
22184 (char *) "self",(char *) "dt", NULL
22185 };
22186
22187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22189 if (SWIG_arg_fail(1)) SWIG_fail;
22190 {
22191 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22192 if (SWIG_arg_fail(2)) SWIG_fail;
22193 if (arg2 == NULL) {
22194 SWIG_null_ref("wxDateTime");
22195 }
22196 if (SWIG_arg_fail(2)) SWIG_fail;
22197 }
22198 {
22199 PyThreadState* __tstate = wxPyBeginAllowThreads();
22200 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22201
22202 wxPyEndAllowThreads(__tstate);
22203 if (PyErr_Occurred()) SWIG_fail;
22204 }
22205 {
22206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22207 }
22208 return resultobj;
22209 fail:
22210 return NULL;
22211 }
22212
22213
22214 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22215 PyObject *resultobj;
22216 wxDateTime *arg1 = (wxDateTime *) 0 ;
22217 wxDateTime *arg2 = 0 ;
22218 wxTimeSpan *arg3 = 0 ;
22219 bool result;
22220 PyObject * obj0 = 0 ;
22221 PyObject * obj1 = 0 ;
22222 PyObject * obj2 = 0 ;
22223 char *kwnames[] = {
22224 (char *) "self",(char *) "dt",(char *) "ts", NULL
22225 };
22226
22227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22229 if (SWIG_arg_fail(1)) SWIG_fail;
22230 {
22231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22232 if (SWIG_arg_fail(2)) SWIG_fail;
22233 if (arg2 == NULL) {
22234 SWIG_null_ref("wxDateTime");
22235 }
22236 if (SWIG_arg_fail(2)) SWIG_fail;
22237 }
22238 {
22239 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22240 if (SWIG_arg_fail(3)) SWIG_fail;
22241 if (arg3 == NULL) {
22242 SWIG_null_ref("wxTimeSpan");
22243 }
22244 if (SWIG_arg_fail(3)) SWIG_fail;
22245 }
22246 {
22247 PyThreadState* __tstate = wxPyBeginAllowThreads();
22248 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22249
22250 wxPyEndAllowThreads(__tstate);
22251 if (PyErr_Occurred()) SWIG_fail;
22252 }
22253 {
22254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22255 }
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22263 PyObject *resultobj;
22264 wxDateTime *arg1 = (wxDateTime *) 0 ;
22265 wxTimeSpan *arg2 = 0 ;
22266 wxDateTime *result;
22267 PyObject * obj0 = 0 ;
22268 PyObject * obj1 = 0 ;
22269 char *kwnames[] = {
22270 (char *) "self",(char *) "diff", NULL
22271 };
22272
22273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22275 if (SWIG_arg_fail(1)) SWIG_fail;
22276 {
22277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22278 if (SWIG_arg_fail(2)) SWIG_fail;
22279 if (arg2 == NULL) {
22280 SWIG_null_ref("wxTimeSpan");
22281 }
22282 if (SWIG_arg_fail(2)) SWIG_fail;
22283 }
22284 {
22285 PyThreadState* __tstate = wxPyBeginAllowThreads();
22286 {
22287 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22288 result = (wxDateTime *) &_result_ref;
22289 }
22290
22291 wxPyEndAllowThreads(__tstate);
22292 if (PyErr_Occurred()) SWIG_fail;
22293 }
22294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22302 PyObject *resultobj;
22303 wxDateTime *arg1 = (wxDateTime *) 0 ;
22304 wxDateSpan *arg2 = 0 ;
22305 wxDateTime *result;
22306 PyObject * obj0 = 0 ;
22307 PyObject * obj1 = 0 ;
22308 char *kwnames[] = {
22309 (char *) "self",(char *) "diff", NULL
22310 };
22311
22312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22314 if (SWIG_arg_fail(1)) SWIG_fail;
22315 {
22316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22317 if (SWIG_arg_fail(2)) SWIG_fail;
22318 if (arg2 == NULL) {
22319 SWIG_null_ref("wxDateSpan");
22320 }
22321 if (SWIG_arg_fail(2)) SWIG_fail;
22322 }
22323 {
22324 PyThreadState* __tstate = wxPyBeginAllowThreads();
22325 {
22326 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22327 result = (wxDateTime *) &_result_ref;
22328 }
22329
22330 wxPyEndAllowThreads(__tstate);
22331 if (PyErr_Occurred()) SWIG_fail;
22332 }
22333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22334 return resultobj;
22335 fail:
22336 return NULL;
22337 }
22338
22339
22340 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22341 PyObject *resultobj;
22342 wxDateTime *arg1 = (wxDateTime *) 0 ;
22343 wxTimeSpan *arg2 = 0 ;
22344 wxDateTime *result;
22345 PyObject * obj0 = 0 ;
22346 PyObject * obj1 = 0 ;
22347 char *kwnames[] = {
22348 (char *) "self",(char *) "diff", NULL
22349 };
22350
22351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22353 if (SWIG_arg_fail(1)) SWIG_fail;
22354 {
22355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22356 if (SWIG_arg_fail(2)) SWIG_fail;
22357 if (arg2 == NULL) {
22358 SWIG_null_ref("wxTimeSpan");
22359 }
22360 if (SWIG_arg_fail(2)) SWIG_fail;
22361 }
22362 {
22363 PyThreadState* __tstate = wxPyBeginAllowThreads();
22364 {
22365 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22366 result = (wxDateTime *) &_result_ref;
22367 }
22368
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22380 PyObject *resultobj;
22381 wxDateTime *arg1 = (wxDateTime *) 0 ;
22382 wxDateSpan *arg2 = 0 ;
22383 wxDateTime *result;
22384 PyObject * obj0 = 0 ;
22385 PyObject * obj1 = 0 ;
22386 char *kwnames[] = {
22387 (char *) "self",(char *) "diff", NULL
22388 };
22389
22390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22392 if (SWIG_arg_fail(1)) SWIG_fail;
22393 {
22394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22395 if (SWIG_arg_fail(2)) SWIG_fail;
22396 if (arg2 == NULL) {
22397 SWIG_null_ref("wxDateSpan");
22398 }
22399 if (SWIG_arg_fail(2)) SWIG_fail;
22400 }
22401 {
22402 PyThreadState* __tstate = wxPyBeginAllowThreads();
22403 {
22404 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22405 result = (wxDateTime *) &_result_ref;
22406 }
22407
22408 wxPyEndAllowThreads(__tstate);
22409 if (PyErr_Occurred()) SWIG_fail;
22410 }
22411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22412 return resultobj;
22413 fail:
22414 return NULL;
22415 }
22416
22417
22418 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22419 PyObject *resultobj;
22420 wxDateTime *arg1 = (wxDateTime *) 0 ;
22421 wxDateTime *arg2 = 0 ;
22422 wxTimeSpan result;
22423 PyObject * obj0 = 0 ;
22424 PyObject * obj1 = 0 ;
22425 char *kwnames[] = {
22426 (char *) "self",(char *) "dt", NULL
22427 };
22428
22429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22431 if (SWIG_arg_fail(1)) SWIG_fail;
22432 {
22433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22434 if (SWIG_arg_fail(2)) SWIG_fail;
22435 if (arg2 == NULL) {
22436 SWIG_null_ref("wxDateTime");
22437 }
22438 if (SWIG_arg_fail(2)) SWIG_fail;
22439 }
22440 {
22441 PyThreadState* __tstate = wxPyBeginAllowThreads();
22442 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22443
22444 wxPyEndAllowThreads(__tstate);
22445 if (PyErr_Occurred()) SWIG_fail;
22446 }
22447 {
22448 wxTimeSpan * resultptr;
22449 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22451 }
22452 return resultobj;
22453 fail:
22454 return NULL;
22455 }
22456
22457
22458 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22459 PyObject *resultobj;
22460 wxDateTime *arg1 = (wxDateTime *) 0 ;
22461 wxTimeSpan *arg2 = 0 ;
22462 wxDateTime *result;
22463 PyObject * obj0 = 0 ;
22464 PyObject * obj1 = 0 ;
22465
22466 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22468 if (SWIG_arg_fail(1)) SWIG_fail;
22469 {
22470 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22471 if (SWIG_arg_fail(2)) SWIG_fail;
22472 if (arg2 == NULL) {
22473 SWIG_null_ref("wxTimeSpan");
22474 }
22475 if (SWIG_arg_fail(2)) SWIG_fail;
22476 }
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 {
22480 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22481 result = (wxDateTime *) &_result_ref;
22482 }
22483
22484 wxPyEndAllowThreads(__tstate);
22485 if (PyErr_Occurred()) SWIG_fail;
22486 }
22487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22495 PyObject *resultobj;
22496 wxDateTime *arg1 = (wxDateTime *) 0 ;
22497 wxDateSpan *arg2 = 0 ;
22498 wxDateTime *result;
22499 PyObject * obj0 = 0 ;
22500 PyObject * obj1 = 0 ;
22501
22502 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22504 if (SWIG_arg_fail(1)) SWIG_fail;
22505 {
22506 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22507 if (SWIG_arg_fail(2)) SWIG_fail;
22508 if (arg2 == NULL) {
22509 SWIG_null_ref("wxDateSpan");
22510 }
22511 if (SWIG_arg_fail(2)) SWIG_fail;
22512 }
22513 {
22514 PyThreadState* __tstate = wxPyBeginAllowThreads();
22515 {
22516 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22517 result = (wxDateTime *) &_result_ref;
22518 }
22519
22520 wxPyEndAllowThreads(__tstate);
22521 if (PyErr_Occurred()) SWIG_fail;
22522 }
22523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22524 return resultobj;
22525 fail:
22526 return NULL;
22527 }
22528
22529
22530 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22531 int argc;
22532 PyObject *argv[3];
22533 int ii;
22534
22535 argc = PyObject_Length(args);
22536 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22537 argv[ii] = PyTuple_GetItem(args,ii);
22538 }
22539 if (argc == 2) {
22540 int _v;
22541 {
22542 void *ptr;
22543 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22544 _v = 0;
22545 PyErr_Clear();
22546 } else {
22547 _v = 1;
22548 }
22549 }
22550 if (_v) {
22551 {
22552 void *ptr = 0;
22553 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22554 _v = 0;
22555 PyErr_Clear();
22556 } else {
22557 _v = (ptr != 0);
22558 }
22559 }
22560 if (_v) {
22561 return _wrap_DateTime___iadd____SWIG_0(self,args);
22562 }
22563 }
22564 }
22565 if (argc == 2) {
22566 int _v;
22567 {
22568 void *ptr;
22569 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22570 _v = 0;
22571 PyErr_Clear();
22572 } else {
22573 _v = 1;
22574 }
22575 }
22576 if (_v) {
22577 {
22578 void *ptr = 0;
22579 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22580 _v = 0;
22581 PyErr_Clear();
22582 } else {
22583 _v = (ptr != 0);
22584 }
22585 }
22586 if (_v) {
22587 return _wrap_DateTime___iadd____SWIG_1(self,args);
22588 }
22589 }
22590 }
22591
22592 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22593 return NULL;
22594 }
22595
22596
22597 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22598 PyObject *resultobj;
22599 wxDateTime *arg1 = (wxDateTime *) 0 ;
22600 wxTimeSpan *arg2 = 0 ;
22601 wxDateTime *result;
22602 PyObject * obj0 = 0 ;
22603 PyObject * obj1 = 0 ;
22604
22605 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22607 if (SWIG_arg_fail(1)) SWIG_fail;
22608 {
22609 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22610 if (SWIG_arg_fail(2)) SWIG_fail;
22611 if (arg2 == NULL) {
22612 SWIG_null_ref("wxTimeSpan");
22613 }
22614 if (SWIG_arg_fail(2)) SWIG_fail;
22615 }
22616 {
22617 PyThreadState* __tstate = wxPyBeginAllowThreads();
22618 {
22619 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22620 result = (wxDateTime *) &_result_ref;
22621 }
22622
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22634 PyObject *resultobj;
22635 wxDateTime *arg1 = (wxDateTime *) 0 ;
22636 wxDateSpan *arg2 = 0 ;
22637 wxDateTime *result;
22638 PyObject * obj0 = 0 ;
22639 PyObject * obj1 = 0 ;
22640
22641 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22643 if (SWIG_arg_fail(1)) SWIG_fail;
22644 {
22645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22646 if (SWIG_arg_fail(2)) SWIG_fail;
22647 if (arg2 == NULL) {
22648 SWIG_null_ref("wxDateSpan");
22649 }
22650 if (SWIG_arg_fail(2)) SWIG_fail;
22651 }
22652 {
22653 PyThreadState* __tstate = wxPyBeginAllowThreads();
22654 {
22655 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22656 result = (wxDateTime *) &_result_ref;
22657 }
22658
22659 wxPyEndAllowThreads(__tstate);
22660 if (PyErr_Occurred()) SWIG_fail;
22661 }
22662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22670 int argc;
22671 PyObject *argv[3];
22672 int ii;
22673
22674 argc = PyObject_Length(args);
22675 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22676 argv[ii] = PyTuple_GetItem(args,ii);
22677 }
22678 if (argc == 2) {
22679 int _v;
22680 {
22681 void *ptr;
22682 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22683 _v = 0;
22684 PyErr_Clear();
22685 } else {
22686 _v = 1;
22687 }
22688 }
22689 if (_v) {
22690 {
22691 void *ptr = 0;
22692 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22693 _v = 0;
22694 PyErr_Clear();
22695 } else {
22696 _v = (ptr != 0);
22697 }
22698 }
22699 if (_v) {
22700 return _wrap_DateTime___isub____SWIG_0(self,args);
22701 }
22702 }
22703 }
22704 if (argc == 2) {
22705 int _v;
22706 {
22707 void *ptr;
22708 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22709 _v = 0;
22710 PyErr_Clear();
22711 } else {
22712 _v = 1;
22713 }
22714 }
22715 if (_v) {
22716 {
22717 void *ptr = 0;
22718 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22719 _v = 0;
22720 PyErr_Clear();
22721 } else {
22722 _v = (ptr != 0);
22723 }
22724 }
22725 if (_v) {
22726 return _wrap_DateTime___isub____SWIG_1(self,args);
22727 }
22728 }
22729 }
22730
22731 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22732 return NULL;
22733 }
22734
22735
22736 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22737 PyObject *resultobj;
22738 wxDateTime *arg1 = (wxDateTime *) 0 ;
22739 wxTimeSpan *arg2 = 0 ;
22740 wxDateTime result;
22741 PyObject * obj0 = 0 ;
22742 PyObject * obj1 = 0 ;
22743
22744 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22746 if (SWIG_arg_fail(1)) SWIG_fail;
22747 {
22748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22749 if (SWIG_arg_fail(2)) SWIG_fail;
22750 if (arg2 == NULL) {
22751 SWIG_null_ref("wxTimeSpan");
22752 }
22753 if (SWIG_arg_fail(2)) SWIG_fail;
22754 }
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22758
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 {
22763 wxDateTime * resultptr;
22764 resultptr = new wxDateTime((wxDateTime &)(result));
22765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22766 }
22767 return resultobj;
22768 fail:
22769 return NULL;
22770 }
22771
22772
22773 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22774 PyObject *resultobj;
22775 wxDateTime *arg1 = (wxDateTime *) 0 ;
22776 wxDateSpan *arg2 = 0 ;
22777 wxDateTime result;
22778 PyObject * obj0 = 0 ;
22779 PyObject * obj1 = 0 ;
22780
22781 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22783 if (SWIG_arg_fail(1)) SWIG_fail;
22784 {
22785 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22786 if (SWIG_arg_fail(2)) SWIG_fail;
22787 if (arg2 == NULL) {
22788 SWIG_null_ref("wxDateSpan");
22789 }
22790 if (SWIG_arg_fail(2)) SWIG_fail;
22791 }
22792 {
22793 PyThreadState* __tstate = wxPyBeginAllowThreads();
22794 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22795
22796 wxPyEndAllowThreads(__tstate);
22797 if (PyErr_Occurred()) SWIG_fail;
22798 }
22799 {
22800 wxDateTime * resultptr;
22801 resultptr = new wxDateTime((wxDateTime &)(result));
22802 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22803 }
22804 return resultobj;
22805 fail:
22806 return NULL;
22807 }
22808
22809
22810 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22811 int argc;
22812 PyObject *argv[3];
22813 int ii;
22814
22815 argc = PyObject_Length(args);
22816 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22817 argv[ii] = PyTuple_GetItem(args,ii);
22818 }
22819 if (argc == 2) {
22820 int _v;
22821 {
22822 void *ptr;
22823 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22824 _v = 0;
22825 PyErr_Clear();
22826 } else {
22827 _v = 1;
22828 }
22829 }
22830 if (_v) {
22831 {
22832 void *ptr = 0;
22833 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22834 _v = 0;
22835 PyErr_Clear();
22836 } else {
22837 _v = (ptr != 0);
22838 }
22839 }
22840 if (_v) {
22841 return _wrap_DateTime___add____SWIG_0(self,args);
22842 }
22843 }
22844 }
22845 if (argc == 2) {
22846 int _v;
22847 {
22848 void *ptr;
22849 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22850 _v = 0;
22851 PyErr_Clear();
22852 } else {
22853 _v = 1;
22854 }
22855 }
22856 if (_v) {
22857 {
22858 void *ptr = 0;
22859 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22860 _v = 0;
22861 PyErr_Clear();
22862 } else {
22863 _v = (ptr != 0);
22864 }
22865 }
22866 if (_v) {
22867 return _wrap_DateTime___add____SWIG_1(self,args);
22868 }
22869 }
22870 }
22871
22872 Py_INCREF(Py_NotImplemented);
22873 return Py_NotImplemented;
22874 }
22875
22876
22877 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22878 PyObject *resultobj;
22879 wxDateTime *arg1 = (wxDateTime *) 0 ;
22880 wxDateTime *arg2 = 0 ;
22881 wxTimeSpan result;
22882 PyObject * obj0 = 0 ;
22883 PyObject * obj1 = 0 ;
22884
22885 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22887 if (SWIG_arg_fail(1)) SWIG_fail;
22888 {
22889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22890 if (SWIG_arg_fail(2)) SWIG_fail;
22891 if (arg2 == NULL) {
22892 SWIG_null_ref("wxDateTime");
22893 }
22894 if (SWIG_arg_fail(2)) SWIG_fail;
22895 }
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22899
22900 wxPyEndAllowThreads(__tstate);
22901 if (PyErr_Occurred()) SWIG_fail;
22902 }
22903 {
22904 wxTimeSpan * resultptr;
22905 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22907 }
22908 return resultobj;
22909 fail:
22910 return NULL;
22911 }
22912
22913
22914 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22915 PyObject *resultobj;
22916 wxDateTime *arg1 = (wxDateTime *) 0 ;
22917 wxTimeSpan *arg2 = 0 ;
22918 wxDateTime result;
22919 PyObject * obj0 = 0 ;
22920 PyObject * obj1 = 0 ;
22921
22922 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22924 if (SWIG_arg_fail(1)) SWIG_fail;
22925 {
22926 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22927 if (SWIG_arg_fail(2)) SWIG_fail;
22928 if (arg2 == NULL) {
22929 SWIG_null_ref("wxTimeSpan");
22930 }
22931 if (SWIG_arg_fail(2)) SWIG_fail;
22932 }
22933 {
22934 PyThreadState* __tstate = wxPyBeginAllowThreads();
22935 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22936
22937 wxPyEndAllowThreads(__tstate);
22938 if (PyErr_Occurred()) SWIG_fail;
22939 }
22940 {
22941 wxDateTime * resultptr;
22942 resultptr = new wxDateTime((wxDateTime &)(result));
22943 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22944 }
22945 return resultobj;
22946 fail:
22947 return NULL;
22948 }
22949
22950
22951 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22952 PyObject *resultobj;
22953 wxDateTime *arg1 = (wxDateTime *) 0 ;
22954 wxDateSpan *arg2 = 0 ;
22955 wxDateTime result;
22956 PyObject * obj0 = 0 ;
22957 PyObject * obj1 = 0 ;
22958
22959 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22961 if (SWIG_arg_fail(1)) SWIG_fail;
22962 {
22963 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22964 if (SWIG_arg_fail(2)) SWIG_fail;
22965 if (arg2 == NULL) {
22966 SWIG_null_ref("wxDateSpan");
22967 }
22968 if (SWIG_arg_fail(2)) SWIG_fail;
22969 }
22970 {
22971 PyThreadState* __tstate = wxPyBeginAllowThreads();
22972 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22973
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 {
22978 wxDateTime * resultptr;
22979 resultptr = new wxDateTime((wxDateTime &)(result));
22980 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22981 }
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22989 int argc;
22990 PyObject *argv[3];
22991 int ii;
22992
22993 argc = PyObject_Length(args);
22994 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22995 argv[ii] = PyTuple_GetItem(args,ii);
22996 }
22997 if (argc == 2) {
22998 int _v;
22999 {
23000 void *ptr;
23001 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23002 _v = 0;
23003 PyErr_Clear();
23004 } else {
23005 _v = 1;
23006 }
23007 }
23008 if (_v) {
23009 {
23010 void *ptr = 0;
23011 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23012 _v = 0;
23013 PyErr_Clear();
23014 } else {
23015 _v = (ptr != 0);
23016 }
23017 }
23018 if (_v) {
23019 return _wrap_DateTime___sub____SWIG_0(self,args);
23020 }
23021 }
23022 }
23023 if (argc == 2) {
23024 int _v;
23025 {
23026 void *ptr;
23027 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23028 _v = 0;
23029 PyErr_Clear();
23030 } else {
23031 _v = 1;
23032 }
23033 }
23034 if (_v) {
23035 {
23036 void *ptr = 0;
23037 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23038 _v = 0;
23039 PyErr_Clear();
23040 } else {
23041 _v = (ptr != 0);
23042 }
23043 }
23044 if (_v) {
23045 return _wrap_DateTime___sub____SWIG_1(self,args);
23046 }
23047 }
23048 }
23049 if (argc == 2) {
23050 int _v;
23051 {
23052 void *ptr;
23053 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23054 _v = 0;
23055 PyErr_Clear();
23056 } else {
23057 _v = 1;
23058 }
23059 }
23060 if (_v) {
23061 {
23062 void *ptr = 0;
23063 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23064 _v = 0;
23065 PyErr_Clear();
23066 } else {
23067 _v = (ptr != 0);
23068 }
23069 }
23070 if (_v) {
23071 return _wrap_DateTime___sub____SWIG_2(self,args);
23072 }
23073 }
23074 }
23075
23076 Py_INCREF(Py_NotImplemented);
23077 return Py_NotImplemented;
23078 }
23079
23080
23081 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args) {
23082 PyObject *resultobj;
23083 wxDateTime *arg1 = (wxDateTime *) 0 ;
23084 wxDateTime *arg2 = (wxDateTime *) 0 ;
23085 bool result;
23086 PyObject * obj0 = 0 ;
23087 PyObject * obj1 = 0 ;
23088
23089 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___lt__",&obj0,&obj1)) goto fail;
23090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23091 if (SWIG_arg_fail(1)) SWIG_fail;
23092 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23093 if (SWIG_arg_fail(2)) SWIG_fail;
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23097
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 {
23102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23103 }
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args) {
23111 PyObject *resultobj;
23112 wxDateTime *arg1 = (wxDateTime *) 0 ;
23113 wxDateTime *arg2 = (wxDateTime *) 0 ;
23114 bool result;
23115 PyObject * obj0 = 0 ;
23116 PyObject * obj1 = 0 ;
23117
23118 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___le__",&obj0,&obj1)) goto fail;
23119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23120 if (SWIG_arg_fail(1)) SWIG_fail;
23121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23122 if (SWIG_arg_fail(2)) SWIG_fail;
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23126
23127 wxPyEndAllowThreads(__tstate);
23128 if (PyErr_Occurred()) SWIG_fail;
23129 }
23130 {
23131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23132 }
23133 return resultobj;
23134 fail:
23135 return NULL;
23136 }
23137
23138
23139 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args) {
23140 PyObject *resultobj;
23141 wxDateTime *arg1 = (wxDateTime *) 0 ;
23142 wxDateTime *arg2 = (wxDateTime *) 0 ;
23143 bool result;
23144 PyObject * obj0 = 0 ;
23145 PyObject * obj1 = 0 ;
23146
23147 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___gt__",&obj0,&obj1)) goto fail;
23148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23149 if (SWIG_arg_fail(1)) SWIG_fail;
23150 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23151 if (SWIG_arg_fail(2)) SWIG_fail;
23152 {
23153 PyThreadState* __tstate = wxPyBeginAllowThreads();
23154 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23155
23156 wxPyEndAllowThreads(__tstate);
23157 if (PyErr_Occurred()) SWIG_fail;
23158 }
23159 {
23160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23161 }
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args) {
23169 PyObject *resultobj;
23170 wxDateTime *arg1 = (wxDateTime *) 0 ;
23171 wxDateTime *arg2 = (wxDateTime *) 0 ;
23172 bool result;
23173 PyObject * obj0 = 0 ;
23174 PyObject * obj1 = 0 ;
23175
23176 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ge__",&obj0,&obj1)) goto fail;
23177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23178 if (SWIG_arg_fail(1)) SWIG_fail;
23179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23180 if (SWIG_arg_fail(2)) SWIG_fail;
23181 {
23182 PyThreadState* __tstate = wxPyBeginAllowThreads();
23183 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23184
23185 wxPyEndAllowThreads(__tstate);
23186 if (PyErr_Occurred()) SWIG_fail;
23187 }
23188 {
23189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23190 }
23191 return resultobj;
23192 fail:
23193 return NULL;
23194 }
23195
23196
23197 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args) {
23198 PyObject *resultobj;
23199 wxDateTime *arg1 = (wxDateTime *) 0 ;
23200 wxDateTime *arg2 = (wxDateTime *) 0 ;
23201 bool result;
23202 PyObject * obj0 = 0 ;
23203 PyObject * obj1 = 0 ;
23204
23205 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___eq__",&obj0,&obj1)) goto fail;
23206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23207 if (SWIG_arg_fail(1)) SWIG_fail;
23208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23209 if (SWIG_arg_fail(2)) SWIG_fail;
23210 {
23211 PyThreadState* __tstate = wxPyBeginAllowThreads();
23212 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23213
23214 wxPyEndAllowThreads(__tstate);
23215 if (PyErr_Occurred()) SWIG_fail;
23216 }
23217 {
23218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23219 }
23220 return resultobj;
23221 fail:
23222 return NULL;
23223 }
23224
23225
23226 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args) {
23227 PyObject *resultobj;
23228 wxDateTime *arg1 = (wxDateTime *) 0 ;
23229 wxDateTime *arg2 = (wxDateTime *) 0 ;
23230 bool result;
23231 PyObject * obj0 = 0 ;
23232 PyObject * obj1 = 0 ;
23233
23234 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ne__",&obj0,&obj1)) goto fail;
23235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23236 if (SWIG_arg_fail(1)) SWIG_fail;
23237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23238 if (SWIG_arg_fail(2)) SWIG_fail;
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23242
23243 wxPyEndAllowThreads(__tstate);
23244 if (PyErr_Occurred()) SWIG_fail;
23245 }
23246 {
23247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23248 }
23249 return resultobj;
23250 fail:
23251 return NULL;
23252 }
23253
23254
23255 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23256 PyObject *resultobj;
23257 wxDateTime *arg1 = (wxDateTime *) 0 ;
23258 wxString *arg2 = 0 ;
23259 int result;
23260 bool temp2 = false ;
23261 PyObject * obj0 = 0 ;
23262 PyObject * obj1 = 0 ;
23263 char *kwnames[] = {
23264 (char *) "self",(char *) "date", NULL
23265 };
23266
23267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23269 if (SWIG_arg_fail(1)) SWIG_fail;
23270 {
23271 arg2 = wxString_in_helper(obj1);
23272 if (arg2 == NULL) SWIG_fail;
23273 temp2 = true;
23274 }
23275 {
23276 PyThreadState* __tstate = wxPyBeginAllowThreads();
23277 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23278
23279 wxPyEndAllowThreads(__tstate);
23280 if (PyErr_Occurred()) SWIG_fail;
23281 }
23282 {
23283 resultobj = SWIG_From_int((int)(result));
23284 }
23285 {
23286 if (temp2)
23287 delete arg2;
23288 }
23289 return resultobj;
23290 fail:
23291 {
23292 if (temp2)
23293 delete arg2;
23294 }
23295 return NULL;
23296 }
23297
23298
23299 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23300 PyObject *resultobj;
23301 wxDateTime *arg1 = (wxDateTime *) 0 ;
23302 wxString *arg2 = 0 ;
23303 wxString const &arg3_defvalue = wxPyDateFormatStr ;
23304 wxString *arg3 = (wxString *) &arg3_defvalue ;
23305 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23306 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23307 int result;
23308 bool temp2 = false ;
23309 bool temp3 = false ;
23310 PyObject * obj0 = 0 ;
23311 PyObject * obj1 = 0 ;
23312 PyObject * obj2 = 0 ;
23313 PyObject * obj3 = 0 ;
23314 char *kwnames[] = {
23315 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23316 };
23317
23318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23320 if (SWIG_arg_fail(1)) SWIG_fail;
23321 {
23322 arg2 = wxString_in_helper(obj1);
23323 if (arg2 == NULL) SWIG_fail;
23324 temp2 = true;
23325 }
23326 if (obj2) {
23327 {
23328 arg3 = wxString_in_helper(obj2);
23329 if (arg3 == NULL) SWIG_fail;
23330 temp3 = true;
23331 }
23332 }
23333 if (obj3) {
23334 {
23335 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23336 if (SWIG_arg_fail(4)) SWIG_fail;
23337 if (arg4 == NULL) {
23338 SWIG_null_ref("wxDateTime");
23339 }
23340 if (SWIG_arg_fail(4)) SWIG_fail;
23341 }
23342 }
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23346
23347 wxPyEndAllowThreads(__tstate);
23348 if (PyErr_Occurred()) SWIG_fail;
23349 }
23350 {
23351 resultobj = SWIG_From_int((int)(result));
23352 }
23353 {
23354 if (temp2)
23355 delete arg2;
23356 }
23357 {
23358 if (temp3)
23359 delete arg3;
23360 }
23361 return resultobj;
23362 fail:
23363 {
23364 if (temp2)
23365 delete arg2;
23366 }
23367 {
23368 if (temp3)
23369 delete arg3;
23370 }
23371 return NULL;
23372 }
23373
23374
23375 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23376 PyObject *resultobj;
23377 wxDateTime *arg1 = (wxDateTime *) 0 ;
23378 wxString *arg2 = 0 ;
23379 int result;
23380 bool temp2 = false ;
23381 PyObject * obj0 = 0 ;
23382 PyObject * obj1 = 0 ;
23383 char *kwnames[] = {
23384 (char *) "self",(char *) "datetime", NULL
23385 };
23386
23387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) 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 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23398
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 {
23403 resultobj = SWIG_From_int((int)(result));
23404 }
23405 {
23406 if (temp2)
23407 delete arg2;
23408 }
23409 return resultobj;
23410 fail:
23411 {
23412 if (temp2)
23413 delete arg2;
23414 }
23415 return NULL;
23416 }
23417
23418
23419 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23420 PyObject *resultobj;
23421 wxDateTime *arg1 = (wxDateTime *) 0 ;
23422 wxString *arg2 = 0 ;
23423 int result;
23424 bool temp2 = false ;
23425 PyObject * obj0 = 0 ;
23426 PyObject * obj1 = 0 ;
23427 char *kwnames[] = {
23428 (char *) "self",(char *) "date", NULL
23429 };
23430
23431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23433 if (SWIG_arg_fail(1)) SWIG_fail;
23434 {
23435 arg2 = wxString_in_helper(obj1);
23436 if (arg2 == NULL) SWIG_fail;
23437 temp2 = true;
23438 }
23439 {
23440 PyThreadState* __tstate = wxPyBeginAllowThreads();
23441 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23442
23443 wxPyEndAllowThreads(__tstate);
23444 if (PyErr_Occurred()) SWIG_fail;
23445 }
23446 {
23447 resultobj = SWIG_From_int((int)(result));
23448 }
23449 {
23450 if (temp2)
23451 delete arg2;
23452 }
23453 return resultobj;
23454 fail:
23455 {
23456 if (temp2)
23457 delete arg2;
23458 }
23459 return NULL;
23460 }
23461
23462
23463 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23464 PyObject *resultobj;
23465 wxDateTime *arg1 = (wxDateTime *) 0 ;
23466 wxString *arg2 = 0 ;
23467 int result;
23468 bool temp2 = false ;
23469 PyObject * obj0 = 0 ;
23470 PyObject * obj1 = 0 ;
23471 char *kwnames[] = {
23472 (char *) "self",(char *) "time", NULL
23473 };
23474
23475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23477 if (SWIG_arg_fail(1)) SWIG_fail;
23478 {
23479 arg2 = wxString_in_helper(obj1);
23480 if (arg2 == NULL) SWIG_fail;
23481 temp2 = true;
23482 }
23483 {
23484 PyThreadState* __tstate = wxPyBeginAllowThreads();
23485 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23486
23487 wxPyEndAllowThreads(__tstate);
23488 if (PyErr_Occurred()) SWIG_fail;
23489 }
23490 {
23491 resultobj = SWIG_From_int((int)(result));
23492 }
23493 {
23494 if (temp2)
23495 delete arg2;
23496 }
23497 return resultobj;
23498 fail:
23499 {
23500 if (temp2)
23501 delete arg2;
23502 }
23503 return NULL;
23504 }
23505
23506
23507 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23508 PyObject *resultobj;
23509 wxDateTime *arg1 = (wxDateTime *) 0 ;
23510 wxString const &arg2_defvalue = wxPyDateFormatStr ;
23511 wxString *arg2 = (wxString *) &arg2_defvalue ;
23512 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23513 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23514 wxString result;
23515 bool temp2 = false ;
23516 bool temp3 = false ;
23517 PyObject * obj0 = 0 ;
23518 PyObject * obj1 = 0 ;
23519 PyObject * obj2 = 0 ;
23520 char *kwnames[] = {
23521 (char *) "self",(char *) "format",(char *) "tz", NULL
23522 };
23523
23524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23526 if (SWIG_arg_fail(1)) SWIG_fail;
23527 if (obj1) {
23528 {
23529 arg2 = wxString_in_helper(obj1);
23530 if (arg2 == NULL) SWIG_fail;
23531 temp2 = true;
23532 }
23533 }
23534 if (obj2) {
23535 {
23536 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23537 temp3 = true;
23538 }
23539 }
23540 {
23541 PyThreadState* __tstate = wxPyBeginAllowThreads();
23542 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23543
23544 wxPyEndAllowThreads(__tstate);
23545 if (PyErr_Occurred()) SWIG_fail;
23546 }
23547 {
23548 #if wxUSE_UNICODE
23549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23550 #else
23551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23552 #endif
23553 }
23554 {
23555 if (temp2)
23556 delete arg2;
23557 }
23558 {
23559 if (temp3) delete arg3;
23560 }
23561 return resultobj;
23562 fail:
23563 {
23564 if (temp2)
23565 delete arg2;
23566 }
23567 {
23568 if (temp3) delete arg3;
23569 }
23570 return NULL;
23571 }
23572
23573
23574 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23575 PyObject *resultobj;
23576 wxDateTime *arg1 = (wxDateTime *) 0 ;
23577 wxString result;
23578 PyObject * obj0 = 0 ;
23579 char *kwnames[] = {
23580 (char *) "self", NULL
23581 };
23582
23583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23585 if (SWIG_arg_fail(1)) SWIG_fail;
23586 {
23587 PyThreadState* __tstate = wxPyBeginAllowThreads();
23588 result = ((wxDateTime const *)arg1)->FormatDate();
23589
23590 wxPyEndAllowThreads(__tstate);
23591 if (PyErr_Occurred()) SWIG_fail;
23592 }
23593 {
23594 #if wxUSE_UNICODE
23595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23596 #else
23597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23598 #endif
23599 }
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23607 PyObject *resultobj;
23608 wxDateTime *arg1 = (wxDateTime *) 0 ;
23609 wxString result;
23610 PyObject * obj0 = 0 ;
23611 char *kwnames[] = {
23612 (char *) "self", NULL
23613 };
23614
23615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23617 if (SWIG_arg_fail(1)) SWIG_fail;
23618 {
23619 PyThreadState* __tstate = wxPyBeginAllowThreads();
23620 result = ((wxDateTime const *)arg1)->FormatTime();
23621
23622 wxPyEndAllowThreads(__tstate);
23623 if (PyErr_Occurred()) SWIG_fail;
23624 }
23625 {
23626 #if wxUSE_UNICODE
23627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23628 #else
23629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23630 #endif
23631 }
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj;
23640 wxDateTime *arg1 = (wxDateTime *) 0 ;
23641 wxString result;
23642 PyObject * obj0 = 0 ;
23643 char *kwnames[] = {
23644 (char *) "self", NULL
23645 };
23646
23647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23649 if (SWIG_arg_fail(1)) SWIG_fail;
23650 {
23651 PyThreadState* __tstate = wxPyBeginAllowThreads();
23652 result = ((wxDateTime const *)arg1)->FormatISODate();
23653
23654 wxPyEndAllowThreads(__tstate);
23655 if (PyErr_Occurred()) SWIG_fail;
23656 }
23657 {
23658 #if wxUSE_UNICODE
23659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23660 #else
23661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23662 #endif
23663 }
23664 return resultobj;
23665 fail:
23666 return NULL;
23667 }
23668
23669
23670 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23671 PyObject *resultobj;
23672 wxDateTime *arg1 = (wxDateTime *) 0 ;
23673 wxString result;
23674 PyObject * obj0 = 0 ;
23675 char *kwnames[] = {
23676 (char *) "self", NULL
23677 };
23678
23679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23681 if (SWIG_arg_fail(1)) SWIG_fail;
23682 {
23683 PyThreadState* __tstate = wxPyBeginAllowThreads();
23684 result = ((wxDateTime const *)arg1)->FormatISOTime();
23685
23686 wxPyEndAllowThreads(__tstate);
23687 if (PyErr_Occurred()) SWIG_fail;
23688 }
23689 {
23690 #if wxUSE_UNICODE
23691 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23692 #else
23693 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23694 #endif
23695 }
23696 return resultobj;
23697 fail:
23698 return NULL;
23699 }
23700
23701
23702 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23703 PyObject *obj;
23704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23705 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23706 Py_INCREF(obj);
23707 return Py_BuildValue((char *)"");
23708 }
23709 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23710 PyObject *resultobj;
23711 long arg1 ;
23712 wxTimeSpan result;
23713 PyObject * obj0 = 0 ;
23714 char *kwnames[] = {
23715 (char *) "sec", NULL
23716 };
23717
23718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23719 {
23720 arg1 = (long)(SWIG_As_long(obj0));
23721 if (SWIG_arg_fail(1)) SWIG_fail;
23722 }
23723 {
23724 PyThreadState* __tstate = wxPyBeginAllowThreads();
23725 result = wxTimeSpan::Seconds(arg1);
23726
23727 wxPyEndAllowThreads(__tstate);
23728 if (PyErr_Occurred()) SWIG_fail;
23729 }
23730 {
23731 wxTimeSpan * resultptr;
23732 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23733 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23734 }
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23742 PyObject *resultobj;
23743 wxTimeSpan result;
23744 char *kwnames[] = {
23745 NULL
23746 };
23747
23748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 result = wxTimeSpan::Second();
23752
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 {
23757 wxTimeSpan * resultptr;
23758 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23760 }
23761 return resultobj;
23762 fail:
23763 return NULL;
23764 }
23765
23766
23767 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj;
23769 long arg1 ;
23770 wxTimeSpan result;
23771 PyObject * obj0 = 0 ;
23772 char *kwnames[] = {
23773 (char *) "min", NULL
23774 };
23775
23776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23777 {
23778 arg1 = (long)(SWIG_As_long(obj0));
23779 if (SWIG_arg_fail(1)) SWIG_fail;
23780 }
23781 {
23782 PyThreadState* __tstate = wxPyBeginAllowThreads();
23783 result = wxTimeSpan::Minutes(arg1);
23784
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 {
23789 wxTimeSpan * resultptr;
23790 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23791 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23792 }
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23800 PyObject *resultobj;
23801 wxTimeSpan result;
23802 char *kwnames[] = {
23803 NULL
23804 };
23805
23806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23807 {
23808 PyThreadState* __tstate = wxPyBeginAllowThreads();
23809 result = wxTimeSpan::Minute();
23810
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 {
23815 wxTimeSpan * resultptr;
23816 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23817 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23818 }
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23826 PyObject *resultobj;
23827 long arg1 ;
23828 wxTimeSpan result;
23829 PyObject * obj0 = 0 ;
23830 char *kwnames[] = {
23831 (char *) "hours", NULL
23832 };
23833
23834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23835 {
23836 arg1 = (long)(SWIG_As_long(obj0));
23837 if (SWIG_arg_fail(1)) SWIG_fail;
23838 }
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = wxTimeSpan::Hours(arg1);
23842
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 {
23847 wxTimeSpan * resultptr;
23848 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23849 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23850 }
23851 return resultobj;
23852 fail:
23853 return NULL;
23854 }
23855
23856
23857 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23858 PyObject *resultobj;
23859 wxTimeSpan result;
23860 char *kwnames[] = {
23861 NULL
23862 };
23863
23864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23865 {
23866 PyThreadState* __tstate = wxPyBeginAllowThreads();
23867 result = wxTimeSpan::Hour();
23868
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 {
23873 wxTimeSpan * resultptr;
23874 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23876 }
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23884 PyObject *resultobj;
23885 long arg1 ;
23886 wxTimeSpan result;
23887 PyObject * obj0 = 0 ;
23888 char *kwnames[] = {
23889 (char *) "days", NULL
23890 };
23891
23892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23893 {
23894 arg1 = (long)(SWIG_As_long(obj0));
23895 if (SWIG_arg_fail(1)) SWIG_fail;
23896 }
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 result = wxTimeSpan::Days(arg1);
23900
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 {
23905 wxTimeSpan * resultptr;
23906 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23908 }
23909 return resultobj;
23910 fail:
23911 return NULL;
23912 }
23913
23914
23915 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23916 PyObject *resultobj;
23917 wxTimeSpan result;
23918 char *kwnames[] = {
23919 NULL
23920 };
23921
23922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 result = wxTimeSpan::Day();
23926
23927 wxPyEndAllowThreads(__tstate);
23928 if (PyErr_Occurred()) SWIG_fail;
23929 }
23930 {
23931 wxTimeSpan * resultptr;
23932 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23933 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23934 }
23935 return resultobj;
23936 fail:
23937 return NULL;
23938 }
23939
23940
23941 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23942 PyObject *resultobj;
23943 long arg1 ;
23944 wxTimeSpan result;
23945 PyObject * obj0 = 0 ;
23946 char *kwnames[] = {
23947 (char *) "days", NULL
23948 };
23949
23950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23951 {
23952 arg1 = (long)(SWIG_As_long(obj0));
23953 if (SWIG_arg_fail(1)) SWIG_fail;
23954 }
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 result = wxTimeSpan::Weeks(arg1);
23958
23959 wxPyEndAllowThreads(__tstate);
23960 if (PyErr_Occurred()) SWIG_fail;
23961 }
23962 {
23963 wxTimeSpan * resultptr;
23964 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23965 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23966 }
23967 return resultobj;
23968 fail:
23969 return NULL;
23970 }
23971
23972
23973 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23974 PyObject *resultobj;
23975 wxTimeSpan result;
23976 char *kwnames[] = {
23977 NULL
23978 };
23979
23980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23981 {
23982 PyThreadState* __tstate = wxPyBeginAllowThreads();
23983 result = wxTimeSpan::Week();
23984
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 {
23989 wxTimeSpan * resultptr;
23990 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23991 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23992 }
23993 return resultobj;
23994 fail:
23995 return NULL;
23996 }
23997
23998
23999 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24000 PyObject *resultobj;
24001 long arg1 = (long) 0 ;
24002 long arg2 = (long) 0 ;
24003 long arg3 = (long) 0 ;
24004 long arg4 = (long) 0 ;
24005 wxTimeSpan *result;
24006 PyObject * obj0 = 0 ;
24007 PyObject * obj1 = 0 ;
24008 PyObject * obj2 = 0 ;
24009 PyObject * obj3 = 0 ;
24010 char *kwnames[] = {
24011 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24012 };
24013
24014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24015 if (obj0) {
24016 {
24017 arg1 = (long)(SWIG_As_long(obj0));
24018 if (SWIG_arg_fail(1)) SWIG_fail;
24019 }
24020 }
24021 if (obj1) {
24022 {
24023 arg2 = (long)(SWIG_As_long(obj1));
24024 if (SWIG_arg_fail(2)) SWIG_fail;
24025 }
24026 }
24027 if (obj2) {
24028 {
24029 arg3 = (long)(SWIG_As_long(obj2));
24030 if (SWIG_arg_fail(3)) SWIG_fail;
24031 }
24032 }
24033 if (obj3) {
24034 {
24035 arg4 = (long)(SWIG_As_long(obj3));
24036 if (SWIG_arg_fail(4)) SWIG_fail;
24037 }
24038 }
24039 {
24040 PyThreadState* __tstate = wxPyBeginAllowThreads();
24041 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24042
24043 wxPyEndAllowThreads(__tstate);
24044 if (PyErr_Occurred()) SWIG_fail;
24045 }
24046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24047 return resultobj;
24048 fail:
24049 return NULL;
24050 }
24051
24052
24053 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24054 PyObject *resultobj;
24055 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24056 PyObject * obj0 = 0 ;
24057 char *kwnames[] = {
24058 (char *) "self", NULL
24059 };
24060
24061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24063 if (SWIG_arg_fail(1)) SWIG_fail;
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 delete arg1;
24067
24068 wxPyEndAllowThreads(__tstate);
24069 if (PyErr_Occurred()) SWIG_fail;
24070 }
24071 Py_INCREF(Py_None); resultobj = Py_None;
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24079 PyObject *resultobj;
24080 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24081 wxTimeSpan *arg2 = 0 ;
24082 wxTimeSpan *result;
24083 PyObject * obj0 = 0 ;
24084 PyObject * obj1 = 0 ;
24085 char *kwnames[] = {
24086 (char *) "self",(char *) "diff", NULL
24087 };
24088
24089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24091 if (SWIG_arg_fail(1)) SWIG_fail;
24092 {
24093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24094 if (SWIG_arg_fail(2)) SWIG_fail;
24095 if (arg2 == NULL) {
24096 SWIG_null_ref("wxTimeSpan");
24097 }
24098 if (SWIG_arg_fail(2)) SWIG_fail;
24099 }
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 {
24103 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24104 result = (wxTimeSpan *) &_result_ref;
24105 }
24106
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24111 return resultobj;
24112 fail:
24113 return NULL;
24114 }
24115
24116
24117 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24118 PyObject *resultobj;
24119 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24120 wxTimeSpan *arg2 = 0 ;
24121 wxTimeSpan *result;
24122 PyObject * obj0 = 0 ;
24123 PyObject * obj1 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "self",(char *) "diff", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 {
24132 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24133 if (SWIG_arg_fail(2)) SWIG_fail;
24134 if (arg2 == NULL) {
24135 SWIG_null_ref("wxTimeSpan");
24136 }
24137 if (SWIG_arg_fail(2)) SWIG_fail;
24138 }
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 {
24142 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24143 result = (wxTimeSpan *) &_result_ref;
24144 }
24145
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24157 PyObject *resultobj;
24158 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24159 int arg2 ;
24160 wxTimeSpan *result;
24161 PyObject * obj0 = 0 ;
24162 PyObject * obj1 = 0 ;
24163 char *kwnames[] = {
24164 (char *) "self",(char *) "n", NULL
24165 };
24166
24167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24169 if (SWIG_arg_fail(1)) SWIG_fail;
24170 {
24171 arg2 = (int)(SWIG_As_int(obj1));
24172 if (SWIG_arg_fail(2)) SWIG_fail;
24173 }
24174 {
24175 PyThreadState* __tstate = wxPyBeginAllowThreads();
24176 {
24177 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24178 result = (wxTimeSpan *) &_result_ref;
24179 }
24180
24181 wxPyEndAllowThreads(__tstate);
24182 if (PyErr_Occurred()) SWIG_fail;
24183 }
24184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24185 return resultobj;
24186 fail:
24187 return NULL;
24188 }
24189
24190
24191 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24192 PyObject *resultobj;
24193 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24194 wxTimeSpan *result;
24195 PyObject * obj0 = 0 ;
24196 char *kwnames[] = {
24197 (char *) "self", NULL
24198 };
24199
24200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24202 if (SWIG_arg_fail(1)) SWIG_fail;
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 {
24206 wxTimeSpan &_result_ref = (arg1)->Neg();
24207 result = (wxTimeSpan *) &_result_ref;
24208 }
24209
24210 wxPyEndAllowThreads(__tstate);
24211 if (PyErr_Occurred()) SWIG_fail;
24212 }
24213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24214 return resultobj;
24215 fail:
24216 return NULL;
24217 }
24218
24219
24220 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24221 PyObject *resultobj;
24222 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24223 wxTimeSpan result;
24224 PyObject * obj0 = 0 ;
24225 char *kwnames[] = {
24226 (char *) "self", NULL
24227 };
24228
24229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24231 if (SWIG_arg_fail(1)) SWIG_fail;
24232 {
24233 PyThreadState* __tstate = wxPyBeginAllowThreads();
24234 result = ((wxTimeSpan const *)arg1)->Abs();
24235
24236 wxPyEndAllowThreads(__tstate);
24237 if (PyErr_Occurred()) SWIG_fail;
24238 }
24239 {
24240 wxTimeSpan * resultptr;
24241 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24243 }
24244 return resultobj;
24245 fail:
24246 return NULL;
24247 }
24248
24249
24250 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24251 PyObject *resultobj;
24252 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24253 wxTimeSpan *arg2 = 0 ;
24254 wxTimeSpan *result;
24255 PyObject * obj0 = 0 ;
24256 PyObject * obj1 = 0 ;
24257 char *kwnames[] = {
24258 (char *) "self",(char *) "diff", NULL
24259 };
24260
24261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24263 if (SWIG_arg_fail(1)) SWIG_fail;
24264 {
24265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24266 if (SWIG_arg_fail(2)) SWIG_fail;
24267 if (arg2 == NULL) {
24268 SWIG_null_ref("wxTimeSpan");
24269 }
24270 if (SWIG_arg_fail(2)) SWIG_fail;
24271 }
24272 {
24273 PyThreadState* __tstate = wxPyBeginAllowThreads();
24274 {
24275 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
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, 1);
24283 return resultobj;
24284 fail:
24285 return NULL;
24286 }
24287
24288
24289 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24290 PyObject *resultobj;
24291 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24292 wxTimeSpan *arg2 = 0 ;
24293 wxTimeSpan *result;
24294 PyObject * obj0 = 0 ;
24295 PyObject * obj1 = 0 ;
24296 char *kwnames[] = {
24297 (char *) "self",(char *) "diff", NULL
24298 };
24299
24300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24302 if (SWIG_arg_fail(1)) SWIG_fail;
24303 {
24304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24305 if (SWIG_arg_fail(2)) SWIG_fail;
24306 if (arg2 == NULL) {
24307 SWIG_null_ref("wxTimeSpan");
24308 }
24309 if (SWIG_arg_fail(2)) SWIG_fail;
24310 }
24311 {
24312 PyThreadState* __tstate = wxPyBeginAllowThreads();
24313 {
24314 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24315 result = (wxTimeSpan *) &_result_ref;
24316 }
24317
24318 wxPyEndAllowThreads(__tstate);
24319 if (PyErr_Occurred()) SWIG_fail;
24320 }
24321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24322 return resultobj;
24323 fail:
24324 return NULL;
24325 }
24326
24327
24328 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24329 PyObject *resultobj;
24330 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24331 int arg2 ;
24332 wxTimeSpan *result;
24333 PyObject * obj0 = 0 ;
24334 PyObject * obj1 = 0 ;
24335 char *kwnames[] = {
24336 (char *) "self",(char *) "n", NULL
24337 };
24338
24339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24341 if (SWIG_arg_fail(1)) SWIG_fail;
24342 {
24343 arg2 = (int)(SWIG_As_int(obj1));
24344 if (SWIG_arg_fail(2)) SWIG_fail;
24345 }
24346 {
24347 PyThreadState* __tstate = wxPyBeginAllowThreads();
24348 {
24349 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24350 result = (wxTimeSpan *) &_result_ref;
24351 }
24352
24353 wxPyEndAllowThreads(__tstate);
24354 if (PyErr_Occurred()) SWIG_fail;
24355 }
24356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24364 PyObject *resultobj;
24365 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24366 wxTimeSpan *result;
24367 PyObject * obj0 = 0 ;
24368 char *kwnames[] = {
24369 (char *) "self", NULL
24370 };
24371
24372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24374 if (SWIG_arg_fail(1)) SWIG_fail;
24375 {
24376 PyThreadState* __tstate = wxPyBeginAllowThreads();
24377 {
24378 wxTimeSpan &_result_ref = (arg1)->operator -();
24379 result = (wxTimeSpan *) &_result_ref;
24380 }
24381
24382 wxPyEndAllowThreads(__tstate);
24383 if (PyErr_Occurred()) SWIG_fail;
24384 }
24385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24386 return resultobj;
24387 fail:
24388 return NULL;
24389 }
24390
24391
24392 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24393 PyObject *resultobj;
24394 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24395 wxTimeSpan *arg2 = 0 ;
24396 wxTimeSpan result;
24397 PyObject * obj0 = 0 ;
24398 PyObject * obj1 = 0 ;
24399 char *kwnames[] = {
24400 (char *) "self",(char *) "other", NULL
24401 };
24402
24403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24405 if (SWIG_arg_fail(1)) SWIG_fail;
24406 {
24407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24408 if (SWIG_arg_fail(2)) SWIG_fail;
24409 if (arg2 == NULL) {
24410 SWIG_null_ref("wxTimeSpan");
24411 }
24412 if (SWIG_arg_fail(2)) SWIG_fail;
24413 }
24414 {
24415 PyThreadState* __tstate = wxPyBeginAllowThreads();
24416 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24417
24418 wxPyEndAllowThreads(__tstate);
24419 if (PyErr_Occurred()) SWIG_fail;
24420 }
24421 {
24422 wxTimeSpan * resultptr;
24423 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24424 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24425 }
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24433 PyObject *resultobj;
24434 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24435 wxTimeSpan *arg2 = 0 ;
24436 wxTimeSpan result;
24437 PyObject * obj0 = 0 ;
24438 PyObject * obj1 = 0 ;
24439 char *kwnames[] = {
24440 (char *) "self",(char *) "other", NULL
24441 };
24442
24443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24445 if (SWIG_arg_fail(1)) SWIG_fail;
24446 {
24447 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24448 if (SWIG_arg_fail(2)) SWIG_fail;
24449 if (arg2 == NULL) {
24450 SWIG_null_ref("wxTimeSpan");
24451 }
24452 if (SWIG_arg_fail(2)) SWIG_fail;
24453 }
24454 {
24455 PyThreadState* __tstate = wxPyBeginAllowThreads();
24456 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24457
24458 wxPyEndAllowThreads(__tstate);
24459 if (PyErr_Occurred()) SWIG_fail;
24460 }
24461 {
24462 wxTimeSpan * resultptr;
24463 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24464 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24465 }
24466 return resultobj;
24467 fail:
24468 return NULL;
24469 }
24470
24471
24472 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24473 PyObject *resultobj;
24474 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24475 int arg2 ;
24476 wxTimeSpan result;
24477 PyObject * obj0 = 0 ;
24478 PyObject * obj1 = 0 ;
24479 char *kwnames[] = {
24480 (char *) "self",(char *) "n", NULL
24481 };
24482
24483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24485 if (SWIG_arg_fail(1)) SWIG_fail;
24486 {
24487 arg2 = (int)(SWIG_As_int(obj1));
24488 if (SWIG_arg_fail(2)) SWIG_fail;
24489 }
24490 {
24491 PyThreadState* __tstate = wxPyBeginAllowThreads();
24492 result = wxTimeSpan___mul__(arg1,arg2);
24493
24494 wxPyEndAllowThreads(__tstate);
24495 if (PyErr_Occurred()) SWIG_fail;
24496 }
24497 {
24498 wxTimeSpan * resultptr;
24499 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24500 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24501 }
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24509 PyObject *resultobj;
24510 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24511 int arg2 ;
24512 wxTimeSpan result;
24513 PyObject * obj0 = 0 ;
24514 PyObject * obj1 = 0 ;
24515 char *kwnames[] = {
24516 (char *) "self",(char *) "n", NULL
24517 };
24518
24519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24521 if (SWIG_arg_fail(1)) SWIG_fail;
24522 {
24523 arg2 = (int)(SWIG_As_int(obj1));
24524 if (SWIG_arg_fail(2)) SWIG_fail;
24525 }
24526 {
24527 PyThreadState* __tstate = wxPyBeginAllowThreads();
24528 result = wxTimeSpan___rmul__(arg1,arg2);
24529
24530 wxPyEndAllowThreads(__tstate);
24531 if (PyErr_Occurred()) SWIG_fail;
24532 }
24533 {
24534 wxTimeSpan * resultptr;
24535 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24536 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24537 }
24538 return resultobj;
24539 fail:
24540 return NULL;
24541 }
24542
24543
24544 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24545 PyObject *resultobj;
24546 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24547 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24548 bool result;
24549 PyObject * obj0 = 0 ;
24550 PyObject * obj1 = 0 ;
24551 char *kwnames[] = {
24552 (char *) "self",(char *) "other", NULL
24553 };
24554
24555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24557 if (SWIG_arg_fail(1)) SWIG_fail;
24558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24559 if (SWIG_arg_fail(2)) SWIG_fail;
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24563
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 {
24568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24569 }
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj;
24578 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24579 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24580 bool result;
24581 PyObject * obj0 = 0 ;
24582 PyObject * obj1 = 0 ;
24583 char *kwnames[] = {
24584 (char *) "self",(char *) "other", NULL
24585 };
24586
24587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24589 if (SWIG_arg_fail(1)) SWIG_fail;
24590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24591 if (SWIG_arg_fail(2)) SWIG_fail;
24592 {
24593 PyThreadState* __tstate = wxPyBeginAllowThreads();
24594 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24595
24596 wxPyEndAllowThreads(__tstate);
24597 if (PyErr_Occurred()) SWIG_fail;
24598 }
24599 {
24600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24601 }
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24609 PyObject *resultobj;
24610 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24611 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24612 bool result;
24613 PyObject * obj0 = 0 ;
24614 PyObject * obj1 = 0 ;
24615 char *kwnames[] = {
24616 (char *) "self",(char *) "other", NULL
24617 };
24618
24619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24621 if (SWIG_arg_fail(1)) SWIG_fail;
24622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24623 if (SWIG_arg_fail(2)) SWIG_fail;
24624 {
24625 PyThreadState* __tstate = wxPyBeginAllowThreads();
24626 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24627
24628 wxPyEndAllowThreads(__tstate);
24629 if (PyErr_Occurred()) SWIG_fail;
24630 }
24631 {
24632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24633 }
24634 return resultobj;
24635 fail:
24636 return NULL;
24637 }
24638
24639
24640 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj;
24642 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24643 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24644 bool result;
24645 PyObject * obj0 = 0 ;
24646 PyObject * obj1 = 0 ;
24647 char *kwnames[] = {
24648 (char *) "self",(char *) "other", NULL
24649 };
24650
24651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24653 if (SWIG_arg_fail(1)) SWIG_fail;
24654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24655 if (SWIG_arg_fail(2)) SWIG_fail;
24656 {
24657 PyThreadState* __tstate = wxPyBeginAllowThreads();
24658 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24659
24660 wxPyEndAllowThreads(__tstate);
24661 if (PyErr_Occurred()) SWIG_fail;
24662 }
24663 {
24664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24665 }
24666 return resultobj;
24667 fail:
24668 return NULL;
24669 }
24670
24671
24672 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24673 PyObject *resultobj;
24674 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24675 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24676 bool result;
24677 PyObject * obj0 = 0 ;
24678 PyObject * obj1 = 0 ;
24679 char *kwnames[] = {
24680 (char *) "self",(char *) "other", NULL
24681 };
24682
24683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24685 if (SWIG_arg_fail(1)) SWIG_fail;
24686 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24687 if (SWIG_arg_fail(2)) SWIG_fail;
24688 {
24689 PyThreadState* __tstate = wxPyBeginAllowThreads();
24690 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24691
24692 wxPyEndAllowThreads(__tstate);
24693 if (PyErr_Occurred()) SWIG_fail;
24694 }
24695 {
24696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24697 }
24698 return resultobj;
24699 fail:
24700 return NULL;
24701 }
24702
24703
24704 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24705 PyObject *resultobj;
24706 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24707 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24708 bool result;
24709 PyObject * obj0 = 0 ;
24710 PyObject * obj1 = 0 ;
24711 char *kwnames[] = {
24712 (char *) "self",(char *) "other", NULL
24713 };
24714
24715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24717 if (SWIG_arg_fail(1)) SWIG_fail;
24718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24719 if (SWIG_arg_fail(2)) SWIG_fail;
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24723
24724 wxPyEndAllowThreads(__tstate);
24725 if (PyErr_Occurred()) SWIG_fail;
24726 }
24727 {
24728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24729 }
24730 return resultobj;
24731 fail:
24732 return NULL;
24733 }
24734
24735
24736 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24737 PyObject *resultobj;
24738 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24739 bool result;
24740 PyObject * obj0 = 0 ;
24741 char *kwnames[] = {
24742 (char *) "self", NULL
24743 };
24744
24745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24747 if (SWIG_arg_fail(1)) SWIG_fail;
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24751
24752 wxPyEndAllowThreads(__tstate);
24753 if (PyErr_Occurred()) SWIG_fail;
24754 }
24755 {
24756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24757 }
24758 return resultobj;
24759 fail:
24760 return NULL;
24761 }
24762
24763
24764 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24765 PyObject *resultobj;
24766 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24767 bool result;
24768 PyObject * obj0 = 0 ;
24769 char *kwnames[] = {
24770 (char *) "self", NULL
24771 };
24772
24773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24775 if (SWIG_arg_fail(1)) SWIG_fail;
24776 {
24777 PyThreadState* __tstate = wxPyBeginAllowThreads();
24778 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24779
24780 wxPyEndAllowThreads(__tstate);
24781 if (PyErr_Occurred()) SWIG_fail;
24782 }
24783 {
24784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24785 }
24786 return resultobj;
24787 fail:
24788 return NULL;
24789 }
24790
24791
24792 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24793 PyObject *resultobj;
24794 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24795 bool result;
24796 PyObject * obj0 = 0 ;
24797 char *kwnames[] = {
24798 (char *) "self", NULL
24799 };
24800
24801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24803 if (SWIG_arg_fail(1)) SWIG_fail;
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24807
24808 wxPyEndAllowThreads(__tstate);
24809 if (PyErr_Occurred()) SWIG_fail;
24810 }
24811 {
24812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24813 }
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24821 PyObject *resultobj;
24822 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24823 wxTimeSpan *arg2 = 0 ;
24824 bool result;
24825 PyObject * obj0 = 0 ;
24826 PyObject * obj1 = 0 ;
24827 char *kwnames[] = {
24828 (char *) "self",(char *) "ts", NULL
24829 };
24830
24831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24833 if (SWIG_arg_fail(1)) SWIG_fail;
24834 {
24835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24836 if (SWIG_arg_fail(2)) SWIG_fail;
24837 if (arg2 == NULL) {
24838 SWIG_null_ref("wxTimeSpan");
24839 }
24840 if (SWIG_arg_fail(2)) SWIG_fail;
24841 }
24842 {
24843 PyThreadState* __tstate = wxPyBeginAllowThreads();
24844 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24845
24846 wxPyEndAllowThreads(__tstate);
24847 if (PyErr_Occurred()) SWIG_fail;
24848 }
24849 {
24850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24851 }
24852 return resultobj;
24853 fail:
24854 return NULL;
24855 }
24856
24857
24858 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24859 PyObject *resultobj;
24860 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24861 wxTimeSpan *arg2 = 0 ;
24862 bool result;
24863 PyObject * obj0 = 0 ;
24864 PyObject * obj1 = 0 ;
24865 char *kwnames[] = {
24866 (char *) "self",(char *) "ts", NULL
24867 };
24868
24869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24871 if (SWIG_arg_fail(1)) SWIG_fail;
24872 {
24873 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24874 if (SWIG_arg_fail(2)) SWIG_fail;
24875 if (arg2 == NULL) {
24876 SWIG_null_ref("wxTimeSpan");
24877 }
24878 if (SWIG_arg_fail(2)) SWIG_fail;
24879 }
24880 {
24881 PyThreadState* __tstate = wxPyBeginAllowThreads();
24882 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24883
24884 wxPyEndAllowThreads(__tstate);
24885 if (PyErr_Occurred()) SWIG_fail;
24886 }
24887 {
24888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24889 }
24890 return resultobj;
24891 fail:
24892 return NULL;
24893 }
24894
24895
24896 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24897 PyObject *resultobj;
24898 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24899 wxTimeSpan *arg2 = 0 ;
24900 bool result;
24901 PyObject * obj0 = 0 ;
24902 PyObject * obj1 = 0 ;
24903 char *kwnames[] = {
24904 (char *) "self",(char *) "t", NULL
24905 };
24906
24907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24909 if (SWIG_arg_fail(1)) SWIG_fail;
24910 {
24911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24912 if (SWIG_arg_fail(2)) SWIG_fail;
24913 if (arg2 == NULL) {
24914 SWIG_null_ref("wxTimeSpan");
24915 }
24916 if (SWIG_arg_fail(2)) SWIG_fail;
24917 }
24918 {
24919 PyThreadState* __tstate = wxPyBeginAllowThreads();
24920 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24921
24922 wxPyEndAllowThreads(__tstate);
24923 if (PyErr_Occurred()) SWIG_fail;
24924 }
24925 {
24926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24927 }
24928 return resultobj;
24929 fail:
24930 return NULL;
24931 }
24932
24933
24934 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24935 PyObject *resultobj;
24936 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24937 int result;
24938 PyObject * obj0 = 0 ;
24939 char *kwnames[] = {
24940 (char *) "self", NULL
24941 };
24942
24943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24945 if (SWIG_arg_fail(1)) SWIG_fail;
24946 {
24947 PyThreadState* __tstate = wxPyBeginAllowThreads();
24948 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24949
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 {
24954 resultobj = SWIG_From_int((int)(result));
24955 }
24956 return resultobj;
24957 fail:
24958 return NULL;
24959 }
24960
24961
24962 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24963 PyObject *resultobj;
24964 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24965 int result;
24966 PyObject * obj0 = 0 ;
24967 char *kwnames[] = {
24968 (char *) "self", NULL
24969 };
24970
24971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24973 if (SWIG_arg_fail(1)) SWIG_fail;
24974 {
24975 PyThreadState* __tstate = wxPyBeginAllowThreads();
24976 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24977
24978 wxPyEndAllowThreads(__tstate);
24979 if (PyErr_Occurred()) SWIG_fail;
24980 }
24981 {
24982 resultobj = SWIG_From_int((int)(result));
24983 }
24984 return resultobj;
24985 fail:
24986 return NULL;
24987 }
24988
24989
24990 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24991 PyObject *resultobj;
24992 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24993 int result;
24994 PyObject * obj0 = 0 ;
24995 char *kwnames[] = {
24996 (char *) "self", NULL
24997 };
24998
24999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25001 if (SWIG_arg_fail(1)) SWIG_fail;
25002 {
25003 PyThreadState* __tstate = wxPyBeginAllowThreads();
25004 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25005
25006 wxPyEndAllowThreads(__tstate);
25007 if (PyErr_Occurred()) SWIG_fail;
25008 }
25009 {
25010 resultobj = SWIG_From_int((int)(result));
25011 }
25012 return resultobj;
25013 fail:
25014 return NULL;
25015 }
25016
25017
25018 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25019 PyObject *resultobj;
25020 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25021 int result;
25022 PyObject * obj0 = 0 ;
25023 char *kwnames[] = {
25024 (char *) "self", NULL
25025 };
25026
25027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25029 if (SWIG_arg_fail(1)) SWIG_fail;
25030 {
25031 PyThreadState* __tstate = wxPyBeginAllowThreads();
25032 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25033
25034 wxPyEndAllowThreads(__tstate);
25035 if (PyErr_Occurred()) SWIG_fail;
25036 }
25037 {
25038 resultobj = SWIG_From_int((int)(result));
25039 }
25040 return resultobj;
25041 fail:
25042 return NULL;
25043 }
25044
25045
25046 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25047 PyObject *resultobj;
25048 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25049 wxLongLong result;
25050 PyObject * obj0 = 0 ;
25051 char *kwnames[] = {
25052 (char *) "self", NULL
25053 };
25054
25055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25057 if (SWIG_arg_fail(1)) SWIG_fail;
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25061
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 {
25066 PyObject *hi, *lo, *shifter, *shifted;
25067 hi = PyLong_FromLong( (&result)->GetHi() );
25068 lo = PyLong_FromLong( (&result)->GetLo() );
25069 shifter = PyLong_FromLong(32);
25070 shifted = PyNumber_Lshift(hi, shifter);
25071 resultobj = PyNumber_Or(shifted, lo);
25072 Py_DECREF(hi);
25073 Py_DECREF(lo);
25074 Py_DECREF(shifter);
25075 Py_DECREF(shifted);
25076 }
25077 return resultobj;
25078 fail:
25079 return NULL;
25080 }
25081
25082
25083 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25084 PyObject *resultobj;
25085 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25086 wxLongLong result;
25087 PyObject * obj0 = 0 ;
25088 char *kwnames[] = {
25089 (char *) "self", NULL
25090 };
25091
25092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25094 if (SWIG_arg_fail(1)) SWIG_fail;
25095 {
25096 PyThreadState* __tstate = wxPyBeginAllowThreads();
25097 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25098
25099 wxPyEndAllowThreads(__tstate);
25100 if (PyErr_Occurred()) SWIG_fail;
25101 }
25102 {
25103 PyObject *hi, *lo, *shifter, *shifted;
25104 hi = PyLong_FromLong( (&result)->GetHi() );
25105 lo = PyLong_FromLong( (&result)->GetLo() );
25106 shifter = PyLong_FromLong(32);
25107 shifted = PyNumber_Lshift(hi, shifter);
25108 resultobj = PyNumber_Or(shifted, lo);
25109 Py_DECREF(hi);
25110 Py_DECREF(lo);
25111 Py_DECREF(shifter);
25112 Py_DECREF(shifted);
25113 }
25114 return resultobj;
25115 fail:
25116 return NULL;
25117 }
25118
25119
25120 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25121 PyObject *resultobj;
25122 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25123 wxString const &arg2_defvalue = wxPyTimeSpanFormatStr ;
25124 wxString *arg2 = (wxString *) &arg2_defvalue ;
25125 wxString result;
25126 bool temp2 = false ;
25127 PyObject * obj0 = 0 ;
25128 PyObject * obj1 = 0 ;
25129 char *kwnames[] = {
25130 (char *) "self",(char *) "format", NULL
25131 };
25132
25133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25135 if (SWIG_arg_fail(1)) SWIG_fail;
25136 if (obj1) {
25137 {
25138 arg2 = wxString_in_helper(obj1);
25139 if (arg2 == NULL) SWIG_fail;
25140 temp2 = true;
25141 }
25142 }
25143 {
25144 PyThreadState* __tstate = wxPyBeginAllowThreads();
25145 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25146
25147 wxPyEndAllowThreads(__tstate);
25148 if (PyErr_Occurred()) SWIG_fail;
25149 }
25150 {
25151 #if wxUSE_UNICODE
25152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25153 #else
25154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25155 #endif
25156 }
25157 {
25158 if (temp2)
25159 delete arg2;
25160 }
25161 return resultobj;
25162 fail:
25163 {
25164 if (temp2)
25165 delete arg2;
25166 }
25167 return NULL;
25168 }
25169
25170
25171 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25172 PyObject *obj;
25173 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25174 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25175 Py_INCREF(obj);
25176 return Py_BuildValue((char *)"");
25177 }
25178 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25179 PyObject *resultobj;
25180 int arg1 = (int) 0 ;
25181 int arg2 = (int) 0 ;
25182 int arg3 = (int) 0 ;
25183 int arg4 = (int) 0 ;
25184 wxDateSpan *result;
25185 PyObject * obj0 = 0 ;
25186 PyObject * obj1 = 0 ;
25187 PyObject * obj2 = 0 ;
25188 PyObject * obj3 = 0 ;
25189 char *kwnames[] = {
25190 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25191 };
25192
25193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25194 if (obj0) {
25195 {
25196 arg1 = (int)(SWIG_As_int(obj0));
25197 if (SWIG_arg_fail(1)) SWIG_fail;
25198 }
25199 }
25200 if (obj1) {
25201 {
25202 arg2 = (int)(SWIG_As_int(obj1));
25203 if (SWIG_arg_fail(2)) SWIG_fail;
25204 }
25205 }
25206 if (obj2) {
25207 {
25208 arg3 = (int)(SWIG_As_int(obj2));
25209 if (SWIG_arg_fail(3)) SWIG_fail;
25210 }
25211 }
25212 if (obj3) {
25213 {
25214 arg4 = (int)(SWIG_As_int(obj3));
25215 if (SWIG_arg_fail(4)) SWIG_fail;
25216 }
25217 }
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25221
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25233 PyObject *resultobj;
25234 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25235 PyObject * obj0 = 0 ;
25236 char *kwnames[] = {
25237 (char *) "self", NULL
25238 };
25239
25240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25242 if (SWIG_arg_fail(1)) SWIG_fail;
25243 {
25244 PyThreadState* __tstate = wxPyBeginAllowThreads();
25245 delete arg1;
25246
25247 wxPyEndAllowThreads(__tstate);
25248 if (PyErr_Occurred()) SWIG_fail;
25249 }
25250 Py_INCREF(Py_None); resultobj = Py_None;
25251 return resultobj;
25252 fail:
25253 return NULL;
25254 }
25255
25256
25257 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25258 PyObject *resultobj;
25259 int arg1 ;
25260 wxDateSpan result;
25261 PyObject * obj0 = 0 ;
25262 char *kwnames[] = {
25263 (char *) "days", NULL
25264 };
25265
25266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25267 {
25268 arg1 = (int)(SWIG_As_int(obj0));
25269 if (SWIG_arg_fail(1)) SWIG_fail;
25270 }
25271 {
25272 PyThreadState* __tstate = wxPyBeginAllowThreads();
25273 result = wxDateSpan::Days(arg1);
25274
25275 wxPyEndAllowThreads(__tstate);
25276 if (PyErr_Occurred()) SWIG_fail;
25277 }
25278 {
25279 wxDateSpan * resultptr;
25280 resultptr = new wxDateSpan((wxDateSpan &)(result));
25281 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25282 }
25283 return resultobj;
25284 fail:
25285 return NULL;
25286 }
25287
25288
25289 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25290 PyObject *resultobj;
25291 wxDateSpan result;
25292 char *kwnames[] = {
25293 NULL
25294 };
25295
25296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25297 {
25298 PyThreadState* __tstate = wxPyBeginAllowThreads();
25299 result = wxDateSpan::Day();
25300
25301 wxPyEndAllowThreads(__tstate);
25302 if (PyErr_Occurred()) SWIG_fail;
25303 }
25304 {
25305 wxDateSpan * resultptr;
25306 resultptr = new wxDateSpan((wxDateSpan &)(result));
25307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25308 }
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25316 PyObject *resultobj;
25317 int arg1 ;
25318 wxDateSpan result;
25319 PyObject * obj0 = 0 ;
25320 char *kwnames[] = {
25321 (char *) "weeks", NULL
25322 };
25323
25324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25325 {
25326 arg1 = (int)(SWIG_As_int(obj0));
25327 if (SWIG_arg_fail(1)) SWIG_fail;
25328 }
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 result = wxDateSpan::Weeks(arg1);
25332
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 {
25337 wxDateSpan * resultptr;
25338 resultptr = new wxDateSpan((wxDateSpan &)(result));
25339 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25340 }
25341 return resultobj;
25342 fail:
25343 return NULL;
25344 }
25345
25346
25347 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25348 PyObject *resultobj;
25349 wxDateSpan result;
25350 char *kwnames[] = {
25351 NULL
25352 };
25353
25354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25355 {
25356 PyThreadState* __tstate = wxPyBeginAllowThreads();
25357 result = wxDateSpan::Week();
25358
25359 wxPyEndAllowThreads(__tstate);
25360 if (PyErr_Occurred()) SWIG_fail;
25361 }
25362 {
25363 wxDateSpan * resultptr;
25364 resultptr = new wxDateSpan((wxDateSpan &)(result));
25365 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25366 }
25367 return resultobj;
25368 fail:
25369 return NULL;
25370 }
25371
25372
25373 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25374 PyObject *resultobj;
25375 int arg1 ;
25376 wxDateSpan result;
25377 PyObject * obj0 = 0 ;
25378 char *kwnames[] = {
25379 (char *) "mon", NULL
25380 };
25381
25382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25383 {
25384 arg1 = (int)(SWIG_As_int(obj0));
25385 if (SWIG_arg_fail(1)) SWIG_fail;
25386 }
25387 {
25388 PyThreadState* __tstate = wxPyBeginAllowThreads();
25389 result = wxDateSpan::Months(arg1);
25390
25391 wxPyEndAllowThreads(__tstate);
25392 if (PyErr_Occurred()) SWIG_fail;
25393 }
25394 {
25395 wxDateSpan * resultptr;
25396 resultptr = new wxDateSpan((wxDateSpan &)(result));
25397 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25398 }
25399 return resultobj;
25400 fail:
25401 return NULL;
25402 }
25403
25404
25405 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25406 PyObject *resultobj;
25407 wxDateSpan result;
25408 char *kwnames[] = {
25409 NULL
25410 };
25411
25412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25413 {
25414 PyThreadState* __tstate = wxPyBeginAllowThreads();
25415 result = wxDateSpan::Month();
25416
25417 wxPyEndAllowThreads(__tstate);
25418 if (PyErr_Occurred()) SWIG_fail;
25419 }
25420 {
25421 wxDateSpan * resultptr;
25422 resultptr = new wxDateSpan((wxDateSpan &)(result));
25423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25424 }
25425 return resultobj;
25426 fail:
25427 return NULL;
25428 }
25429
25430
25431 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25432 PyObject *resultobj;
25433 int arg1 ;
25434 wxDateSpan result;
25435 PyObject * obj0 = 0 ;
25436 char *kwnames[] = {
25437 (char *) "years", NULL
25438 };
25439
25440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25441 {
25442 arg1 = (int)(SWIG_As_int(obj0));
25443 if (SWIG_arg_fail(1)) SWIG_fail;
25444 }
25445 {
25446 PyThreadState* __tstate = wxPyBeginAllowThreads();
25447 result = wxDateSpan::Years(arg1);
25448
25449 wxPyEndAllowThreads(__tstate);
25450 if (PyErr_Occurred()) SWIG_fail;
25451 }
25452 {
25453 wxDateSpan * resultptr;
25454 resultptr = new wxDateSpan((wxDateSpan &)(result));
25455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25456 }
25457 return resultobj;
25458 fail:
25459 return NULL;
25460 }
25461
25462
25463 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25464 PyObject *resultobj;
25465 wxDateSpan result;
25466 char *kwnames[] = {
25467 NULL
25468 };
25469
25470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25471 {
25472 PyThreadState* __tstate = wxPyBeginAllowThreads();
25473 result = wxDateSpan::Year();
25474
25475 wxPyEndAllowThreads(__tstate);
25476 if (PyErr_Occurred()) SWIG_fail;
25477 }
25478 {
25479 wxDateSpan * resultptr;
25480 resultptr = new wxDateSpan((wxDateSpan &)(result));
25481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25482 }
25483 return resultobj;
25484 fail:
25485 return NULL;
25486 }
25487
25488
25489 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25490 PyObject *resultobj;
25491 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25492 int arg2 ;
25493 wxDateSpan *result;
25494 PyObject * obj0 = 0 ;
25495 PyObject * obj1 = 0 ;
25496 char *kwnames[] = {
25497 (char *) "self",(char *) "n", NULL
25498 };
25499
25500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25502 if (SWIG_arg_fail(1)) SWIG_fail;
25503 {
25504 arg2 = (int)(SWIG_As_int(obj1));
25505 if (SWIG_arg_fail(2)) SWIG_fail;
25506 }
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 {
25510 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25511 result = (wxDateSpan *) &_result_ref;
25512 }
25513
25514 wxPyEndAllowThreads(__tstate);
25515 if (PyErr_Occurred()) SWIG_fail;
25516 }
25517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25525 PyObject *resultobj;
25526 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25527 int arg2 ;
25528 wxDateSpan *result;
25529 PyObject * obj0 = 0 ;
25530 PyObject * obj1 = 0 ;
25531 char *kwnames[] = {
25532 (char *) "self",(char *) "n", NULL
25533 };
25534
25535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25537 if (SWIG_arg_fail(1)) SWIG_fail;
25538 {
25539 arg2 = (int)(SWIG_As_int(obj1));
25540 if (SWIG_arg_fail(2)) SWIG_fail;
25541 }
25542 {
25543 PyThreadState* __tstate = wxPyBeginAllowThreads();
25544 {
25545 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25546 result = (wxDateSpan *) &_result_ref;
25547 }
25548
25549 wxPyEndAllowThreads(__tstate);
25550 if (PyErr_Occurred()) SWIG_fail;
25551 }
25552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25553 return resultobj;
25554 fail:
25555 return NULL;
25556 }
25557
25558
25559 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25560 PyObject *resultobj;
25561 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25562 int arg2 ;
25563 wxDateSpan *result;
25564 PyObject * obj0 = 0 ;
25565 PyObject * obj1 = 0 ;
25566 char *kwnames[] = {
25567 (char *) "self",(char *) "n", NULL
25568 };
25569
25570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25572 if (SWIG_arg_fail(1)) SWIG_fail;
25573 {
25574 arg2 = (int)(SWIG_As_int(obj1));
25575 if (SWIG_arg_fail(2)) SWIG_fail;
25576 }
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 {
25580 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25581 result = (wxDateSpan *) &_result_ref;
25582 }
25583
25584 wxPyEndAllowThreads(__tstate);
25585 if (PyErr_Occurred()) SWIG_fail;
25586 }
25587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25588 return resultobj;
25589 fail:
25590 return NULL;
25591 }
25592
25593
25594 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25595 PyObject *resultobj;
25596 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25597 int arg2 ;
25598 wxDateSpan *result;
25599 PyObject * obj0 = 0 ;
25600 PyObject * obj1 = 0 ;
25601 char *kwnames[] = {
25602 (char *) "self",(char *) "n", NULL
25603 };
25604
25605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25607 if (SWIG_arg_fail(1)) SWIG_fail;
25608 {
25609 arg2 = (int)(SWIG_As_int(obj1));
25610 if (SWIG_arg_fail(2)) SWIG_fail;
25611 }
25612 {
25613 PyThreadState* __tstate = wxPyBeginAllowThreads();
25614 {
25615 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25616 result = (wxDateSpan *) &_result_ref;
25617 }
25618
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25623 return resultobj;
25624 fail:
25625 return NULL;
25626 }
25627
25628
25629 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25630 PyObject *resultobj;
25631 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25632 int result;
25633 PyObject * obj0 = 0 ;
25634 char *kwnames[] = {
25635 (char *) "self", NULL
25636 };
25637
25638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25640 if (SWIG_arg_fail(1)) SWIG_fail;
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 result = (int)((wxDateSpan const *)arg1)->GetYears();
25644
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 {
25649 resultobj = SWIG_From_int((int)(result));
25650 }
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25658 PyObject *resultobj;
25659 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25660 int result;
25661 PyObject * obj0 = 0 ;
25662 char *kwnames[] = {
25663 (char *) "self", NULL
25664 };
25665
25666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25668 if (SWIG_arg_fail(1)) SWIG_fail;
25669 {
25670 PyThreadState* __tstate = wxPyBeginAllowThreads();
25671 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25672
25673 wxPyEndAllowThreads(__tstate);
25674 if (PyErr_Occurred()) SWIG_fail;
25675 }
25676 {
25677 resultobj = SWIG_From_int((int)(result));
25678 }
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25686 PyObject *resultobj;
25687 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25688 int result;
25689 PyObject * obj0 = 0 ;
25690 char *kwnames[] = {
25691 (char *) "self", NULL
25692 };
25693
25694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25696 if (SWIG_arg_fail(1)) SWIG_fail;
25697 {
25698 PyThreadState* __tstate = wxPyBeginAllowThreads();
25699 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25700
25701 wxPyEndAllowThreads(__tstate);
25702 if (PyErr_Occurred()) SWIG_fail;
25703 }
25704 {
25705 resultobj = SWIG_From_int((int)(result));
25706 }
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25714 PyObject *resultobj;
25715 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25716 int result;
25717 PyObject * obj0 = 0 ;
25718 char *kwnames[] = {
25719 (char *) "self", NULL
25720 };
25721
25722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25724 if (SWIG_arg_fail(1)) SWIG_fail;
25725 {
25726 PyThreadState* __tstate = wxPyBeginAllowThreads();
25727 result = (int)((wxDateSpan const *)arg1)->GetDays();
25728
25729 wxPyEndAllowThreads(__tstate);
25730 if (PyErr_Occurred()) SWIG_fail;
25731 }
25732 {
25733 resultobj = SWIG_From_int((int)(result));
25734 }
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25742 PyObject *resultobj;
25743 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25744 int result;
25745 PyObject * obj0 = 0 ;
25746 char *kwnames[] = {
25747 (char *) "self", NULL
25748 };
25749
25750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25752 if (SWIG_arg_fail(1)) SWIG_fail;
25753 {
25754 PyThreadState* __tstate = wxPyBeginAllowThreads();
25755 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25756
25757 wxPyEndAllowThreads(__tstate);
25758 if (PyErr_Occurred()) SWIG_fail;
25759 }
25760 {
25761 resultobj = SWIG_From_int((int)(result));
25762 }
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25770 PyObject *resultobj;
25771 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25772 wxDateSpan *arg2 = 0 ;
25773 wxDateSpan *result;
25774 PyObject * obj0 = 0 ;
25775 PyObject * obj1 = 0 ;
25776 char *kwnames[] = {
25777 (char *) "self",(char *) "other", NULL
25778 };
25779
25780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25782 if (SWIG_arg_fail(1)) SWIG_fail;
25783 {
25784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25785 if (SWIG_arg_fail(2)) SWIG_fail;
25786 if (arg2 == NULL) {
25787 SWIG_null_ref("wxDateSpan");
25788 }
25789 if (SWIG_arg_fail(2)) SWIG_fail;
25790 }
25791 {
25792 PyThreadState* __tstate = wxPyBeginAllowThreads();
25793 {
25794 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25795 result = (wxDateSpan *) &_result_ref;
25796 }
25797
25798 wxPyEndAllowThreads(__tstate);
25799 if (PyErr_Occurred()) SWIG_fail;
25800 }
25801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25802 return resultobj;
25803 fail:
25804 return NULL;
25805 }
25806
25807
25808 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25809 PyObject *resultobj;
25810 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25811 wxDateSpan *arg2 = 0 ;
25812 wxDateSpan *result;
25813 PyObject * obj0 = 0 ;
25814 PyObject * obj1 = 0 ;
25815 char *kwnames[] = {
25816 (char *) "self",(char *) "other", NULL
25817 };
25818
25819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25824 if (SWIG_arg_fail(2)) SWIG_fail;
25825 if (arg2 == NULL) {
25826 SWIG_null_ref("wxDateSpan");
25827 }
25828 if (SWIG_arg_fail(2)) SWIG_fail;
25829 }
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 {
25833 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25834 result = (wxDateSpan *) &_result_ref;
25835 }
25836
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25841 return resultobj;
25842 fail:
25843 return NULL;
25844 }
25845
25846
25847 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25848 PyObject *resultobj;
25849 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25850 wxDateSpan *result;
25851 PyObject * obj0 = 0 ;
25852 char *kwnames[] = {
25853 (char *) "self", NULL
25854 };
25855
25856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25858 if (SWIG_arg_fail(1)) SWIG_fail;
25859 {
25860 PyThreadState* __tstate = wxPyBeginAllowThreads();
25861 {
25862 wxDateSpan &_result_ref = (arg1)->Neg();
25863 result = (wxDateSpan *) &_result_ref;
25864 }
25865
25866 wxPyEndAllowThreads(__tstate);
25867 if (PyErr_Occurred()) SWIG_fail;
25868 }
25869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25870 return resultobj;
25871 fail:
25872 return NULL;
25873 }
25874
25875
25876 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj;
25878 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25879 int arg2 ;
25880 wxDateSpan *result;
25881 PyObject * obj0 = 0 ;
25882 PyObject * obj1 = 0 ;
25883 char *kwnames[] = {
25884 (char *) "self",(char *) "factor", NULL
25885 };
25886
25887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25889 if (SWIG_arg_fail(1)) SWIG_fail;
25890 {
25891 arg2 = (int)(SWIG_As_int(obj1));
25892 if (SWIG_arg_fail(2)) SWIG_fail;
25893 }
25894 {
25895 PyThreadState* __tstate = wxPyBeginAllowThreads();
25896 {
25897 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25898 result = (wxDateSpan *) &_result_ref;
25899 }
25900
25901 wxPyEndAllowThreads(__tstate);
25902 if (PyErr_Occurred()) SWIG_fail;
25903 }
25904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25905 return resultobj;
25906 fail:
25907 return NULL;
25908 }
25909
25910
25911 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25912 PyObject *resultobj;
25913 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25914 wxDateSpan *arg2 = 0 ;
25915 wxDateSpan *result;
25916 PyObject * obj0 = 0 ;
25917 PyObject * obj1 = 0 ;
25918 char *kwnames[] = {
25919 (char *) "self",(char *) "other", NULL
25920 };
25921
25922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25924 if (SWIG_arg_fail(1)) SWIG_fail;
25925 {
25926 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25927 if (SWIG_arg_fail(2)) SWIG_fail;
25928 if (arg2 == NULL) {
25929 SWIG_null_ref("wxDateSpan");
25930 }
25931 if (SWIG_arg_fail(2)) SWIG_fail;
25932 }
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 {
25936 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25937 result = (wxDateSpan *) &_result_ref;
25938 }
25939
25940 wxPyEndAllowThreads(__tstate);
25941 if (PyErr_Occurred()) SWIG_fail;
25942 }
25943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25951 PyObject *resultobj;
25952 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25953 wxDateSpan *arg2 = 0 ;
25954 wxDateSpan *result;
25955 PyObject * obj0 = 0 ;
25956 PyObject * obj1 = 0 ;
25957 char *kwnames[] = {
25958 (char *) "self",(char *) "other", NULL
25959 };
25960
25961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25963 if (SWIG_arg_fail(1)) SWIG_fail;
25964 {
25965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25966 if (SWIG_arg_fail(2)) SWIG_fail;
25967 if (arg2 == NULL) {
25968 SWIG_null_ref("wxDateSpan");
25969 }
25970 if (SWIG_arg_fail(2)) SWIG_fail;
25971 }
25972 {
25973 PyThreadState* __tstate = wxPyBeginAllowThreads();
25974 {
25975 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25976 result = (wxDateSpan *) &_result_ref;
25977 }
25978
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25990 PyObject *resultobj;
25991 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25992 wxDateSpan *result;
25993 PyObject * obj0 = 0 ;
25994 char *kwnames[] = {
25995 (char *) "self", NULL
25996 };
25997
25998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26000 if (SWIG_arg_fail(1)) SWIG_fail;
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 {
26004 wxDateSpan &_result_ref = (arg1)->operator -();
26005 result = (wxDateSpan *) &_result_ref;
26006 }
26007
26008 wxPyEndAllowThreads(__tstate);
26009 if (PyErr_Occurred()) SWIG_fail;
26010 }
26011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26012 return resultobj;
26013 fail:
26014 return NULL;
26015 }
26016
26017
26018 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26019 PyObject *resultobj;
26020 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26021 int arg2 ;
26022 wxDateSpan *result;
26023 PyObject * obj0 = 0 ;
26024 PyObject * obj1 = 0 ;
26025 char *kwnames[] = {
26026 (char *) "self",(char *) "factor", NULL
26027 };
26028
26029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26031 if (SWIG_arg_fail(1)) SWIG_fail;
26032 {
26033 arg2 = (int)(SWIG_As_int(obj1));
26034 if (SWIG_arg_fail(2)) SWIG_fail;
26035 }
26036 {
26037 PyThreadState* __tstate = wxPyBeginAllowThreads();
26038 {
26039 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26040 result = (wxDateSpan *) &_result_ref;
26041 }
26042
26043 wxPyEndAllowThreads(__tstate);
26044 if (PyErr_Occurred()) SWIG_fail;
26045 }
26046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26047 return resultobj;
26048 fail:
26049 return NULL;
26050 }
26051
26052
26053 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26054 PyObject *resultobj;
26055 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26056 wxDateSpan *arg2 = 0 ;
26057 wxDateSpan result;
26058 PyObject * obj0 = 0 ;
26059 PyObject * obj1 = 0 ;
26060 char *kwnames[] = {
26061 (char *) "self",(char *) "other", NULL
26062 };
26063
26064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26066 if (SWIG_arg_fail(1)) SWIG_fail;
26067 {
26068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26069 if (SWIG_arg_fail(2)) SWIG_fail;
26070 if (arg2 == NULL) {
26071 SWIG_null_ref("wxDateSpan");
26072 }
26073 if (SWIG_arg_fail(2)) SWIG_fail;
26074 }
26075 {
26076 PyThreadState* __tstate = wxPyBeginAllowThreads();
26077 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26078
26079 wxPyEndAllowThreads(__tstate);
26080 if (PyErr_Occurred()) SWIG_fail;
26081 }
26082 {
26083 wxDateSpan * resultptr;
26084 resultptr = new wxDateSpan((wxDateSpan &)(result));
26085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26086 }
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj;
26095 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26096 wxDateSpan *arg2 = 0 ;
26097 wxDateSpan result;
26098 PyObject * obj0 = 0 ;
26099 PyObject * obj1 = 0 ;
26100 char *kwnames[] = {
26101 (char *) "self",(char *) "other", NULL
26102 };
26103
26104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26106 if (SWIG_arg_fail(1)) SWIG_fail;
26107 {
26108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26109 if (SWIG_arg_fail(2)) SWIG_fail;
26110 if (arg2 == NULL) {
26111 SWIG_null_ref("wxDateSpan");
26112 }
26113 if (SWIG_arg_fail(2)) SWIG_fail;
26114 }
26115 {
26116 PyThreadState* __tstate = wxPyBeginAllowThreads();
26117 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26118
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 {
26123 wxDateSpan * resultptr;
26124 resultptr = new wxDateSpan((wxDateSpan &)(result));
26125 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26126 }
26127 return resultobj;
26128 fail:
26129 return NULL;
26130 }
26131
26132
26133 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26134 PyObject *resultobj;
26135 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26136 int arg2 ;
26137 wxDateSpan result;
26138 PyObject * obj0 = 0 ;
26139 PyObject * obj1 = 0 ;
26140 char *kwnames[] = {
26141 (char *) "self",(char *) "n", NULL
26142 };
26143
26144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26146 if (SWIG_arg_fail(1)) SWIG_fail;
26147 {
26148 arg2 = (int)(SWIG_As_int(obj1));
26149 if (SWIG_arg_fail(2)) SWIG_fail;
26150 }
26151 {
26152 PyThreadState* __tstate = wxPyBeginAllowThreads();
26153 result = wxDateSpan___mul__(arg1,arg2);
26154
26155 wxPyEndAllowThreads(__tstate);
26156 if (PyErr_Occurred()) SWIG_fail;
26157 }
26158 {
26159 wxDateSpan * resultptr;
26160 resultptr = new wxDateSpan((wxDateSpan &)(result));
26161 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26162 }
26163 return resultobj;
26164 fail:
26165 return NULL;
26166 }
26167
26168
26169 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26170 PyObject *resultobj;
26171 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26172 int arg2 ;
26173 wxDateSpan result;
26174 PyObject * obj0 = 0 ;
26175 PyObject * obj1 = 0 ;
26176 char *kwnames[] = {
26177 (char *) "self",(char *) "n", NULL
26178 };
26179
26180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26182 if (SWIG_arg_fail(1)) SWIG_fail;
26183 {
26184 arg2 = (int)(SWIG_As_int(obj1));
26185 if (SWIG_arg_fail(2)) SWIG_fail;
26186 }
26187 {
26188 PyThreadState* __tstate = wxPyBeginAllowThreads();
26189 result = wxDateSpan___rmul__(arg1,arg2);
26190
26191 wxPyEndAllowThreads(__tstate);
26192 if (PyErr_Occurred()) SWIG_fail;
26193 }
26194 {
26195 wxDateSpan * resultptr;
26196 resultptr = new wxDateSpan((wxDateSpan &)(result));
26197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26198 }
26199 return resultobj;
26200 fail:
26201 return NULL;
26202 }
26203
26204
26205 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26206 PyObject *resultobj;
26207 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26208 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26209 bool result;
26210 PyObject * obj0 = 0 ;
26211 PyObject * obj1 = 0 ;
26212 char *kwnames[] = {
26213 (char *) "self",(char *) "other", NULL
26214 };
26215
26216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26218 if (SWIG_arg_fail(1)) SWIG_fail;
26219 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26220 if (SWIG_arg_fail(2)) SWIG_fail;
26221 {
26222 PyThreadState* __tstate = wxPyBeginAllowThreads();
26223 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26224
26225 wxPyEndAllowThreads(__tstate);
26226 if (PyErr_Occurred()) SWIG_fail;
26227 }
26228 {
26229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26230 }
26231 return resultobj;
26232 fail:
26233 return NULL;
26234 }
26235
26236
26237 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26238 PyObject *resultobj;
26239 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26240 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26241 bool result;
26242 PyObject * obj0 = 0 ;
26243 PyObject * obj1 = 0 ;
26244 char *kwnames[] = {
26245 (char *) "self",(char *) "other", NULL
26246 };
26247
26248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26250 if (SWIG_arg_fail(1)) SWIG_fail;
26251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26252 if (SWIG_arg_fail(2)) SWIG_fail;
26253 {
26254 PyThreadState* __tstate = wxPyBeginAllowThreads();
26255 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26256
26257 wxPyEndAllowThreads(__tstate);
26258 if (PyErr_Occurred()) SWIG_fail;
26259 }
26260 {
26261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26262 }
26263 return resultobj;
26264 fail:
26265 return NULL;
26266 }
26267
26268
26269 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26270 PyObject *obj;
26271 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26272 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26273 Py_INCREF(obj);
26274 return Py_BuildValue((char *)"");
26275 }
26276 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26277 PyObject *resultobj;
26278 long result;
26279 char *kwnames[] = {
26280 NULL
26281 };
26282
26283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26284 {
26285 PyThreadState* __tstate = wxPyBeginAllowThreads();
26286 result = (long)wxGetLocalTime();
26287
26288 wxPyEndAllowThreads(__tstate);
26289 if (PyErr_Occurred()) SWIG_fail;
26290 }
26291 {
26292 resultobj = SWIG_From_long((long)(result));
26293 }
26294 return resultobj;
26295 fail:
26296 return NULL;
26297 }
26298
26299
26300 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26301 PyObject *resultobj;
26302 long result;
26303 char *kwnames[] = {
26304 NULL
26305 };
26306
26307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26308 {
26309 PyThreadState* __tstate = wxPyBeginAllowThreads();
26310 result = (long)wxGetUTCTime();
26311
26312 wxPyEndAllowThreads(__tstate);
26313 if (PyErr_Occurred()) SWIG_fail;
26314 }
26315 {
26316 resultobj = SWIG_From_long((long)(result));
26317 }
26318 return resultobj;
26319 fail:
26320 return NULL;
26321 }
26322
26323
26324 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26325 PyObject *resultobj;
26326 long result;
26327 char *kwnames[] = {
26328 NULL
26329 };
26330
26331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26332 {
26333 PyThreadState* __tstate = wxPyBeginAllowThreads();
26334 result = (long)wxGetCurrentTime();
26335
26336 wxPyEndAllowThreads(__tstate);
26337 if (PyErr_Occurred()) SWIG_fail;
26338 }
26339 {
26340 resultobj = SWIG_From_long((long)(result));
26341 }
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26349 PyObject *resultobj;
26350 wxLongLong result;
26351 char *kwnames[] = {
26352 NULL
26353 };
26354
26355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26356 {
26357 PyThreadState* __tstate = wxPyBeginAllowThreads();
26358 result = wxGetLocalTimeMillis();
26359
26360 wxPyEndAllowThreads(__tstate);
26361 if (PyErr_Occurred()) SWIG_fail;
26362 }
26363 {
26364 PyObject *hi, *lo, *shifter, *shifted;
26365 hi = PyLong_FromLong( (&result)->GetHi() );
26366 lo = PyLong_FromLong( (&result)->GetLo() );
26367 shifter = PyLong_FromLong(32);
26368 shifted = PyNumber_Lshift(hi, shifter);
26369 resultobj = PyNumber_Or(shifted, lo);
26370 Py_DECREF(hi);
26371 Py_DECREF(lo);
26372 Py_DECREF(shifter);
26373 Py_DECREF(shifted);
26374 }
26375 return resultobj;
26376 fail:
26377 return NULL;
26378 }
26379
26380
26381 static int _wrap_DefaultDateTime_set(PyObject *) {
26382 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26383 return 1;
26384 }
26385
26386
26387 static PyObject *_wrap_DefaultDateTime_get(void) {
26388 PyObject *pyobj;
26389
26390 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26391 return pyobj;
26392 }
26393
26394
26395 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26396 PyObject *resultobj;
26397 wxDataFormatId arg1 ;
26398 wxDataFormat *result;
26399 PyObject * obj0 = 0 ;
26400 char *kwnames[] = {
26401 (char *) "type", NULL
26402 };
26403
26404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26405 {
26406 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26407 if (SWIG_arg_fail(1)) SWIG_fail;
26408 }
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26412
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26417 return resultobj;
26418 fail:
26419 return NULL;
26420 }
26421
26422
26423 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26424 PyObject *resultobj;
26425 wxString *arg1 = 0 ;
26426 wxDataFormat *result;
26427 bool temp1 = false ;
26428 PyObject * obj0 = 0 ;
26429 char *kwnames[] = {
26430 (char *) "format", NULL
26431 };
26432
26433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26434 {
26435 arg1 = wxString_in_helper(obj0);
26436 if (arg1 == NULL) SWIG_fail;
26437 temp1 = true;
26438 }
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26442
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26447 {
26448 if (temp1)
26449 delete arg1;
26450 }
26451 return resultobj;
26452 fail:
26453 {
26454 if (temp1)
26455 delete arg1;
26456 }
26457 return NULL;
26458 }
26459
26460
26461 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26462 PyObject *resultobj;
26463 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26464 PyObject * obj0 = 0 ;
26465 char *kwnames[] = {
26466 (char *) "self", NULL
26467 };
26468
26469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26471 if (SWIG_arg_fail(1)) SWIG_fail;
26472 {
26473 PyThreadState* __tstate = wxPyBeginAllowThreads();
26474 delete arg1;
26475
26476 wxPyEndAllowThreads(__tstate);
26477 if (PyErr_Occurred()) SWIG_fail;
26478 }
26479 Py_INCREF(Py_None); resultobj = Py_None;
26480 return resultobj;
26481 fail:
26482 return NULL;
26483 }
26484
26485
26486 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26487 PyObject *resultobj;
26488 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26489 wxDataFormatId arg2 ;
26490 bool result;
26491 PyObject * obj0 = 0 ;
26492 PyObject * obj1 = 0 ;
26493
26494 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26496 if (SWIG_arg_fail(1)) SWIG_fail;
26497 {
26498 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26499 if (SWIG_arg_fail(2)) SWIG_fail;
26500 }
26501 {
26502 PyThreadState* __tstate = wxPyBeginAllowThreads();
26503 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26504
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 {
26509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26510 }
26511 return resultobj;
26512 fail:
26513 return NULL;
26514 }
26515
26516
26517 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26518 PyObject *resultobj;
26519 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26520 wxDataFormatId arg2 ;
26521 bool result;
26522 PyObject * obj0 = 0 ;
26523 PyObject * obj1 = 0 ;
26524
26525 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26527 if (SWIG_arg_fail(1)) SWIG_fail;
26528 {
26529 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26530 if (SWIG_arg_fail(2)) SWIG_fail;
26531 }
26532 {
26533 PyThreadState* __tstate = wxPyBeginAllowThreads();
26534 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26535
26536 wxPyEndAllowThreads(__tstate);
26537 if (PyErr_Occurred()) SWIG_fail;
26538 }
26539 {
26540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26541 }
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26549 PyObject *resultobj;
26550 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26551 wxDataFormat *arg2 = 0 ;
26552 bool result;
26553 PyObject * obj0 = 0 ;
26554 PyObject * obj1 = 0 ;
26555
26556 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26558 if (SWIG_arg_fail(1)) SWIG_fail;
26559 {
26560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26561 if (SWIG_arg_fail(2)) SWIG_fail;
26562 if (arg2 == NULL) {
26563 SWIG_null_ref("wxDataFormat");
26564 }
26565 if (SWIG_arg_fail(2)) SWIG_fail;
26566 }
26567 {
26568 PyThreadState* __tstate = wxPyBeginAllowThreads();
26569 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26570
26571 wxPyEndAllowThreads(__tstate);
26572 if (PyErr_Occurred()) SWIG_fail;
26573 }
26574 {
26575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26576 }
26577 return resultobj;
26578 fail:
26579 return NULL;
26580 }
26581
26582
26583 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26584 int argc;
26585 PyObject *argv[3];
26586 int ii;
26587
26588 argc = PyObject_Length(args);
26589 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26590 argv[ii] = PyTuple_GetItem(args,ii);
26591 }
26592 if (argc == 2) {
26593 int _v;
26594 {
26595 void *ptr;
26596 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26597 _v = 0;
26598 PyErr_Clear();
26599 } else {
26600 _v = 1;
26601 }
26602 }
26603 if (_v) {
26604 {
26605 void *ptr = 0;
26606 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26607 _v = 0;
26608 PyErr_Clear();
26609 } else {
26610 _v = (ptr != 0);
26611 }
26612 }
26613 if (_v) {
26614 return _wrap_DataFormat___eq____SWIG_1(self,args);
26615 }
26616 }
26617 }
26618 if (argc == 2) {
26619 int _v;
26620 {
26621 void *ptr;
26622 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26623 _v = 0;
26624 PyErr_Clear();
26625 } else {
26626 _v = 1;
26627 }
26628 }
26629 if (_v) {
26630 _v = SWIG_Check_int(argv[1]);
26631 if (_v) {
26632 return _wrap_DataFormat___eq____SWIG_0(self,args);
26633 }
26634 }
26635 }
26636
26637 Py_INCREF(Py_NotImplemented);
26638 return Py_NotImplemented;
26639 }
26640
26641
26642 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26643 PyObject *resultobj;
26644 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26645 wxDataFormat *arg2 = 0 ;
26646 bool result;
26647 PyObject * obj0 = 0 ;
26648 PyObject * obj1 = 0 ;
26649
26650 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26652 if (SWIG_arg_fail(1)) SWIG_fail;
26653 {
26654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26655 if (SWIG_arg_fail(2)) SWIG_fail;
26656 if (arg2 == NULL) {
26657 SWIG_null_ref("wxDataFormat");
26658 }
26659 if (SWIG_arg_fail(2)) SWIG_fail;
26660 }
26661 {
26662 PyThreadState* __tstate = wxPyBeginAllowThreads();
26663 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26664
26665 wxPyEndAllowThreads(__tstate);
26666 if (PyErr_Occurred()) SWIG_fail;
26667 }
26668 {
26669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26670 }
26671 return resultobj;
26672 fail:
26673 return NULL;
26674 }
26675
26676
26677 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26678 int argc;
26679 PyObject *argv[3];
26680 int ii;
26681
26682 argc = PyObject_Length(args);
26683 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26684 argv[ii] = PyTuple_GetItem(args,ii);
26685 }
26686 if (argc == 2) {
26687 int _v;
26688 {
26689 void *ptr;
26690 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26691 _v = 0;
26692 PyErr_Clear();
26693 } else {
26694 _v = 1;
26695 }
26696 }
26697 if (_v) {
26698 {
26699 void *ptr = 0;
26700 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26701 _v = 0;
26702 PyErr_Clear();
26703 } else {
26704 _v = (ptr != 0);
26705 }
26706 }
26707 if (_v) {
26708 return _wrap_DataFormat___ne____SWIG_1(self,args);
26709 }
26710 }
26711 }
26712 if (argc == 2) {
26713 int _v;
26714 {
26715 void *ptr;
26716 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26717 _v = 0;
26718 PyErr_Clear();
26719 } else {
26720 _v = 1;
26721 }
26722 }
26723 if (_v) {
26724 _v = SWIG_Check_int(argv[1]);
26725 if (_v) {
26726 return _wrap_DataFormat___ne____SWIG_0(self,args);
26727 }
26728 }
26729 }
26730
26731 Py_INCREF(Py_NotImplemented);
26732 return Py_NotImplemented;
26733 }
26734
26735
26736 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26737 PyObject *resultobj;
26738 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26739 wxDataFormatId arg2 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char *kwnames[] = {
26743 (char *) "self",(char *) "format", NULL
26744 };
26745
26746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26748 if (SWIG_arg_fail(1)) SWIG_fail;
26749 {
26750 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26751 if (SWIG_arg_fail(2)) SWIG_fail;
26752 }
26753 {
26754 PyThreadState* __tstate = wxPyBeginAllowThreads();
26755 (arg1)->SetType((wxDataFormatId )arg2);
26756
26757 wxPyEndAllowThreads(__tstate);
26758 if (PyErr_Occurred()) SWIG_fail;
26759 }
26760 Py_INCREF(Py_None); resultobj = Py_None;
26761 return resultobj;
26762 fail:
26763 return NULL;
26764 }
26765
26766
26767 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26768 PyObject *resultobj;
26769 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26770 wxDataFormatId result;
26771 PyObject * obj0 = 0 ;
26772 char *kwnames[] = {
26773 (char *) "self", NULL
26774 };
26775
26776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26778 if (SWIG_arg_fail(1)) SWIG_fail;
26779 {
26780 PyThreadState* __tstate = wxPyBeginAllowThreads();
26781 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26782
26783 wxPyEndAllowThreads(__tstate);
26784 if (PyErr_Occurred()) SWIG_fail;
26785 }
26786 resultobj = SWIG_From_int((result));
26787 return resultobj;
26788 fail:
26789 return NULL;
26790 }
26791
26792
26793 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26794 PyObject *resultobj;
26795 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26796 wxString result;
26797 PyObject * obj0 = 0 ;
26798 char *kwnames[] = {
26799 (char *) "self", NULL
26800 };
26801
26802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26804 if (SWIG_arg_fail(1)) SWIG_fail;
26805 {
26806 PyThreadState* __tstate = wxPyBeginAllowThreads();
26807 result = ((wxDataFormat const *)arg1)->GetId();
26808
26809 wxPyEndAllowThreads(__tstate);
26810 if (PyErr_Occurred()) SWIG_fail;
26811 }
26812 {
26813 #if wxUSE_UNICODE
26814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26815 #else
26816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26817 #endif
26818 }
26819 return resultobj;
26820 fail:
26821 return NULL;
26822 }
26823
26824
26825 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26826 PyObject *resultobj;
26827 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26828 wxString *arg2 = 0 ;
26829 bool temp2 = false ;
26830 PyObject * obj0 = 0 ;
26831 PyObject * obj1 = 0 ;
26832 char *kwnames[] = {
26833 (char *) "self",(char *) "format", NULL
26834 };
26835
26836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26838 if (SWIG_arg_fail(1)) SWIG_fail;
26839 {
26840 arg2 = wxString_in_helper(obj1);
26841 if (arg2 == NULL) SWIG_fail;
26842 temp2 = true;
26843 }
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 (arg1)->SetId((wxString const &)*arg2);
26847
26848 wxPyEndAllowThreads(__tstate);
26849 if (PyErr_Occurred()) SWIG_fail;
26850 }
26851 Py_INCREF(Py_None); resultobj = Py_None;
26852 {
26853 if (temp2)
26854 delete arg2;
26855 }
26856 return resultobj;
26857 fail:
26858 {
26859 if (temp2)
26860 delete arg2;
26861 }
26862 return NULL;
26863 }
26864
26865
26866 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26867 PyObject *obj;
26868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26869 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26870 Py_INCREF(obj);
26871 return Py_BuildValue((char *)"");
26872 }
26873 static int _wrap_FormatInvalid_set(PyObject *) {
26874 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26875 return 1;
26876 }
26877
26878
26879 static PyObject *_wrap_FormatInvalid_get(void) {
26880 PyObject *pyobj;
26881
26882 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26883 return pyobj;
26884 }
26885
26886
26887 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj;
26889 wxDataObject *arg1 = (wxDataObject *) 0 ;
26890 PyObject * obj0 = 0 ;
26891 char *kwnames[] = {
26892 (char *) "self", NULL
26893 };
26894
26895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26897 if (SWIG_arg_fail(1)) SWIG_fail;
26898 {
26899 PyThreadState* __tstate = wxPyBeginAllowThreads();
26900 delete arg1;
26901
26902 wxPyEndAllowThreads(__tstate);
26903 if (PyErr_Occurred()) SWIG_fail;
26904 }
26905 Py_INCREF(Py_None); resultobj = Py_None;
26906 return resultobj;
26907 fail:
26908 return NULL;
26909 }
26910
26911
26912 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26913 PyObject *resultobj;
26914 wxDataObject *arg1 = (wxDataObject *) 0 ;
26915 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26916 SwigValueWrapper<wxDataFormat > result;
26917 PyObject * obj0 = 0 ;
26918 PyObject * obj1 = 0 ;
26919 char *kwnames[] = {
26920 (char *) "self",(char *) "dir", NULL
26921 };
26922
26923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26925 if (SWIG_arg_fail(1)) SWIG_fail;
26926 if (obj1) {
26927 {
26928 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26929 if (SWIG_arg_fail(2)) SWIG_fail;
26930 }
26931 }
26932 {
26933 PyThreadState* __tstate = wxPyBeginAllowThreads();
26934 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26935
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 {
26940 wxDataFormat * resultptr;
26941 resultptr = new wxDataFormat((wxDataFormat &)(result));
26942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26943 }
26944 return resultobj;
26945 fail:
26946 return NULL;
26947 }
26948
26949
26950 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26951 PyObject *resultobj;
26952 wxDataObject *arg1 = (wxDataObject *) 0 ;
26953 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26954 size_t result;
26955 PyObject * obj0 = 0 ;
26956 PyObject * obj1 = 0 ;
26957 char *kwnames[] = {
26958 (char *) "self",(char *) "dir", NULL
26959 };
26960
26961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26963 if (SWIG_arg_fail(1)) SWIG_fail;
26964 if (obj1) {
26965 {
26966 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26967 if (SWIG_arg_fail(2)) SWIG_fail;
26968 }
26969 }
26970 {
26971 PyThreadState* __tstate = wxPyBeginAllowThreads();
26972 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26973
26974 wxPyEndAllowThreads(__tstate);
26975 if (PyErr_Occurred()) SWIG_fail;
26976 }
26977 {
26978 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26979 }
26980 return resultobj;
26981 fail:
26982 return NULL;
26983 }
26984
26985
26986 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26987 PyObject *resultobj;
26988 wxDataObject *arg1 = (wxDataObject *) 0 ;
26989 wxDataFormat *arg2 = 0 ;
26990 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26991 bool result;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 PyObject * obj2 = 0 ;
26995 char *kwnames[] = {
26996 (char *) "self",(char *) "format",(char *) "dir", NULL
26997 };
26998
26999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27001 if (SWIG_arg_fail(1)) SWIG_fail;
27002 {
27003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27004 if (SWIG_arg_fail(2)) SWIG_fail;
27005 if (arg2 == NULL) {
27006 SWIG_null_ref("wxDataFormat");
27007 }
27008 if (SWIG_arg_fail(2)) SWIG_fail;
27009 }
27010 if (obj2) {
27011 {
27012 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27013 if (SWIG_arg_fail(3)) SWIG_fail;
27014 }
27015 }
27016 {
27017 PyThreadState* __tstate = wxPyBeginAllowThreads();
27018 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27019
27020 wxPyEndAllowThreads(__tstate);
27021 if (PyErr_Occurred()) SWIG_fail;
27022 }
27023 {
27024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27025 }
27026 return resultobj;
27027 fail:
27028 return NULL;
27029 }
27030
27031
27032 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj;
27034 wxDataObject *arg1 = (wxDataObject *) 0 ;
27035 wxDataFormat *arg2 = 0 ;
27036 size_t result;
27037 PyObject * obj0 = 0 ;
27038 PyObject * obj1 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self",(char *) "format", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27045 if (SWIG_arg_fail(1)) SWIG_fail;
27046 {
27047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27048 if (SWIG_arg_fail(2)) SWIG_fail;
27049 if (arg2 == NULL) {
27050 SWIG_null_ref("wxDataFormat");
27051 }
27052 if (SWIG_arg_fail(2)) SWIG_fail;
27053 }
27054 {
27055 PyThreadState* __tstate = wxPyBeginAllowThreads();
27056 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27057
27058 wxPyEndAllowThreads(__tstate);
27059 if (PyErr_Occurred()) SWIG_fail;
27060 }
27061 {
27062 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27063 }
27064 return resultobj;
27065 fail:
27066 return NULL;
27067 }
27068
27069
27070 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27071 PyObject *resultobj;
27072 wxDataObject *arg1 = (wxDataObject *) 0 ;
27073 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27074 PyObject *result;
27075 PyObject * obj0 = 0 ;
27076 PyObject * obj1 = 0 ;
27077 char *kwnames[] = {
27078 (char *) "self",(char *) "dir", NULL
27079 };
27080
27081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27083 if (SWIG_arg_fail(1)) SWIG_fail;
27084 if (obj1) {
27085 {
27086 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27087 if (SWIG_arg_fail(2)) SWIG_fail;
27088 }
27089 }
27090 {
27091 PyThreadState* __tstate = wxPyBeginAllowThreads();
27092 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27093
27094 wxPyEndAllowThreads(__tstate);
27095 if (PyErr_Occurred()) SWIG_fail;
27096 }
27097 resultobj = result;
27098 return resultobj;
27099 fail:
27100 return NULL;
27101 }
27102
27103
27104 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27105 PyObject *resultobj;
27106 wxDataObject *arg1 = (wxDataObject *) 0 ;
27107 wxDataFormat *arg2 = 0 ;
27108 PyObject *result;
27109 PyObject * obj0 = 0 ;
27110 PyObject * obj1 = 0 ;
27111 char *kwnames[] = {
27112 (char *) "self",(char *) "format", NULL
27113 };
27114
27115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27117 if (SWIG_arg_fail(1)) SWIG_fail;
27118 {
27119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27120 if (SWIG_arg_fail(2)) SWIG_fail;
27121 if (arg2 == NULL) {
27122 SWIG_null_ref("wxDataFormat");
27123 }
27124 if (SWIG_arg_fail(2)) SWIG_fail;
27125 }
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27129
27130 wxPyEndAllowThreads(__tstate);
27131 if (PyErr_Occurred()) SWIG_fail;
27132 }
27133 resultobj = result;
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj;
27142 wxDataObject *arg1 = (wxDataObject *) 0 ;
27143 wxDataFormat *arg2 = 0 ;
27144 PyObject *arg3 = (PyObject *) 0 ;
27145 bool result;
27146 PyObject * obj0 = 0 ;
27147 PyObject * obj1 = 0 ;
27148 PyObject * obj2 = 0 ;
27149 char *kwnames[] = {
27150 (char *) "self",(char *) "format",(char *) "data", NULL
27151 };
27152
27153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27155 if (SWIG_arg_fail(1)) SWIG_fail;
27156 {
27157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27158 if (SWIG_arg_fail(2)) SWIG_fail;
27159 if (arg2 == NULL) {
27160 SWIG_null_ref("wxDataFormat");
27161 }
27162 if (SWIG_arg_fail(2)) SWIG_fail;
27163 }
27164 arg3 = obj2;
27165 {
27166 PyThreadState* __tstate = wxPyBeginAllowThreads();
27167 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27168
27169 wxPyEndAllowThreads(__tstate);
27170 if (PyErr_Occurred()) SWIG_fail;
27171 }
27172 {
27173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27174 }
27175 return resultobj;
27176 fail:
27177 return NULL;
27178 }
27179
27180
27181 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27182 PyObject *obj;
27183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27184 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27185 Py_INCREF(obj);
27186 return Py_BuildValue((char *)"");
27187 }
27188 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27189 PyObject *resultobj;
27190 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27191 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27192 wxDataObjectSimple *result;
27193 PyObject * obj0 = 0 ;
27194 char *kwnames[] = {
27195 (char *) "format", NULL
27196 };
27197
27198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27199 if (obj0) {
27200 {
27201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27202 if (SWIG_arg_fail(1)) SWIG_fail;
27203 if (arg1 == NULL) {
27204 SWIG_null_ref("wxDataFormat");
27205 }
27206 if (SWIG_arg_fail(1)) SWIG_fail;
27207 }
27208 }
27209 {
27210 PyThreadState* __tstate = wxPyBeginAllowThreads();
27211 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27212
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27224 PyObject *resultobj;
27225 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27226 wxDataFormat *result;
27227 PyObject * obj0 = 0 ;
27228 char *kwnames[] = {
27229 (char *) "self", NULL
27230 };
27231
27232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27234 if (SWIG_arg_fail(1)) SWIG_fail;
27235 {
27236 PyThreadState* __tstate = wxPyBeginAllowThreads();
27237 {
27238 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27239 result = (wxDataFormat *) &_result_ref;
27240 }
27241
27242 wxPyEndAllowThreads(__tstate);
27243 if (PyErr_Occurred()) SWIG_fail;
27244 }
27245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27246 return resultobj;
27247 fail:
27248 return NULL;
27249 }
27250
27251
27252 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27253 PyObject *resultobj;
27254 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27255 wxDataFormat *arg2 = 0 ;
27256 PyObject * obj0 = 0 ;
27257 PyObject * obj1 = 0 ;
27258 char *kwnames[] = {
27259 (char *) "self",(char *) "format", NULL
27260 };
27261
27262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27264 if (SWIG_arg_fail(1)) SWIG_fail;
27265 {
27266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27267 if (SWIG_arg_fail(2)) SWIG_fail;
27268 if (arg2 == NULL) {
27269 SWIG_null_ref("wxDataFormat");
27270 }
27271 if (SWIG_arg_fail(2)) SWIG_fail;
27272 }
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27276
27277 wxPyEndAllowThreads(__tstate);
27278 if (PyErr_Occurred()) SWIG_fail;
27279 }
27280 Py_INCREF(Py_None); resultobj = Py_None;
27281 return resultobj;
27282 fail:
27283 return NULL;
27284 }
27285
27286
27287 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27288 PyObject *resultobj;
27289 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27290 size_t result;
27291 PyObject * obj0 = 0 ;
27292 char *kwnames[] = {
27293 (char *) "self", NULL
27294 };
27295
27296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(1)) SWIG_fail;
27299 {
27300 PyThreadState* __tstate = wxPyBeginAllowThreads();
27301 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27302
27303 wxPyEndAllowThreads(__tstate);
27304 if (PyErr_Occurred()) SWIG_fail;
27305 }
27306 {
27307 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27308 }
27309 return resultobj;
27310 fail:
27311 return NULL;
27312 }
27313
27314
27315 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27316 PyObject *resultobj;
27317 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27318 PyObject *result;
27319 PyObject * obj0 = 0 ;
27320 char *kwnames[] = {
27321 (char *) "self", NULL
27322 };
27323
27324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27326 if (SWIG_arg_fail(1)) SWIG_fail;
27327 {
27328 PyThreadState* __tstate = wxPyBeginAllowThreads();
27329 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27330
27331 wxPyEndAllowThreads(__tstate);
27332 if (PyErr_Occurred()) SWIG_fail;
27333 }
27334 resultobj = result;
27335 return resultobj;
27336 fail:
27337 return NULL;
27338 }
27339
27340
27341 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27342 PyObject *resultobj;
27343 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27344 PyObject *arg2 = (PyObject *) 0 ;
27345 bool result;
27346 PyObject * obj0 = 0 ;
27347 PyObject * obj1 = 0 ;
27348 char *kwnames[] = {
27349 (char *) "self",(char *) "data", NULL
27350 };
27351
27352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27354 if (SWIG_arg_fail(1)) SWIG_fail;
27355 arg2 = obj1;
27356 {
27357 PyThreadState* __tstate = wxPyBeginAllowThreads();
27358 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27359
27360 wxPyEndAllowThreads(__tstate);
27361 if (PyErr_Occurred()) SWIG_fail;
27362 }
27363 {
27364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27365 }
27366 return resultobj;
27367 fail:
27368 return NULL;
27369 }
27370
27371
27372 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27373 PyObject *obj;
27374 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27375 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27376 Py_INCREF(obj);
27377 return Py_BuildValue((char *)"");
27378 }
27379 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27380 PyObject *resultobj;
27381 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27382 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27383 wxPyDataObjectSimple *result;
27384 PyObject * obj0 = 0 ;
27385 char *kwnames[] = {
27386 (char *) "format", NULL
27387 };
27388
27389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27390 if (obj0) {
27391 {
27392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27393 if (SWIG_arg_fail(1)) SWIG_fail;
27394 if (arg1 == NULL) {
27395 SWIG_null_ref("wxDataFormat");
27396 }
27397 if (SWIG_arg_fail(1)) SWIG_fail;
27398 }
27399 }
27400 {
27401 PyThreadState* __tstate = wxPyBeginAllowThreads();
27402 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27403
27404 wxPyEndAllowThreads(__tstate);
27405 if (PyErr_Occurred()) SWIG_fail;
27406 }
27407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27415 PyObject *resultobj;
27416 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27417 PyObject *arg2 = (PyObject *) 0 ;
27418 PyObject *arg3 = (PyObject *) 0 ;
27419 PyObject * obj0 = 0 ;
27420 PyObject * obj1 = 0 ;
27421 PyObject * obj2 = 0 ;
27422 char *kwnames[] = {
27423 (char *) "self",(char *) "self",(char *) "_class", NULL
27424 };
27425
27426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27428 if (SWIG_arg_fail(1)) SWIG_fail;
27429 arg2 = obj1;
27430 arg3 = obj2;
27431 {
27432 PyThreadState* __tstate = wxPyBeginAllowThreads();
27433 (arg1)->_setCallbackInfo(arg2,arg3);
27434
27435 wxPyEndAllowThreads(__tstate);
27436 if (PyErr_Occurred()) SWIG_fail;
27437 }
27438 Py_INCREF(Py_None); resultobj = Py_None;
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27446 PyObject *obj;
27447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27448 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27449 Py_INCREF(obj);
27450 return Py_BuildValue((char *)"");
27451 }
27452 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27453 PyObject *resultobj;
27454 wxDataObjectComposite *result;
27455 char *kwnames[] = {
27456 NULL
27457 };
27458
27459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27463
27464 wxPyEndAllowThreads(__tstate);
27465 if (PyErr_Occurred()) SWIG_fail;
27466 }
27467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27475 PyObject *resultobj;
27476 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27477 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27478 bool arg3 = (bool) false ;
27479 PyObject * obj0 = 0 ;
27480 PyObject * obj1 = 0 ;
27481 PyObject * obj2 = 0 ;
27482 char *kwnames[] = {
27483 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27484 };
27485
27486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27488 if (SWIG_arg_fail(1)) SWIG_fail;
27489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27490 if (SWIG_arg_fail(2)) SWIG_fail;
27491 if (obj2) {
27492 {
27493 arg3 = (bool)(SWIG_As_bool(obj2));
27494 if (SWIG_arg_fail(3)) SWIG_fail;
27495 }
27496 }
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 (arg1)->Add(arg2,arg3);
27500
27501 wxPyEndAllowThreads(__tstate);
27502 if (PyErr_Occurred()) SWIG_fail;
27503 }
27504 Py_INCREF(Py_None); resultobj = Py_None;
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27512 PyObject *obj;
27513 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27514 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27515 Py_INCREF(obj);
27516 return Py_BuildValue((char *)"");
27517 }
27518 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27519 PyObject *resultobj;
27520 wxString const &arg1_defvalue = wxPyEmptyString ;
27521 wxString *arg1 = (wxString *) &arg1_defvalue ;
27522 wxTextDataObject *result;
27523 bool temp1 = false ;
27524 PyObject * obj0 = 0 ;
27525 char *kwnames[] = {
27526 (char *) "text", NULL
27527 };
27528
27529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27530 if (obj0) {
27531 {
27532 arg1 = wxString_in_helper(obj0);
27533 if (arg1 == NULL) SWIG_fail;
27534 temp1 = true;
27535 }
27536 }
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27540
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27545 {
27546 if (temp1)
27547 delete arg1;
27548 }
27549 return resultobj;
27550 fail:
27551 {
27552 if (temp1)
27553 delete arg1;
27554 }
27555 return NULL;
27556 }
27557
27558
27559 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27560 PyObject *resultobj;
27561 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27562 size_t result;
27563 PyObject * obj0 = 0 ;
27564 char *kwnames[] = {
27565 (char *) "self", NULL
27566 };
27567
27568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27570 if (SWIG_arg_fail(1)) SWIG_fail;
27571 {
27572 PyThreadState* __tstate = wxPyBeginAllowThreads();
27573 result = (size_t)(arg1)->GetTextLength();
27574
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 {
27579 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27580 }
27581 return resultobj;
27582 fail:
27583 return NULL;
27584 }
27585
27586
27587 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27588 PyObject *resultobj;
27589 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27590 wxString result;
27591 PyObject * obj0 = 0 ;
27592 char *kwnames[] = {
27593 (char *) "self", NULL
27594 };
27595
27596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27598 if (SWIG_arg_fail(1)) SWIG_fail;
27599 {
27600 PyThreadState* __tstate = wxPyBeginAllowThreads();
27601 result = (arg1)->GetText();
27602
27603 wxPyEndAllowThreads(__tstate);
27604 if (PyErr_Occurred()) SWIG_fail;
27605 }
27606 {
27607 #if wxUSE_UNICODE
27608 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27609 #else
27610 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27611 #endif
27612 }
27613 return resultobj;
27614 fail:
27615 return NULL;
27616 }
27617
27618
27619 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27620 PyObject *resultobj;
27621 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27622 wxString *arg2 = 0 ;
27623 bool temp2 = false ;
27624 PyObject * obj0 = 0 ;
27625 PyObject * obj1 = 0 ;
27626 char *kwnames[] = {
27627 (char *) "self",(char *) "text", NULL
27628 };
27629
27630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27632 if (SWIG_arg_fail(1)) SWIG_fail;
27633 {
27634 arg2 = wxString_in_helper(obj1);
27635 if (arg2 == NULL) SWIG_fail;
27636 temp2 = true;
27637 }
27638 {
27639 PyThreadState* __tstate = wxPyBeginAllowThreads();
27640 (arg1)->SetText((wxString const &)*arg2);
27641
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 Py_INCREF(Py_None); resultobj = Py_None;
27646 {
27647 if (temp2)
27648 delete arg2;
27649 }
27650 return resultobj;
27651 fail:
27652 {
27653 if (temp2)
27654 delete arg2;
27655 }
27656 return NULL;
27657 }
27658
27659
27660 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27661 PyObject *obj;
27662 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27663 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27664 Py_INCREF(obj);
27665 return Py_BuildValue((char *)"");
27666 }
27667 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27668 PyObject *resultobj;
27669 wxString const &arg1_defvalue = wxPyEmptyString ;
27670 wxString *arg1 = (wxString *) &arg1_defvalue ;
27671 wxPyTextDataObject *result;
27672 bool temp1 = false ;
27673 PyObject * obj0 = 0 ;
27674 char *kwnames[] = {
27675 (char *) "text", NULL
27676 };
27677
27678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27679 if (obj0) {
27680 {
27681 arg1 = wxString_in_helper(obj0);
27682 if (arg1 == NULL) SWIG_fail;
27683 temp1 = true;
27684 }
27685 }
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27689
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27694 {
27695 if (temp1)
27696 delete arg1;
27697 }
27698 return resultobj;
27699 fail:
27700 {
27701 if (temp1)
27702 delete arg1;
27703 }
27704 return NULL;
27705 }
27706
27707
27708 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27709 PyObject *resultobj;
27710 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27711 PyObject *arg2 = (PyObject *) 0 ;
27712 PyObject *arg3 = (PyObject *) 0 ;
27713 PyObject * obj0 = 0 ;
27714 PyObject * obj1 = 0 ;
27715 PyObject * obj2 = 0 ;
27716 char *kwnames[] = {
27717 (char *) "self",(char *) "self",(char *) "_class", NULL
27718 };
27719
27720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27722 if (SWIG_arg_fail(1)) SWIG_fail;
27723 arg2 = obj1;
27724 arg3 = obj2;
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 (arg1)->_setCallbackInfo(arg2,arg3);
27728
27729 wxPyEndAllowThreads(__tstate);
27730 if (PyErr_Occurred()) SWIG_fail;
27731 }
27732 Py_INCREF(Py_None); resultobj = Py_None;
27733 return resultobj;
27734 fail:
27735 return NULL;
27736 }
27737
27738
27739 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27740 PyObject *obj;
27741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27742 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27743 Py_INCREF(obj);
27744 return Py_BuildValue((char *)"");
27745 }
27746 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27747 PyObject *resultobj;
27748 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27749 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27750 wxBitmapDataObject *result;
27751 PyObject * obj0 = 0 ;
27752 char *kwnames[] = {
27753 (char *) "bitmap", NULL
27754 };
27755
27756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27757 if (obj0) {
27758 {
27759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27760 if (SWIG_arg_fail(1)) SWIG_fail;
27761 if (arg1 == NULL) {
27762 SWIG_null_ref("wxBitmap");
27763 }
27764 if (SWIG_arg_fail(1)) SWIG_fail;
27765 }
27766 }
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27770
27771 wxPyEndAllowThreads(__tstate);
27772 if (PyErr_Occurred()) SWIG_fail;
27773 }
27774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27775 return resultobj;
27776 fail:
27777 return NULL;
27778 }
27779
27780
27781 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27782 PyObject *resultobj;
27783 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27784 wxBitmap result;
27785 PyObject * obj0 = 0 ;
27786 char *kwnames[] = {
27787 (char *) "self", NULL
27788 };
27789
27790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27792 if (SWIG_arg_fail(1)) SWIG_fail;
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27796
27797 wxPyEndAllowThreads(__tstate);
27798 if (PyErr_Occurred()) SWIG_fail;
27799 }
27800 {
27801 wxBitmap * resultptr;
27802 resultptr = new wxBitmap((wxBitmap &)(result));
27803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27804 }
27805 return resultobj;
27806 fail:
27807 return NULL;
27808 }
27809
27810
27811 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27812 PyObject *resultobj;
27813 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27814 wxBitmap *arg2 = 0 ;
27815 PyObject * obj0 = 0 ;
27816 PyObject * obj1 = 0 ;
27817 char *kwnames[] = {
27818 (char *) "self",(char *) "bitmap", NULL
27819 };
27820
27821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27823 if (SWIG_arg_fail(1)) SWIG_fail;
27824 {
27825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27826 if (SWIG_arg_fail(2)) SWIG_fail;
27827 if (arg2 == NULL) {
27828 SWIG_null_ref("wxBitmap");
27829 }
27830 if (SWIG_arg_fail(2)) SWIG_fail;
27831 }
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27835
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 Py_INCREF(Py_None); resultobj = Py_None;
27840 return resultobj;
27841 fail:
27842 return NULL;
27843 }
27844
27845
27846 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27847 PyObject *obj;
27848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27849 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27850 Py_INCREF(obj);
27851 return Py_BuildValue((char *)"");
27852 }
27853 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27854 PyObject *resultobj;
27855 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27856 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27857 wxPyBitmapDataObject *result;
27858 PyObject * obj0 = 0 ;
27859 char *kwnames[] = {
27860 (char *) "bitmap", NULL
27861 };
27862
27863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27864 if (obj0) {
27865 {
27866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27867 if (SWIG_arg_fail(1)) SWIG_fail;
27868 if (arg1 == NULL) {
27869 SWIG_null_ref("wxBitmap");
27870 }
27871 if (SWIG_arg_fail(1)) SWIG_fail;
27872 }
27873 }
27874 {
27875 PyThreadState* __tstate = wxPyBeginAllowThreads();
27876 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27877
27878 wxPyEndAllowThreads(__tstate);
27879 if (PyErr_Occurred()) SWIG_fail;
27880 }
27881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27882 return resultobj;
27883 fail:
27884 return NULL;
27885 }
27886
27887
27888 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj;
27890 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27891 PyObject *arg2 = (PyObject *) 0 ;
27892 PyObject *arg3 = (PyObject *) 0 ;
27893 PyObject * obj0 = 0 ;
27894 PyObject * obj1 = 0 ;
27895 PyObject * obj2 = 0 ;
27896 char *kwnames[] = {
27897 (char *) "self",(char *) "self",(char *) "_class", NULL
27898 };
27899
27900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27902 if (SWIG_arg_fail(1)) SWIG_fail;
27903 arg2 = obj1;
27904 arg3 = obj2;
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 (arg1)->_setCallbackInfo(arg2,arg3);
27908
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 Py_INCREF(Py_None); resultobj = Py_None;
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27920 PyObject *obj;
27921 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27922 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27923 Py_INCREF(obj);
27924 return Py_BuildValue((char *)"");
27925 }
27926 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27927 PyObject *resultobj;
27928 wxFileDataObject *result;
27929 char *kwnames[] = {
27930 NULL
27931 };
27932
27933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27934 {
27935 PyThreadState* __tstate = wxPyBeginAllowThreads();
27936 result = (wxFileDataObject *)new wxFileDataObject();
27937
27938 wxPyEndAllowThreads(__tstate);
27939 if (PyErr_Occurred()) SWIG_fail;
27940 }
27941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27942 return resultobj;
27943 fail:
27944 return NULL;
27945 }
27946
27947
27948 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27949 PyObject *resultobj;
27950 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27951 wxArrayString *result;
27952 PyObject * obj0 = 0 ;
27953 char *kwnames[] = {
27954 (char *) "self", NULL
27955 };
27956
27957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27959 if (SWIG_arg_fail(1)) SWIG_fail;
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 {
27963 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27964 result = (wxArrayString *) &_result_ref;
27965 }
27966
27967 wxPyEndAllowThreads(__tstate);
27968 if (PyErr_Occurred()) SWIG_fail;
27969 }
27970 {
27971 resultobj = wxArrayString2PyList_helper(*result);
27972 }
27973 return resultobj;
27974 fail:
27975 return NULL;
27976 }
27977
27978
27979 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27980 PyObject *resultobj;
27981 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27982 wxString *arg2 = 0 ;
27983 bool temp2 = false ;
27984 PyObject * obj0 = 0 ;
27985 PyObject * obj1 = 0 ;
27986 char *kwnames[] = {
27987 (char *) "self",(char *) "filename", NULL
27988 };
27989
27990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27992 if (SWIG_arg_fail(1)) SWIG_fail;
27993 {
27994 arg2 = wxString_in_helper(obj1);
27995 if (arg2 == NULL) SWIG_fail;
27996 temp2 = true;
27997 }
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 (arg1)->AddFile((wxString const &)*arg2);
28001
28002 wxPyEndAllowThreads(__tstate);
28003 if (PyErr_Occurred()) SWIG_fail;
28004 }
28005 Py_INCREF(Py_None); resultobj = Py_None;
28006 {
28007 if (temp2)
28008 delete arg2;
28009 }
28010 return resultobj;
28011 fail:
28012 {
28013 if (temp2)
28014 delete arg2;
28015 }
28016 return NULL;
28017 }
28018
28019
28020 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28021 PyObject *obj;
28022 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28023 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28024 Py_INCREF(obj);
28025 return Py_BuildValue((char *)"");
28026 }
28027 static PyObject *_wrap_new_CustomDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28028 PyObject *resultobj;
28029 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28030 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28031 wxCustomDataObject *result;
28032 PyObject * obj0 = 0 ;
28033 char *kwnames[] = {
28034 (char *) "format", NULL
28035 };
28036
28037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_CustomDataObject",kwnames,&obj0)) goto fail;
28038 if (obj0) {
28039 {
28040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28041 if (SWIG_arg_fail(1)) SWIG_fail;
28042 if (arg1 == NULL) {
28043 SWIG_null_ref("wxDataFormat");
28044 }
28045 if (SWIG_arg_fail(1)) SWIG_fail;
28046 }
28047 }
28048 {
28049 PyThreadState* __tstate = wxPyBeginAllowThreads();
28050 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28051
28052 wxPyEndAllowThreads(__tstate);
28053 if (PyErr_Occurred()) SWIG_fail;
28054 }
28055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28056 return resultobj;
28057 fail:
28058 return NULL;
28059 }
28060
28061
28062 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28063 PyObject *resultobj;
28064 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28065 PyObject *arg2 = (PyObject *) 0 ;
28066 bool result;
28067 PyObject * obj0 = 0 ;
28068 PyObject * obj1 = 0 ;
28069 char *kwnames[] = {
28070 (char *) "self",(char *) "data", NULL
28071 };
28072
28073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28075 if (SWIG_arg_fail(1)) SWIG_fail;
28076 arg2 = obj1;
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28080
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 {
28085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28086 }
28087 return resultobj;
28088 fail:
28089 return NULL;
28090 }
28091
28092
28093 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28094 PyObject *resultobj;
28095 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28096 size_t result;
28097 PyObject * obj0 = 0 ;
28098 char *kwnames[] = {
28099 (char *) "self", NULL
28100 };
28101
28102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28104 if (SWIG_arg_fail(1)) SWIG_fail;
28105 {
28106 PyThreadState* __tstate = wxPyBeginAllowThreads();
28107 result = (size_t)(arg1)->GetSize();
28108
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 {
28113 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28114 }
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28122 PyObject *resultobj;
28123 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28124 PyObject *result;
28125 PyObject * obj0 = 0 ;
28126 char *kwnames[] = {
28127 (char *) "self", NULL
28128 };
28129
28130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28132 if (SWIG_arg_fail(1)) SWIG_fail;
28133 {
28134 PyThreadState* __tstate = wxPyBeginAllowThreads();
28135 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28136
28137 wxPyEndAllowThreads(__tstate);
28138 if (PyErr_Occurred()) SWIG_fail;
28139 }
28140 resultobj = result;
28141 return resultobj;
28142 fail:
28143 return NULL;
28144 }
28145
28146
28147 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28148 PyObject *obj;
28149 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28150 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28151 Py_INCREF(obj);
28152 return Py_BuildValue((char *)"");
28153 }
28154 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28155 PyObject *resultobj;
28156 wxURLDataObject *result;
28157 char *kwnames[] = {
28158 NULL
28159 };
28160
28161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 result = (wxURLDataObject *)new wxURLDataObject();
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj;
28178 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28179 wxString result;
28180 PyObject * obj0 = 0 ;
28181 char *kwnames[] = {
28182 (char *) "self", NULL
28183 };
28184
28185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28187 if (SWIG_arg_fail(1)) SWIG_fail;
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 result = (arg1)->GetURL();
28191
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 {
28196 #if wxUSE_UNICODE
28197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28198 #else
28199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28200 #endif
28201 }
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28209 PyObject *resultobj;
28210 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28211 wxString *arg2 = 0 ;
28212 bool temp2 = false ;
28213 PyObject * obj0 = 0 ;
28214 PyObject * obj1 = 0 ;
28215 char *kwnames[] = {
28216 (char *) "self",(char *) "url", NULL
28217 };
28218
28219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28221 if (SWIG_arg_fail(1)) SWIG_fail;
28222 {
28223 arg2 = wxString_in_helper(obj1);
28224 if (arg2 == NULL) SWIG_fail;
28225 temp2 = true;
28226 }
28227 {
28228 PyThreadState* __tstate = wxPyBeginAllowThreads();
28229 (arg1)->SetURL((wxString const &)*arg2);
28230
28231 wxPyEndAllowThreads(__tstate);
28232 if (PyErr_Occurred()) SWIG_fail;
28233 }
28234 Py_INCREF(Py_None); resultobj = Py_None;
28235 {
28236 if (temp2)
28237 delete arg2;
28238 }
28239 return resultobj;
28240 fail:
28241 {
28242 if (temp2)
28243 delete arg2;
28244 }
28245 return NULL;
28246 }
28247
28248
28249 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28250 PyObject *obj;
28251 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28252 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28253 Py_INCREF(obj);
28254 return Py_BuildValue((char *)"");
28255 }
28256 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28257 PyObject *resultobj;
28258 wxMetafileDataObject *result;
28259 char *kwnames[] = {
28260 NULL
28261 };
28262
28263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28264 {
28265 PyThreadState* __tstate = wxPyBeginAllowThreads();
28266 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28267
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28272 return resultobj;
28273 fail:
28274 return NULL;
28275 }
28276
28277
28278 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28279 PyObject *resultobj;
28280 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28281 wxMetafile *arg2 = 0 ;
28282 PyObject * obj0 = 0 ;
28283 PyObject * obj1 = 0 ;
28284 char *kwnames[] = {
28285 (char *) "self",(char *) "metafile", NULL
28286 };
28287
28288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28290 if (SWIG_arg_fail(1)) SWIG_fail;
28291 {
28292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28293 if (SWIG_arg_fail(2)) SWIG_fail;
28294 if (arg2 == NULL) {
28295 SWIG_null_ref("wxMetafile");
28296 }
28297 if (SWIG_arg_fail(2)) SWIG_fail;
28298 }
28299 {
28300 PyThreadState* __tstate = wxPyBeginAllowThreads();
28301 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28302
28303 wxPyEndAllowThreads(__tstate);
28304 if (PyErr_Occurred()) SWIG_fail;
28305 }
28306 Py_INCREF(Py_None); resultobj = Py_None;
28307 return resultobj;
28308 fail:
28309 return NULL;
28310 }
28311
28312
28313 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28314 PyObject *resultobj;
28315 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28316 wxMetafile result;
28317 PyObject * obj0 = 0 ;
28318 char *kwnames[] = {
28319 (char *) "self", NULL
28320 };
28321
28322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28324 if (SWIG_arg_fail(1)) SWIG_fail;
28325 {
28326 PyThreadState* __tstate = wxPyBeginAllowThreads();
28327 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28328
28329 wxPyEndAllowThreads(__tstate);
28330 if (PyErr_Occurred()) SWIG_fail;
28331 }
28332 {
28333 wxMetafile * resultptr;
28334 resultptr = new wxMetafile((wxMetafile &)(result));
28335 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28336 }
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28344 PyObject *obj;
28345 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28346 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28347 Py_INCREF(obj);
28348 return Py_BuildValue((char *)"");
28349 }
28350 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28351 PyObject *resultobj;
28352 wxDragResult arg1 ;
28353 bool result;
28354 PyObject * obj0 = 0 ;
28355 char *kwnames[] = {
28356 (char *) "res", NULL
28357 };
28358
28359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28360 {
28361 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28362 if (SWIG_arg_fail(1)) SWIG_fail;
28363 }
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28367
28368 wxPyEndAllowThreads(__tstate);
28369 if (PyErr_Occurred()) SWIG_fail;
28370 }
28371 {
28372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28373 }
28374 return resultobj;
28375 fail:
28376 return NULL;
28377 }
28378
28379
28380 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28381 PyObject *resultobj;
28382 wxWindow *arg1 = (wxWindow *) 0 ;
28383 wxCursor const &arg2_defvalue = wxNullCursor ;
28384 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28385 wxCursor const &arg3_defvalue = wxNullCursor ;
28386 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28387 wxCursor const &arg4_defvalue = wxNullCursor ;
28388 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28389 wxPyDropSource *result;
28390 PyObject * obj0 = 0 ;
28391 PyObject * obj1 = 0 ;
28392 PyObject * obj2 = 0 ;
28393 PyObject * obj3 = 0 ;
28394 char *kwnames[] = {
28395 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28396 };
28397
28398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28400 if (SWIG_arg_fail(1)) SWIG_fail;
28401 if (obj1) {
28402 {
28403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28404 if (SWIG_arg_fail(2)) SWIG_fail;
28405 if (arg2 == NULL) {
28406 SWIG_null_ref("wxCursor");
28407 }
28408 if (SWIG_arg_fail(2)) SWIG_fail;
28409 }
28410 }
28411 if (obj2) {
28412 {
28413 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28414 if (SWIG_arg_fail(3)) SWIG_fail;
28415 if (arg3 == NULL) {
28416 SWIG_null_ref("wxCursor");
28417 }
28418 if (SWIG_arg_fail(3)) SWIG_fail;
28419 }
28420 }
28421 if (obj3) {
28422 {
28423 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28424 if (SWIG_arg_fail(4)) SWIG_fail;
28425 if (arg4 == NULL) {
28426 SWIG_null_ref("wxCursor");
28427 }
28428 if (SWIG_arg_fail(4)) SWIG_fail;
28429 }
28430 }
28431 {
28432 PyThreadState* __tstate = wxPyBeginAllowThreads();
28433 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28434
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28439 return resultobj;
28440 fail:
28441 return NULL;
28442 }
28443
28444
28445 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28446 PyObject *resultobj;
28447 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28448 PyObject *arg2 = (PyObject *) 0 ;
28449 PyObject *arg3 = (PyObject *) 0 ;
28450 int arg4 ;
28451 PyObject * obj0 = 0 ;
28452 PyObject * obj1 = 0 ;
28453 PyObject * obj2 = 0 ;
28454 PyObject * obj3 = 0 ;
28455 char *kwnames[] = {
28456 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28457 };
28458
28459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28461 if (SWIG_arg_fail(1)) SWIG_fail;
28462 arg2 = obj1;
28463 arg3 = obj2;
28464 {
28465 arg4 = (int)(SWIG_As_int(obj3));
28466 if (SWIG_arg_fail(4)) SWIG_fail;
28467 }
28468 {
28469 PyThreadState* __tstate = wxPyBeginAllowThreads();
28470 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28471
28472 wxPyEndAllowThreads(__tstate);
28473 if (PyErr_Occurred()) SWIG_fail;
28474 }
28475 Py_INCREF(Py_None); resultobj = Py_None;
28476 return resultobj;
28477 fail:
28478 return NULL;
28479 }
28480
28481
28482 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28483 PyObject *resultobj;
28484 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28485 PyObject * obj0 = 0 ;
28486 char *kwnames[] = {
28487 (char *) "self", NULL
28488 };
28489
28490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28492 if (SWIG_arg_fail(1)) SWIG_fail;
28493 {
28494 PyThreadState* __tstate = wxPyBeginAllowThreads();
28495 delete arg1;
28496
28497 wxPyEndAllowThreads(__tstate);
28498 if (PyErr_Occurred()) SWIG_fail;
28499 }
28500 Py_INCREF(Py_None); resultobj = Py_None;
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28508 PyObject *resultobj;
28509 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28510 wxDataObject *arg2 = 0 ;
28511 PyObject * obj0 = 0 ;
28512 PyObject * obj1 = 0 ;
28513 char *kwnames[] = {
28514 (char *) "self",(char *) "data", NULL
28515 };
28516
28517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28519 if (SWIG_arg_fail(1)) SWIG_fail;
28520 {
28521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28522 if (SWIG_arg_fail(2)) SWIG_fail;
28523 if (arg2 == NULL) {
28524 SWIG_null_ref("wxDataObject");
28525 }
28526 if (SWIG_arg_fail(2)) SWIG_fail;
28527 }
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 (arg1)->SetData(*arg2);
28531
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 Py_INCREF(Py_None); resultobj = Py_None;
28536 return resultobj;
28537 fail:
28538 return NULL;
28539 }
28540
28541
28542 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28543 PyObject *resultobj;
28544 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28545 wxDataObject *result;
28546 PyObject * obj0 = 0 ;
28547 char *kwnames[] = {
28548 (char *) "self", NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28553 if (SWIG_arg_fail(1)) SWIG_fail;
28554 {
28555 PyThreadState* __tstate = wxPyBeginAllowThreads();
28556 result = (wxDataObject *)(arg1)->GetDataObject();
28557
28558 wxPyEndAllowThreads(__tstate);
28559 if (PyErr_Occurred()) SWIG_fail;
28560 }
28561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28562 return resultobj;
28563 fail:
28564 return NULL;
28565 }
28566
28567
28568 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28569 PyObject *resultobj;
28570 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28571 wxDragResult arg2 ;
28572 wxCursor *arg3 = 0 ;
28573 PyObject * obj0 = 0 ;
28574 PyObject * obj1 = 0 ;
28575 PyObject * obj2 = 0 ;
28576 char *kwnames[] = {
28577 (char *) "self",(char *) "res",(char *) "cursor", NULL
28578 };
28579
28580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28582 if (SWIG_arg_fail(1)) SWIG_fail;
28583 {
28584 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28585 if (SWIG_arg_fail(2)) SWIG_fail;
28586 }
28587 {
28588 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28589 if (SWIG_arg_fail(3)) SWIG_fail;
28590 if (arg3 == NULL) {
28591 SWIG_null_ref("wxCursor");
28592 }
28593 if (SWIG_arg_fail(3)) SWIG_fail;
28594 }
28595 {
28596 PyThreadState* __tstate = wxPyBeginAllowThreads();
28597 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28598
28599 wxPyEndAllowThreads(__tstate);
28600 if (PyErr_Occurred()) SWIG_fail;
28601 }
28602 Py_INCREF(Py_None); resultobj = Py_None;
28603 return resultobj;
28604 fail:
28605 return NULL;
28606 }
28607
28608
28609 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28610 PyObject *resultobj;
28611 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28612 int arg2 = (int) wxDrag_CopyOnly ;
28613 wxDragResult result;
28614 PyObject * obj0 = 0 ;
28615 PyObject * obj1 = 0 ;
28616 char *kwnames[] = {
28617 (char *) "self",(char *) "flags", NULL
28618 };
28619
28620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28622 if (SWIG_arg_fail(1)) SWIG_fail;
28623 if (obj1) {
28624 {
28625 arg2 = (int)(SWIG_As_int(obj1));
28626 if (SWIG_arg_fail(2)) SWIG_fail;
28627 }
28628 }
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28632
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 resultobj = SWIG_From_int((result));
28637 return resultobj;
28638 fail:
28639 return NULL;
28640 }
28641
28642
28643 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28644 PyObject *resultobj;
28645 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28646 wxDragResult arg2 ;
28647 bool result;
28648 PyObject * obj0 = 0 ;
28649 PyObject * obj1 = 0 ;
28650 char *kwnames[] = {
28651 (char *) "self",(char *) "effect", NULL
28652 };
28653
28654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(1)) SWIG_fail;
28657 {
28658 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28659 if (SWIG_arg_fail(2)) SWIG_fail;
28660 }
28661 {
28662 PyThreadState* __tstate = wxPyBeginAllowThreads();
28663 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28664
28665 wxPyEndAllowThreads(__tstate);
28666 if (PyErr_Occurred()) SWIG_fail;
28667 }
28668 {
28669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28670 }
28671 return resultobj;
28672 fail:
28673 return NULL;
28674 }
28675
28676
28677 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28678 PyObject *obj;
28679 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28680 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28681 Py_INCREF(obj);
28682 return Py_BuildValue((char *)"");
28683 }
28684 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28685 PyObject *resultobj;
28686 wxDataObject *arg1 = (wxDataObject *) NULL ;
28687 wxPyDropTarget *result;
28688 PyObject * obj0 = 0 ;
28689 char *kwnames[] = {
28690 (char *) "dataObject", NULL
28691 };
28692
28693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28694 if (obj0) {
28695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28696 if (SWIG_arg_fail(1)) SWIG_fail;
28697 }
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28701
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28713 PyObject *resultobj;
28714 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28715 PyObject *arg2 = (PyObject *) 0 ;
28716 PyObject *arg3 = (PyObject *) 0 ;
28717 PyObject * obj0 = 0 ;
28718 PyObject * obj1 = 0 ;
28719 PyObject * obj2 = 0 ;
28720 char *kwnames[] = {
28721 (char *) "self",(char *) "self",(char *) "_class", NULL
28722 };
28723
28724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28726 if (SWIG_arg_fail(1)) SWIG_fail;
28727 arg2 = obj1;
28728 arg3 = obj2;
28729 {
28730 PyThreadState* __tstate = wxPyBeginAllowThreads();
28731 (arg1)->_setCallbackInfo(arg2,arg3);
28732
28733 wxPyEndAllowThreads(__tstate);
28734 if (PyErr_Occurred()) SWIG_fail;
28735 }
28736 Py_INCREF(Py_None); resultobj = Py_None;
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28744 PyObject *resultobj;
28745 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28746 PyObject * obj0 = 0 ;
28747 char *kwnames[] = {
28748 (char *) "self", NULL
28749 };
28750
28751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28753 if (SWIG_arg_fail(1)) SWIG_fail;
28754 {
28755 PyThreadState* __tstate = wxPyBeginAllowThreads();
28756 delete arg1;
28757
28758 wxPyEndAllowThreads(__tstate);
28759 if (PyErr_Occurred()) SWIG_fail;
28760 }
28761 Py_INCREF(Py_None); resultobj = Py_None;
28762 return resultobj;
28763 fail:
28764 return NULL;
28765 }
28766
28767
28768 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28769 PyObject *resultobj;
28770 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28771 wxDataObject *result;
28772 PyObject * obj0 = 0 ;
28773 char *kwnames[] = {
28774 (char *) "self", NULL
28775 };
28776
28777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28779 if (SWIG_arg_fail(1)) SWIG_fail;
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 result = (wxDataObject *)(arg1)->GetDataObject();
28783
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj;
28796 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28797 wxDataObject *arg2 = (wxDataObject *) 0 ;
28798 PyObject * obj0 = 0 ;
28799 PyObject * obj1 = 0 ;
28800 char *kwnames[] = {
28801 (char *) "self",(char *) "dataObject", NULL
28802 };
28803
28804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28806 if (SWIG_arg_fail(1)) SWIG_fail;
28807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28808 if (SWIG_arg_fail(2)) SWIG_fail;
28809 {
28810 PyThreadState* __tstate = wxPyBeginAllowThreads();
28811 (arg1)->SetDataObject(arg2);
28812
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 Py_INCREF(Py_None); resultobj = Py_None;
28817 return resultobj;
28818 fail:
28819 return NULL;
28820 }
28821
28822
28823 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28824 PyObject *resultobj;
28825 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28826 int arg2 ;
28827 int arg3 ;
28828 wxDragResult arg4 ;
28829 wxDragResult result;
28830 PyObject * obj0 = 0 ;
28831 PyObject * obj1 = 0 ;
28832 PyObject * obj2 = 0 ;
28833 PyObject * obj3 = 0 ;
28834 char *kwnames[] = {
28835 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28836 };
28837
28838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28840 if (SWIG_arg_fail(1)) SWIG_fail;
28841 {
28842 arg2 = (int)(SWIG_As_int(obj1));
28843 if (SWIG_arg_fail(2)) SWIG_fail;
28844 }
28845 {
28846 arg3 = (int)(SWIG_As_int(obj2));
28847 if (SWIG_arg_fail(3)) SWIG_fail;
28848 }
28849 {
28850 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28851 if (SWIG_arg_fail(4)) SWIG_fail;
28852 }
28853 {
28854 PyThreadState* __tstate = wxPyBeginAllowThreads();
28855 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28856
28857 wxPyEndAllowThreads(__tstate);
28858 if (PyErr_Occurred()) SWIG_fail;
28859 }
28860 resultobj = SWIG_From_int((result));
28861 return resultobj;
28862 fail:
28863 return NULL;
28864 }
28865
28866
28867 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28868 PyObject *resultobj;
28869 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28870 int arg2 ;
28871 int arg3 ;
28872 wxDragResult arg4 ;
28873 wxDragResult result;
28874 PyObject * obj0 = 0 ;
28875 PyObject * obj1 = 0 ;
28876 PyObject * obj2 = 0 ;
28877 PyObject * obj3 = 0 ;
28878 char *kwnames[] = {
28879 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28880 };
28881
28882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28884 if (SWIG_arg_fail(1)) SWIG_fail;
28885 {
28886 arg2 = (int)(SWIG_As_int(obj1));
28887 if (SWIG_arg_fail(2)) SWIG_fail;
28888 }
28889 {
28890 arg3 = (int)(SWIG_As_int(obj2));
28891 if (SWIG_arg_fail(3)) SWIG_fail;
28892 }
28893 {
28894 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28895 if (SWIG_arg_fail(4)) SWIG_fail;
28896 }
28897 {
28898 PyThreadState* __tstate = wxPyBeginAllowThreads();
28899 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28900
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 resultobj = SWIG_From_int((result));
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28912 PyObject *resultobj;
28913 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28914 PyObject * obj0 = 0 ;
28915 char *kwnames[] = {
28916 (char *) "self", NULL
28917 };
28918
28919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28921 if (SWIG_arg_fail(1)) SWIG_fail;
28922 {
28923 PyThreadState* __tstate = wxPyBeginAllowThreads();
28924 (arg1)->base_OnLeave();
28925
28926 wxPyEndAllowThreads(__tstate);
28927 if (PyErr_Occurred()) SWIG_fail;
28928 }
28929 Py_INCREF(Py_None); resultobj = Py_None;
28930 return resultobj;
28931 fail:
28932 return NULL;
28933 }
28934
28935
28936 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28937 PyObject *resultobj;
28938 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28939 int arg2 ;
28940 int arg3 ;
28941 bool result;
28942 PyObject * obj0 = 0 ;
28943 PyObject * obj1 = 0 ;
28944 PyObject * obj2 = 0 ;
28945 char *kwnames[] = {
28946 (char *) "self",(char *) "x",(char *) "y", NULL
28947 };
28948
28949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28951 if (SWIG_arg_fail(1)) SWIG_fail;
28952 {
28953 arg2 = (int)(SWIG_As_int(obj1));
28954 if (SWIG_arg_fail(2)) SWIG_fail;
28955 }
28956 {
28957 arg3 = (int)(SWIG_As_int(obj2));
28958 if (SWIG_arg_fail(3)) SWIG_fail;
28959 }
28960 {
28961 PyThreadState* __tstate = wxPyBeginAllowThreads();
28962 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28963
28964 wxPyEndAllowThreads(__tstate);
28965 if (PyErr_Occurred()) SWIG_fail;
28966 }
28967 {
28968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28969 }
28970 return resultobj;
28971 fail:
28972 return NULL;
28973 }
28974
28975
28976 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28977 PyObject *resultobj;
28978 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28979 bool result;
28980 PyObject * obj0 = 0 ;
28981 char *kwnames[] = {
28982 (char *) "self", NULL
28983 };
28984
28985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28987 if (SWIG_arg_fail(1)) SWIG_fail;
28988 {
28989 PyThreadState* __tstate = wxPyBeginAllowThreads();
28990 result = (bool)(arg1)->GetData();
28991
28992 wxPyEndAllowThreads(__tstate);
28993 if (PyErr_Occurred()) SWIG_fail;
28994 }
28995 {
28996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28997 }
28998 return resultobj;
28999 fail:
29000 return NULL;
29001 }
29002
29003
29004 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29005 PyObject *obj;
29006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29007 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29008 Py_INCREF(obj);
29009 return Py_BuildValue((char *)"");
29010 }
29011 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29012 PyObject *resultobj;
29013 wxPyTextDropTarget *result;
29014 char *kwnames[] = {
29015 NULL
29016 };
29017
29018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29019 {
29020 PyThreadState* __tstate = wxPyBeginAllowThreads();
29021 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29022
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29027 return resultobj;
29028 fail:
29029 return NULL;
29030 }
29031
29032
29033 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29034 PyObject *resultobj;
29035 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29036 PyObject *arg2 = (PyObject *) 0 ;
29037 PyObject *arg3 = (PyObject *) 0 ;
29038 PyObject * obj0 = 0 ;
29039 PyObject * obj1 = 0 ;
29040 PyObject * obj2 = 0 ;
29041 char *kwnames[] = {
29042 (char *) "self",(char *) "self",(char *) "_class", NULL
29043 };
29044
29045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29047 if (SWIG_arg_fail(1)) SWIG_fail;
29048 arg2 = obj1;
29049 arg3 = obj2;
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 (arg1)->_setCallbackInfo(arg2,arg3);
29053
29054 wxPyEndAllowThreads(__tstate);
29055 if (PyErr_Occurred()) SWIG_fail;
29056 }
29057 Py_INCREF(Py_None); resultobj = Py_None;
29058 return resultobj;
29059 fail:
29060 return NULL;
29061 }
29062
29063
29064 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj;
29066 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29067 int arg2 ;
29068 int arg3 ;
29069 wxDragResult arg4 ;
29070 wxDragResult result;
29071 PyObject * obj0 = 0 ;
29072 PyObject * obj1 = 0 ;
29073 PyObject * obj2 = 0 ;
29074 PyObject * obj3 = 0 ;
29075 char *kwnames[] = {
29076 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29077 };
29078
29079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29081 if (SWIG_arg_fail(1)) SWIG_fail;
29082 {
29083 arg2 = (int)(SWIG_As_int(obj1));
29084 if (SWIG_arg_fail(2)) SWIG_fail;
29085 }
29086 {
29087 arg3 = (int)(SWIG_As_int(obj2));
29088 if (SWIG_arg_fail(3)) SWIG_fail;
29089 }
29090 {
29091 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29092 if (SWIG_arg_fail(4)) SWIG_fail;
29093 }
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29097
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 resultobj = SWIG_From_int((result));
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj;
29110 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29111 int arg2 ;
29112 int arg3 ;
29113 wxDragResult arg4 ;
29114 wxDragResult result;
29115 PyObject * obj0 = 0 ;
29116 PyObject * obj1 = 0 ;
29117 PyObject * obj2 = 0 ;
29118 PyObject * obj3 = 0 ;
29119 char *kwnames[] = {
29120 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29121 };
29122
29123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29125 if (SWIG_arg_fail(1)) SWIG_fail;
29126 {
29127 arg2 = (int)(SWIG_As_int(obj1));
29128 if (SWIG_arg_fail(2)) SWIG_fail;
29129 }
29130 {
29131 arg3 = (int)(SWIG_As_int(obj2));
29132 if (SWIG_arg_fail(3)) SWIG_fail;
29133 }
29134 {
29135 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29136 if (SWIG_arg_fail(4)) SWIG_fail;
29137 }
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29141
29142 wxPyEndAllowThreads(__tstate);
29143 if (PyErr_Occurred()) SWIG_fail;
29144 }
29145 resultobj = SWIG_From_int((result));
29146 return resultobj;
29147 fail:
29148 return NULL;
29149 }
29150
29151
29152 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj;
29154 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29155 PyObject * obj0 = 0 ;
29156 char *kwnames[] = {
29157 (char *) "self", NULL
29158 };
29159
29160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29162 if (SWIG_arg_fail(1)) SWIG_fail;
29163 {
29164 PyThreadState* __tstate = wxPyBeginAllowThreads();
29165 (arg1)->base_OnLeave();
29166
29167 wxPyEndAllowThreads(__tstate);
29168 if (PyErr_Occurred()) SWIG_fail;
29169 }
29170 Py_INCREF(Py_None); resultobj = Py_None;
29171 return resultobj;
29172 fail:
29173 return NULL;
29174 }
29175
29176
29177 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29178 PyObject *resultobj;
29179 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29180 int arg2 ;
29181 int arg3 ;
29182 bool result;
29183 PyObject * obj0 = 0 ;
29184 PyObject * obj1 = 0 ;
29185 PyObject * obj2 = 0 ;
29186 char *kwnames[] = {
29187 (char *) "self",(char *) "x",(char *) "y", NULL
29188 };
29189
29190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29192 if (SWIG_arg_fail(1)) SWIG_fail;
29193 {
29194 arg2 = (int)(SWIG_As_int(obj1));
29195 if (SWIG_arg_fail(2)) SWIG_fail;
29196 }
29197 {
29198 arg3 = (int)(SWIG_As_int(obj2));
29199 if (SWIG_arg_fail(3)) SWIG_fail;
29200 }
29201 {
29202 PyThreadState* __tstate = wxPyBeginAllowThreads();
29203 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29204
29205 wxPyEndAllowThreads(__tstate);
29206 if (PyErr_Occurred()) SWIG_fail;
29207 }
29208 {
29209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29210 }
29211 return resultobj;
29212 fail:
29213 return NULL;
29214 }
29215
29216
29217 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29218 PyObject *resultobj;
29219 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29220 int arg2 ;
29221 int arg3 ;
29222 wxDragResult arg4 ;
29223 wxDragResult result;
29224 PyObject * obj0 = 0 ;
29225 PyObject * obj1 = 0 ;
29226 PyObject * obj2 = 0 ;
29227 PyObject * obj3 = 0 ;
29228 char *kwnames[] = {
29229 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29230 };
29231
29232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29234 if (SWIG_arg_fail(1)) SWIG_fail;
29235 {
29236 arg2 = (int)(SWIG_As_int(obj1));
29237 if (SWIG_arg_fail(2)) SWIG_fail;
29238 }
29239 {
29240 arg3 = (int)(SWIG_As_int(obj2));
29241 if (SWIG_arg_fail(3)) SWIG_fail;
29242 }
29243 {
29244 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29245 if (SWIG_arg_fail(4)) SWIG_fail;
29246 }
29247 {
29248 PyThreadState* __tstate = wxPyBeginAllowThreads();
29249 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29250
29251 wxPyEndAllowThreads(__tstate);
29252 if (PyErr_Occurred()) SWIG_fail;
29253 }
29254 resultobj = SWIG_From_int((result));
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29262 PyObject *obj;
29263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29264 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29265 Py_INCREF(obj);
29266 return Py_BuildValue((char *)"");
29267 }
29268 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29269 PyObject *resultobj;
29270 wxPyFileDropTarget *result;
29271 char *kwnames[] = {
29272 NULL
29273 };
29274
29275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29279
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj;
29292 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29293 PyObject *arg2 = (PyObject *) 0 ;
29294 PyObject *arg3 = (PyObject *) 0 ;
29295 PyObject * obj0 = 0 ;
29296 PyObject * obj1 = 0 ;
29297 PyObject * obj2 = 0 ;
29298 char *kwnames[] = {
29299 (char *) "self",(char *) "self",(char *) "_class", NULL
29300 };
29301
29302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29304 if (SWIG_arg_fail(1)) SWIG_fail;
29305 arg2 = obj1;
29306 arg3 = obj2;
29307 {
29308 PyThreadState* __tstate = wxPyBeginAllowThreads();
29309 (arg1)->_setCallbackInfo(arg2,arg3);
29310
29311 wxPyEndAllowThreads(__tstate);
29312 if (PyErr_Occurred()) SWIG_fail;
29313 }
29314 Py_INCREF(Py_None); resultobj = Py_None;
29315 return resultobj;
29316 fail:
29317 return NULL;
29318 }
29319
29320
29321 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29322 PyObject *resultobj;
29323 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29324 int arg2 ;
29325 int arg3 ;
29326 wxDragResult arg4 ;
29327 wxDragResult result;
29328 PyObject * obj0 = 0 ;
29329 PyObject * obj1 = 0 ;
29330 PyObject * obj2 = 0 ;
29331 PyObject * obj3 = 0 ;
29332 char *kwnames[] = {
29333 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29334 };
29335
29336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29338 if (SWIG_arg_fail(1)) SWIG_fail;
29339 {
29340 arg2 = (int)(SWIG_As_int(obj1));
29341 if (SWIG_arg_fail(2)) SWIG_fail;
29342 }
29343 {
29344 arg3 = (int)(SWIG_As_int(obj2));
29345 if (SWIG_arg_fail(3)) SWIG_fail;
29346 }
29347 {
29348 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29349 if (SWIG_arg_fail(4)) SWIG_fail;
29350 }
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29354
29355 wxPyEndAllowThreads(__tstate);
29356 if (PyErr_Occurred()) SWIG_fail;
29357 }
29358 resultobj = SWIG_From_int((result));
29359 return resultobj;
29360 fail:
29361 return NULL;
29362 }
29363
29364
29365 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29366 PyObject *resultobj;
29367 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29368 int arg2 ;
29369 int arg3 ;
29370 wxDragResult arg4 ;
29371 wxDragResult result;
29372 PyObject * obj0 = 0 ;
29373 PyObject * obj1 = 0 ;
29374 PyObject * obj2 = 0 ;
29375 PyObject * obj3 = 0 ;
29376 char *kwnames[] = {
29377 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29378 };
29379
29380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29382 if (SWIG_arg_fail(1)) SWIG_fail;
29383 {
29384 arg2 = (int)(SWIG_As_int(obj1));
29385 if (SWIG_arg_fail(2)) SWIG_fail;
29386 }
29387 {
29388 arg3 = (int)(SWIG_As_int(obj2));
29389 if (SWIG_arg_fail(3)) SWIG_fail;
29390 }
29391 {
29392 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29393 if (SWIG_arg_fail(4)) SWIG_fail;
29394 }
29395 {
29396 PyThreadState* __tstate = wxPyBeginAllowThreads();
29397 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29398
29399 wxPyEndAllowThreads(__tstate);
29400 if (PyErr_Occurred()) SWIG_fail;
29401 }
29402 resultobj = SWIG_From_int((result));
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29410 PyObject *resultobj;
29411 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29412 PyObject * obj0 = 0 ;
29413 char *kwnames[] = {
29414 (char *) "self", NULL
29415 };
29416
29417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29419 if (SWIG_arg_fail(1)) SWIG_fail;
29420 {
29421 PyThreadState* __tstate = wxPyBeginAllowThreads();
29422 (arg1)->base_OnLeave();
29423
29424 wxPyEndAllowThreads(__tstate);
29425 if (PyErr_Occurred()) SWIG_fail;
29426 }
29427 Py_INCREF(Py_None); resultobj = Py_None;
29428 return resultobj;
29429 fail:
29430 return NULL;
29431 }
29432
29433
29434 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29435 PyObject *resultobj;
29436 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29437 int arg2 ;
29438 int arg3 ;
29439 bool result;
29440 PyObject * obj0 = 0 ;
29441 PyObject * obj1 = 0 ;
29442 PyObject * obj2 = 0 ;
29443 char *kwnames[] = {
29444 (char *) "self",(char *) "x",(char *) "y", NULL
29445 };
29446
29447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29449 if (SWIG_arg_fail(1)) SWIG_fail;
29450 {
29451 arg2 = (int)(SWIG_As_int(obj1));
29452 if (SWIG_arg_fail(2)) SWIG_fail;
29453 }
29454 {
29455 arg3 = (int)(SWIG_As_int(obj2));
29456 if (SWIG_arg_fail(3)) SWIG_fail;
29457 }
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29461
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 {
29466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29467 }
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj;
29476 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29477 int arg2 ;
29478 int arg3 ;
29479 wxDragResult arg4 ;
29480 wxDragResult result;
29481 PyObject * obj0 = 0 ;
29482 PyObject * obj1 = 0 ;
29483 PyObject * obj2 = 0 ;
29484 PyObject * obj3 = 0 ;
29485 char *kwnames[] = {
29486 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29487 };
29488
29489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29491 if (SWIG_arg_fail(1)) SWIG_fail;
29492 {
29493 arg2 = (int)(SWIG_As_int(obj1));
29494 if (SWIG_arg_fail(2)) SWIG_fail;
29495 }
29496 {
29497 arg3 = (int)(SWIG_As_int(obj2));
29498 if (SWIG_arg_fail(3)) SWIG_fail;
29499 }
29500 {
29501 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29502 if (SWIG_arg_fail(4)) SWIG_fail;
29503 }
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29507
29508 wxPyEndAllowThreads(__tstate);
29509 if (PyErr_Occurred()) SWIG_fail;
29510 }
29511 resultobj = SWIG_From_int((result));
29512 return resultobj;
29513 fail:
29514 return NULL;
29515 }
29516
29517
29518 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29519 PyObject *obj;
29520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29521 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29522 Py_INCREF(obj);
29523 return Py_BuildValue((char *)"");
29524 }
29525 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29526 PyObject *resultobj;
29527 wxClipboard *result;
29528 char *kwnames[] = {
29529 NULL
29530 };
29531
29532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29533 {
29534 PyThreadState* __tstate = wxPyBeginAllowThreads();
29535 result = (wxClipboard *)new wxClipboard();
29536
29537 wxPyEndAllowThreads(__tstate);
29538 if (PyErr_Occurred()) SWIG_fail;
29539 }
29540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29541 return resultobj;
29542 fail:
29543 return NULL;
29544 }
29545
29546
29547 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29548 PyObject *resultobj;
29549 wxClipboard *arg1 = (wxClipboard *) 0 ;
29550 PyObject * obj0 = 0 ;
29551 char *kwnames[] = {
29552 (char *) "self", NULL
29553 };
29554
29555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29557 if (SWIG_arg_fail(1)) SWIG_fail;
29558 {
29559 PyThreadState* __tstate = wxPyBeginAllowThreads();
29560 delete arg1;
29561
29562 wxPyEndAllowThreads(__tstate);
29563 if (PyErr_Occurred()) SWIG_fail;
29564 }
29565 Py_INCREF(Py_None); resultobj = Py_None;
29566 return resultobj;
29567 fail:
29568 return NULL;
29569 }
29570
29571
29572 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29573 PyObject *resultobj;
29574 wxClipboard *arg1 = (wxClipboard *) 0 ;
29575 bool result;
29576 PyObject * obj0 = 0 ;
29577 char *kwnames[] = {
29578 (char *) "self", NULL
29579 };
29580
29581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29583 if (SWIG_arg_fail(1)) SWIG_fail;
29584 {
29585 PyThreadState* __tstate = wxPyBeginAllowThreads();
29586 result = (bool)(arg1)->Open();
29587
29588 wxPyEndAllowThreads(__tstate);
29589 if (PyErr_Occurred()) SWIG_fail;
29590 }
29591 {
29592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29593 }
29594 return resultobj;
29595 fail:
29596 return NULL;
29597 }
29598
29599
29600 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29601 PyObject *resultobj;
29602 wxClipboard *arg1 = (wxClipboard *) 0 ;
29603 PyObject * obj0 = 0 ;
29604 char *kwnames[] = {
29605 (char *) "self", NULL
29606 };
29607
29608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29610 if (SWIG_arg_fail(1)) SWIG_fail;
29611 {
29612 PyThreadState* __tstate = wxPyBeginAllowThreads();
29613 (arg1)->Close();
29614
29615 wxPyEndAllowThreads(__tstate);
29616 if (PyErr_Occurred()) SWIG_fail;
29617 }
29618 Py_INCREF(Py_None); resultobj = Py_None;
29619 return resultobj;
29620 fail:
29621 return NULL;
29622 }
29623
29624
29625 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29626 PyObject *resultobj;
29627 wxClipboard *arg1 = (wxClipboard *) 0 ;
29628 bool result;
29629 PyObject * obj0 = 0 ;
29630 char *kwnames[] = {
29631 (char *) "self", NULL
29632 };
29633
29634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29636 if (SWIG_arg_fail(1)) SWIG_fail;
29637 {
29638 PyThreadState* __tstate = wxPyBeginAllowThreads();
29639 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29640
29641 wxPyEndAllowThreads(__tstate);
29642 if (PyErr_Occurred()) SWIG_fail;
29643 }
29644 {
29645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29646 }
29647 return resultobj;
29648 fail:
29649 return NULL;
29650 }
29651
29652
29653 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29654 PyObject *resultobj;
29655 wxClipboard *arg1 = (wxClipboard *) 0 ;
29656 wxDataObject *arg2 = (wxDataObject *) 0 ;
29657 bool result;
29658 PyObject * obj0 = 0 ;
29659 PyObject * obj1 = 0 ;
29660 char *kwnames[] = {
29661 (char *) "self",(char *) "data", NULL
29662 };
29663
29664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29666 if (SWIG_arg_fail(1)) SWIG_fail;
29667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29668 if (SWIG_arg_fail(2)) SWIG_fail;
29669 {
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 result = (bool)(arg1)->AddData(arg2);
29672
29673 wxPyEndAllowThreads(__tstate);
29674 if (PyErr_Occurred()) SWIG_fail;
29675 }
29676 {
29677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29678 }
29679 return resultobj;
29680 fail:
29681 return NULL;
29682 }
29683
29684
29685 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29686 PyObject *resultobj;
29687 wxClipboard *arg1 = (wxClipboard *) 0 ;
29688 wxDataObject *arg2 = (wxDataObject *) 0 ;
29689 bool result;
29690 PyObject * obj0 = 0 ;
29691 PyObject * obj1 = 0 ;
29692 char *kwnames[] = {
29693 (char *) "self",(char *) "data", NULL
29694 };
29695
29696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29698 if (SWIG_arg_fail(1)) SWIG_fail;
29699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29700 if (SWIG_arg_fail(2)) SWIG_fail;
29701 {
29702 PyThreadState* __tstate = wxPyBeginAllowThreads();
29703 result = (bool)(arg1)->SetData(arg2);
29704
29705 wxPyEndAllowThreads(__tstate);
29706 if (PyErr_Occurred()) SWIG_fail;
29707 }
29708 {
29709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29710 }
29711 return resultobj;
29712 fail:
29713 return NULL;
29714 }
29715
29716
29717 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29718 PyObject *resultobj;
29719 wxClipboard *arg1 = (wxClipboard *) 0 ;
29720 wxDataFormat *arg2 = 0 ;
29721 bool result;
29722 PyObject * obj0 = 0 ;
29723 PyObject * obj1 = 0 ;
29724 char *kwnames[] = {
29725 (char *) "self",(char *) "format", NULL
29726 };
29727
29728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29733 if (SWIG_arg_fail(2)) SWIG_fail;
29734 if (arg2 == NULL) {
29735 SWIG_null_ref("wxDataFormat");
29736 }
29737 if (SWIG_arg_fail(2)) SWIG_fail;
29738 }
29739 {
29740 PyThreadState* __tstate = wxPyBeginAllowThreads();
29741 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29742
29743 wxPyEndAllowThreads(__tstate);
29744 if (PyErr_Occurred()) SWIG_fail;
29745 }
29746 {
29747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29748 }
29749 return resultobj;
29750 fail:
29751 return NULL;
29752 }
29753
29754
29755 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29756 PyObject *resultobj;
29757 wxClipboard *arg1 = (wxClipboard *) 0 ;
29758 wxDataObject *arg2 = 0 ;
29759 bool result;
29760 PyObject * obj0 = 0 ;
29761 PyObject * obj1 = 0 ;
29762 char *kwnames[] = {
29763 (char *) "self",(char *) "data", NULL
29764 };
29765
29766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29768 if (SWIG_arg_fail(1)) SWIG_fail;
29769 {
29770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29771 if (SWIG_arg_fail(2)) SWIG_fail;
29772 if (arg2 == NULL) {
29773 SWIG_null_ref("wxDataObject");
29774 }
29775 if (SWIG_arg_fail(2)) SWIG_fail;
29776 }
29777 {
29778 PyThreadState* __tstate = wxPyBeginAllowThreads();
29779 result = (bool)(arg1)->GetData(*arg2);
29780
29781 wxPyEndAllowThreads(__tstate);
29782 if (PyErr_Occurred()) SWIG_fail;
29783 }
29784 {
29785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29786 }
29787 return resultobj;
29788 fail:
29789 return NULL;
29790 }
29791
29792
29793 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29794 PyObject *resultobj;
29795 wxClipboard *arg1 = (wxClipboard *) 0 ;
29796 PyObject * obj0 = 0 ;
29797 char *kwnames[] = {
29798 (char *) "self", NULL
29799 };
29800
29801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29803 if (SWIG_arg_fail(1)) SWIG_fail;
29804 {
29805 PyThreadState* __tstate = wxPyBeginAllowThreads();
29806 (arg1)->Clear();
29807
29808 wxPyEndAllowThreads(__tstate);
29809 if (PyErr_Occurred()) SWIG_fail;
29810 }
29811 Py_INCREF(Py_None); resultobj = Py_None;
29812 return resultobj;
29813 fail:
29814 return NULL;
29815 }
29816
29817
29818 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29819 PyObject *resultobj;
29820 wxClipboard *arg1 = (wxClipboard *) 0 ;
29821 bool result;
29822 PyObject * obj0 = 0 ;
29823 char *kwnames[] = {
29824 (char *) "self", NULL
29825 };
29826
29827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29829 if (SWIG_arg_fail(1)) SWIG_fail;
29830 {
29831 PyThreadState* __tstate = wxPyBeginAllowThreads();
29832 result = (bool)(arg1)->Flush();
29833
29834 wxPyEndAllowThreads(__tstate);
29835 if (PyErr_Occurred()) SWIG_fail;
29836 }
29837 {
29838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29839 }
29840 return resultobj;
29841 fail:
29842 return NULL;
29843 }
29844
29845
29846 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29847 PyObject *resultobj;
29848 wxClipboard *arg1 = (wxClipboard *) 0 ;
29849 bool arg2 = (bool) true ;
29850 PyObject * obj0 = 0 ;
29851 PyObject * obj1 = 0 ;
29852 char *kwnames[] = {
29853 (char *) "self",(char *) "primary", NULL
29854 };
29855
29856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29858 if (SWIG_arg_fail(1)) SWIG_fail;
29859 if (obj1) {
29860 {
29861 arg2 = (bool)(SWIG_As_bool(obj1));
29862 if (SWIG_arg_fail(2)) SWIG_fail;
29863 }
29864 }
29865 {
29866 PyThreadState* __tstate = wxPyBeginAllowThreads();
29867 (arg1)->UsePrimarySelection(arg2);
29868
29869 wxPyEndAllowThreads(__tstate);
29870 if (PyErr_Occurred()) SWIG_fail;
29871 }
29872 Py_INCREF(Py_None); resultobj = Py_None;
29873 return resultobj;
29874 fail:
29875 return NULL;
29876 }
29877
29878
29879 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29880 PyObject *resultobj;
29881 wxClipboard *result;
29882 char *kwnames[] = {
29883 NULL
29884 };
29885
29886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29887 {
29888 PyThreadState* __tstate = wxPyBeginAllowThreads();
29889 result = (wxClipboard *)wxClipboard::Get();
29890
29891 wxPyEndAllowThreads(__tstate);
29892 if (PyErr_Occurred()) SWIG_fail;
29893 }
29894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29895 return resultobj;
29896 fail:
29897 return NULL;
29898 }
29899
29900
29901 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29902 PyObject *obj;
29903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29904 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29905 Py_INCREF(obj);
29906 return Py_BuildValue((char *)"");
29907 }
29908 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29909 PyObject *resultobj;
29910 wxClipboard *arg1 = (wxClipboard *) NULL ;
29911 wxClipboardLocker *result;
29912 PyObject * obj0 = 0 ;
29913 char *kwnames[] = {
29914 (char *) "clipboard", NULL
29915 };
29916
29917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29918 if (obj0) {
29919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29920 if (SWIG_arg_fail(1)) SWIG_fail;
29921 }
29922 {
29923 PyThreadState* __tstate = wxPyBeginAllowThreads();
29924 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29925
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29930 return resultobj;
29931 fail:
29932 return NULL;
29933 }
29934
29935
29936 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29937 PyObject *resultobj;
29938 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29939 PyObject * obj0 = 0 ;
29940 char *kwnames[] = {
29941 (char *) "self", NULL
29942 };
29943
29944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29946 if (SWIG_arg_fail(1)) SWIG_fail;
29947 {
29948 PyThreadState* __tstate = wxPyBeginAllowThreads();
29949 delete arg1;
29950
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 Py_INCREF(Py_None); resultobj = Py_None;
29955 return resultobj;
29956 fail:
29957 return NULL;
29958 }
29959
29960
29961 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29962 PyObject *resultobj;
29963 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29964 bool result;
29965 PyObject * obj0 = 0 ;
29966 char *kwnames[] = {
29967 (char *) "self", NULL
29968 };
29969
29970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29972 if (SWIG_arg_fail(1)) SWIG_fail;
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 result = (bool)wxClipboardLocker___nonzero__(arg1);
29976
29977 wxPyEndAllowThreads(__tstate);
29978 if (PyErr_Occurred()) SWIG_fail;
29979 }
29980 {
29981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29982 }
29983 return resultobj;
29984 fail:
29985 return NULL;
29986 }
29987
29988
29989 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29990 PyObject *obj;
29991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29992 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29993 Py_INCREF(obj);
29994 return Py_BuildValue((char *)"");
29995 }
29996 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29997 PyObject *resultobj;
29998 int arg1 = (int) 0 ;
29999 int arg2 = (int) 0 ;
30000 int arg3 = (int) 0 ;
30001 int arg4 = (int) 0 ;
30002 wxVideoMode *result;
30003 PyObject * obj0 = 0 ;
30004 PyObject * obj1 = 0 ;
30005 PyObject * obj2 = 0 ;
30006 PyObject * obj3 = 0 ;
30007 char *kwnames[] = {
30008 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30009 };
30010
30011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30012 if (obj0) {
30013 {
30014 arg1 = (int)(SWIG_As_int(obj0));
30015 if (SWIG_arg_fail(1)) SWIG_fail;
30016 }
30017 }
30018 if (obj1) {
30019 {
30020 arg2 = (int)(SWIG_As_int(obj1));
30021 if (SWIG_arg_fail(2)) SWIG_fail;
30022 }
30023 }
30024 if (obj2) {
30025 {
30026 arg3 = (int)(SWIG_As_int(obj2));
30027 if (SWIG_arg_fail(3)) SWIG_fail;
30028 }
30029 }
30030 if (obj3) {
30031 {
30032 arg4 = (int)(SWIG_As_int(obj3));
30033 if (SWIG_arg_fail(4)) SWIG_fail;
30034 }
30035 }
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30039
30040 wxPyEndAllowThreads(__tstate);
30041 if (PyErr_Occurred()) SWIG_fail;
30042 }
30043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30044 return resultobj;
30045 fail:
30046 return NULL;
30047 }
30048
30049
30050 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30051 PyObject *resultobj;
30052 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30053 PyObject * obj0 = 0 ;
30054 char *kwnames[] = {
30055 (char *) "self", NULL
30056 };
30057
30058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30060 if (SWIG_arg_fail(1)) SWIG_fail;
30061 {
30062 PyThreadState* __tstate = wxPyBeginAllowThreads();
30063 delete arg1;
30064
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 Py_INCREF(Py_None); resultobj = Py_None;
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30076 PyObject *resultobj;
30077 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30078 wxVideoMode *arg2 = 0 ;
30079 bool result;
30080 PyObject * obj0 = 0 ;
30081 PyObject * obj1 = 0 ;
30082 char *kwnames[] = {
30083 (char *) "self",(char *) "other", NULL
30084 };
30085
30086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30088 if (SWIG_arg_fail(1)) SWIG_fail;
30089 {
30090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30091 if (SWIG_arg_fail(2)) SWIG_fail;
30092 if (arg2 == NULL) {
30093 SWIG_null_ref("wxVideoMode");
30094 }
30095 if (SWIG_arg_fail(2)) SWIG_fail;
30096 }
30097 {
30098 PyThreadState* __tstate = wxPyBeginAllowThreads();
30099 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30100
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 {
30105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30106 }
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30114 PyObject *resultobj;
30115 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30116 int result;
30117 PyObject * obj0 = 0 ;
30118 char *kwnames[] = {
30119 (char *) "self", NULL
30120 };
30121
30122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30124 if (SWIG_arg_fail(1)) SWIG_fail;
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30128
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 {
30133 resultobj = SWIG_From_int((int)(result));
30134 }
30135 return resultobj;
30136 fail:
30137 return NULL;
30138 }
30139
30140
30141 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30142 PyObject *resultobj;
30143 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30144 int result;
30145 PyObject * obj0 = 0 ;
30146 char *kwnames[] = {
30147 (char *) "self", NULL
30148 };
30149
30150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30152 if (SWIG_arg_fail(1)) SWIG_fail;
30153 {
30154 PyThreadState* __tstate = wxPyBeginAllowThreads();
30155 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30156
30157 wxPyEndAllowThreads(__tstate);
30158 if (PyErr_Occurred()) SWIG_fail;
30159 }
30160 {
30161 resultobj = SWIG_From_int((int)(result));
30162 }
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30170 PyObject *resultobj;
30171 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30172 int result;
30173 PyObject * obj0 = 0 ;
30174 char *kwnames[] = {
30175 (char *) "self", NULL
30176 };
30177
30178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30180 if (SWIG_arg_fail(1)) SWIG_fail;
30181 {
30182 PyThreadState* __tstate = wxPyBeginAllowThreads();
30183 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30184
30185 wxPyEndAllowThreads(__tstate);
30186 if (PyErr_Occurred()) SWIG_fail;
30187 }
30188 {
30189 resultobj = SWIG_From_int((int)(result));
30190 }
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30198 PyObject *resultobj;
30199 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30200 bool result;
30201 PyObject * obj0 = 0 ;
30202 char *kwnames[] = {
30203 (char *) "self", NULL
30204 };
30205
30206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30208 if (SWIG_arg_fail(1)) SWIG_fail;
30209 {
30210 PyThreadState* __tstate = wxPyBeginAllowThreads();
30211 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30212
30213 wxPyEndAllowThreads(__tstate);
30214 if (PyErr_Occurred()) SWIG_fail;
30215 }
30216 {
30217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30218 }
30219 return resultobj;
30220 fail:
30221 return NULL;
30222 }
30223
30224
30225 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30226 PyObject *resultobj;
30227 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30228 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30229 bool result;
30230 PyObject * obj0 = 0 ;
30231 PyObject * obj1 = 0 ;
30232 char *kwnames[] = {
30233 (char *) "self",(char *) "other", NULL
30234 };
30235
30236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30238 if (SWIG_arg_fail(1)) SWIG_fail;
30239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30240 if (SWIG_arg_fail(2)) SWIG_fail;
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30244
30245 wxPyEndAllowThreads(__tstate);
30246 if (PyErr_Occurred()) SWIG_fail;
30247 }
30248 {
30249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30250 }
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30258 PyObject *resultobj;
30259 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30260 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30261 bool result;
30262 PyObject * obj0 = 0 ;
30263 PyObject * obj1 = 0 ;
30264 char *kwnames[] = {
30265 (char *) "self",(char *) "other", NULL
30266 };
30267
30268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(1)) SWIG_fail;
30271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30272 if (SWIG_arg_fail(2)) SWIG_fail;
30273 {
30274 PyThreadState* __tstate = wxPyBeginAllowThreads();
30275 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30276
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 {
30281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30282 }
30283 return resultobj;
30284 fail:
30285 return NULL;
30286 }
30287
30288
30289 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30290 PyObject *resultobj;
30291 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30292 int arg2 ;
30293 PyObject * obj0 = 0 ;
30294 PyObject * obj1 = 0 ;
30295 char *kwnames[] = {
30296 (char *) "self",(char *) "w", NULL
30297 };
30298
30299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30301 if (SWIG_arg_fail(1)) SWIG_fail;
30302 {
30303 arg2 = (int)(SWIG_As_int(obj1));
30304 if (SWIG_arg_fail(2)) SWIG_fail;
30305 }
30306 if (arg1) (arg1)->w = arg2;
30307
30308 Py_INCREF(Py_None); resultobj = Py_None;
30309 return resultobj;
30310 fail:
30311 return NULL;
30312 }
30313
30314
30315 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30316 PyObject *resultobj;
30317 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30318 int result;
30319 PyObject * obj0 = 0 ;
30320 char *kwnames[] = {
30321 (char *) "self", NULL
30322 };
30323
30324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30326 if (SWIG_arg_fail(1)) SWIG_fail;
30327 result = (int) ((arg1)->w);
30328
30329 {
30330 resultobj = SWIG_From_int((int)(result));
30331 }
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30339 PyObject *resultobj;
30340 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30341 int arg2 ;
30342 PyObject * obj0 = 0 ;
30343 PyObject * obj1 = 0 ;
30344 char *kwnames[] = {
30345 (char *) "self",(char *) "h", NULL
30346 };
30347
30348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30350 if (SWIG_arg_fail(1)) SWIG_fail;
30351 {
30352 arg2 = (int)(SWIG_As_int(obj1));
30353 if (SWIG_arg_fail(2)) SWIG_fail;
30354 }
30355 if (arg1) (arg1)->h = arg2;
30356
30357 Py_INCREF(Py_None); resultobj = Py_None;
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30365 PyObject *resultobj;
30366 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30367 int result;
30368 PyObject * obj0 = 0 ;
30369 char *kwnames[] = {
30370 (char *) "self", NULL
30371 };
30372
30373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30375 if (SWIG_arg_fail(1)) SWIG_fail;
30376 result = (int) ((arg1)->h);
30377
30378 {
30379 resultobj = SWIG_From_int((int)(result));
30380 }
30381 return resultobj;
30382 fail:
30383 return NULL;
30384 }
30385
30386
30387 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30388 PyObject *resultobj;
30389 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30390 int arg2 ;
30391 PyObject * obj0 = 0 ;
30392 PyObject * obj1 = 0 ;
30393 char *kwnames[] = {
30394 (char *) "self",(char *) "bpp", NULL
30395 };
30396
30397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30399 if (SWIG_arg_fail(1)) SWIG_fail;
30400 {
30401 arg2 = (int)(SWIG_As_int(obj1));
30402 if (SWIG_arg_fail(2)) SWIG_fail;
30403 }
30404 if (arg1) (arg1)->bpp = arg2;
30405
30406 Py_INCREF(Py_None); resultobj = Py_None;
30407 return resultobj;
30408 fail:
30409 return NULL;
30410 }
30411
30412
30413 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30414 PyObject *resultobj;
30415 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30416 int result;
30417 PyObject * obj0 = 0 ;
30418 char *kwnames[] = {
30419 (char *) "self", NULL
30420 };
30421
30422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30424 if (SWIG_arg_fail(1)) SWIG_fail;
30425 result = (int) ((arg1)->bpp);
30426
30427 {
30428 resultobj = SWIG_From_int((int)(result));
30429 }
30430 return resultobj;
30431 fail:
30432 return NULL;
30433 }
30434
30435
30436 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30437 PyObject *resultobj;
30438 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30439 int arg2 ;
30440 PyObject * obj0 = 0 ;
30441 PyObject * obj1 = 0 ;
30442 char *kwnames[] = {
30443 (char *) "self",(char *) "refresh", NULL
30444 };
30445
30446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30448 if (SWIG_arg_fail(1)) SWIG_fail;
30449 {
30450 arg2 = (int)(SWIG_As_int(obj1));
30451 if (SWIG_arg_fail(2)) SWIG_fail;
30452 }
30453 if (arg1) (arg1)->refresh = arg2;
30454
30455 Py_INCREF(Py_None); resultobj = Py_None;
30456 return resultobj;
30457 fail:
30458 return NULL;
30459 }
30460
30461
30462 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30463 PyObject *resultobj;
30464 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30465 int result;
30466 PyObject * obj0 = 0 ;
30467 char *kwnames[] = {
30468 (char *) "self", NULL
30469 };
30470
30471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30473 if (SWIG_arg_fail(1)) SWIG_fail;
30474 result = (int) ((arg1)->refresh);
30475
30476 {
30477 resultobj = SWIG_From_int((int)(result));
30478 }
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30486 PyObject *obj;
30487 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30488 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30489 Py_INCREF(obj);
30490 return Py_BuildValue((char *)"");
30491 }
30492 static int _wrap_DefaultVideoMode_set(PyObject *) {
30493 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30494 return 1;
30495 }
30496
30497
30498 static PyObject *_wrap_DefaultVideoMode_get(void) {
30499 PyObject *pyobj;
30500
30501 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30502 return pyobj;
30503 }
30504
30505
30506 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30507 PyObject *resultobj;
30508 size_t arg1 = (size_t) 0 ;
30509 wxDisplay *result;
30510 PyObject * obj0 = 0 ;
30511 char *kwnames[] = {
30512 (char *) "index", NULL
30513 };
30514
30515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30516 if (obj0) {
30517 {
30518 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30519 if (SWIG_arg_fail(1)) SWIG_fail;
30520 }
30521 }
30522 {
30523 PyThreadState* __tstate = wxPyBeginAllowThreads();
30524 result = (wxDisplay *)new wxDisplay(arg1);
30525
30526 wxPyEndAllowThreads(__tstate);
30527 if (PyErr_Occurred()) SWIG_fail;
30528 }
30529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30537 PyObject *resultobj;
30538 wxDisplay *arg1 = (wxDisplay *) 0 ;
30539 PyObject * obj0 = 0 ;
30540 char *kwnames[] = {
30541 (char *) "self", NULL
30542 };
30543
30544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30546 if (SWIG_arg_fail(1)) SWIG_fail;
30547 {
30548 PyThreadState* __tstate = wxPyBeginAllowThreads();
30549 delete arg1;
30550
30551 wxPyEndAllowThreads(__tstate);
30552 if (PyErr_Occurred()) SWIG_fail;
30553 }
30554 Py_INCREF(Py_None); resultobj = Py_None;
30555 return resultobj;
30556 fail:
30557 return NULL;
30558 }
30559
30560
30561 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30562 PyObject *resultobj;
30563 size_t result;
30564 char *kwnames[] = {
30565 NULL
30566 };
30567
30568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 result = (size_t)wxDisplay::GetCount();
30572
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 {
30577 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30586 PyObject *resultobj;
30587 wxPoint *arg1 = 0 ;
30588 int result;
30589 wxPoint temp1 ;
30590 PyObject * obj0 = 0 ;
30591 char *kwnames[] = {
30592 (char *) "pt", NULL
30593 };
30594
30595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30596 {
30597 arg1 = &temp1;
30598 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30599 }
30600 {
30601 PyThreadState* __tstate = wxPyBeginAllowThreads();
30602 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30603
30604 wxPyEndAllowThreads(__tstate);
30605 if (PyErr_Occurred()) SWIG_fail;
30606 }
30607 {
30608 resultobj = SWIG_From_int((int)(result));
30609 }
30610 return resultobj;
30611 fail:
30612 return NULL;
30613 }
30614
30615
30616 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30617 PyObject *resultobj;
30618 wxWindow *arg1 = (wxWindow *) 0 ;
30619 int result;
30620 PyObject * obj0 = 0 ;
30621 char *kwnames[] = {
30622 (char *) "window", NULL
30623 };
30624
30625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30627 if (SWIG_arg_fail(1)) SWIG_fail;
30628 {
30629 PyThreadState* __tstate = wxPyBeginAllowThreads();
30630 result = (int)Display_GetFromWindow(arg1);
30631
30632 wxPyEndAllowThreads(__tstate);
30633 if (PyErr_Occurred()) SWIG_fail;
30634 }
30635 {
30636 resultobj = SWIG_From_int((int)(result));
30637 }
30638 return resultobj;
30639 fail:
30640 return NULL;
30641 }
30642
30643
30644 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30645 PyObject *resultobj;
30646 wxDisplay *arg1 = (wxDisplay *) 0 ;
30647 bool result;
30648 PyObject * obj0 = 0 ;
30649 char *kwnames[] = {
30650 (char *) "self", NULL
30651 };
30652
30653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30655 if (SWIG_arg_fail(1)) SWIG_fail;
30656 {
30657 PyThreadState* __tstate = wxPyBeginAllowThreads();
30658 result = (bool)((wxDisplay const *)arg1)->IsOk();
30659
30660 wxPyEndAllowThreads(__tstate);
30661 if (PyErr_Occurred()) SWIG_fail;
30662 }
30663 {
30664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30665 }
30666 return resultobj;
30667 fail:
30668 return NULL;
30669 }
30670
30671
30672 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30673 PyObject *resultobj;
30674 wxDisplay *arg1 = (wxDisplay *) 0 ;
30675 wxRect result;
30676 PyObject * obj0 = 0 ;
30677 char *kwnames[] = {
30678 (char *) "self", NULL
30679 };
30680
30681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30683 if (SWIG_arg_fail(1)) SWIG_fail;
30684 {
30685 PyThreadState* __tstate = wxPyBeginAllowThreads();
30686 result = ((wxDisplay const *)arg1)->GetGeometry();
30687
30688 wxPyEndAllowThreads(__tstate);
30689 if (PyErr_Occurred()) SWIG_fail;
30690 }
30691 {
30692 wxRect * resultptr;
30693 resultptr = new wxRect((wxRect &)(result));
30694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30695 }
30696 return resultobj;
30697 fail:
30698 return NULL;
30699 }
30700
30701
30702 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30703 PyObject *resultobj;
30704 wxDisplay *arg1 = (wxDisplay *) 0 ;
30705 wxString result;
30706 PyObject * obj0 = 0 ;
30707 char *kwnames[] = {
30708 (char *) "self", NULL
30709 };
30710
30711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30713 if (SWIG_arg_fail(1)) SWIG_fail;
30714 {
30715 PyThreadState* __tstate = wxPyBeginAllowThreads();
30716 result = ((wxDisplay const *)arg1)->GetName();
30717
30718 wxPyEndAllowThreads(__tstate);
30719 if (PyErr_Occurred()) SWIG_fail;
30720 }
30721 {
30722 #if wxUSE_UNICODE
30723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30724 #else
30725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30726 #endif
30727 }
30728 return resultobj;
30729 fail:
30730 return NULL;
30731 }
30732
30733
30734 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30735 PyObject *resultobj;
30736 wxDisplay *arg1 = (wxDisplay *) 0 ;
30737 bool result;
30738 PyObject * obj0 = 0 ;
30739 char *kwnames[] = {
30740 (char *) "self", NULL
30741 };
30742
30743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30745 if (SWIG_arg_fail(1)) SWIG_fail;
30746 {
30747 PyThreadState* __tstate = wxPyBeginAllowThreads();
30748 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30749
30750 wxPyEndAllowThreads(__tstate);
30751 if (PyErr_Occurred()) SWIG_fail;
30752 }
30753 {
30754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30755 }
30756 return resultobj;
30757 fail:
30758 return NULL;
30759 }
30760
30761
30762 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30763 PyObject *resultobj;
30764 wxDisplay *arg1 = (wxDisplay *) 0 ;
30765 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30766 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30767 PyObject *result;
30768 PyObject * obj0 = 0 ;
30769 PyObject * obj1 = 0 ;
30770 char *kwnames[] = {
30771 (char *) "self",(char *) "mode", NULL
30772 };
30773
30774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30776 if (SWIG_arg_fail(1)) SWIG_fail;
30777 if (obj1) {
30778 {
30779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30780 if (SWIG_arg_fail(2)) SWIG_fail;
30781 if (arg2 == NULL) {
30782 SWIG_null_ref("wxVideoMode");
30783 }
30784 if (SWIG_arg_fail(2)) SWIG_fail;
30785 }
30786 }
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30790
30791 wxPyEndAllowThreads(__tstate);
30792 if (PyErr_Occurred()) SWIG_fail;
30793 }
30794 resultobj = result;
30795 return resultobj;
30796 fail:
30797 return NULL;
30798 }
30799
30800
30801 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30802 PyObject *resultobj;
30803 wxDisplay *arg1 = (wxDisplay *) 0 ;
30804 wxVideoMode result;
30805 PyObject * obj0 = 0 ;
30806 char *kwnames[] = {
30807 (char *) "self", NULL
30808 };
30809
30810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30812 if (SWIG_arg_fail(1)) SWIG_fail;
30813 {
30814 PyThreadState* __tstate = wxPyBeginAllowThreads();
30815 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30816
30817 wxPyEndAllowThreads(__tstate);
30818 if (PyErr_Occurred()) SWIG_fail;
30819 }
30820 {
30821 wxVideoMode * resultptr;
30822 resultptr = new wxVideoMode((wxVideoMode &)(result));
30823 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30824 }
30825 return resultobj;
30826 fail:
30827 return NULL;
30828 }
30829
30830
30831 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30832 PyObject *resultobj;
30833 wxDisplay *arg1 = (wxDisplay *) 0 ;
30834 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30835 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30836 bool result;
30837 PyObject * obj0 = 0 ;
30838 PyObject * obj1 = 0 ;
30839 char *kwnames[] = {
30840 (char *) "self",(char *) "mode", NULL
30841 };
30842
30843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30845 if (SWIG_arg_fail(1)) SWIG_fail;
30846 if (obj1) {
30847 {
30848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30849 if (SWIG_arg_fail(2)) SWIG_fail;
30850 if (arg2 == NULL) {
30851 SWIG_null_ref("wxVideoMode");
30852 }
30853 if (SWIG_arg_fail(2)) SWIG_fail;
30854 }
30855 }
30856 {
30857 PyThreadState* __tstate = wxPyBeginAllowThreads();
30858 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30859
30860 wxPyEndAllowThreads(__tstate);
30861 if (PyErr_Occurred()) SWIG_fail;
30862 }
30863 {
30864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30865 }
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj;
30874 wxDisplay *arg1 = (wxDisplay *) 0 ;
30875 PyObject * obj0 = 0 ;
30876 char *kwnames[] = {
30877 (char *) "self", NULL
30878 };
30879
30880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30882 if (SWIG_arg_fail(1)) SWIG_fail;
30883 {
30884 PyThreadState* __tstate = wxPyBeginAllowThreads();
30885 (arg1)->ResetMode();
30886
30887 wxPyEndAllowThreads(__tstate);
30888 if (PyErr_Occurred()) SWIG_fail;
30889 }
30890 Py_INCREF(Py_None); resultobj = Py_None;
30891 return resultobj;
30892 fail:
30893 return NULL;
30894 }
30895
30896
30897 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30898 PyObject *obj;
30899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30900 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30901 Py_INCREF(obj);
30902 return Py_BuildValue((char *)"");
30903 }
30904 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30905 PyObject *resultobj;
30906 wxStandardPaths *result;
30907 char *kwnames[] = {
30908 NULL
30909 };
30910
30911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30912 {
30913 PyThreadState* __tstate = wxPyBeginAllowThreads();
30914 result = (wxStandardPaths *)StandardPaths_Get();
30915
30916 wxPyEndAllowThreads(__tstate);
30917 if (PyErr_Occurred()) SWIG_fail;
30918 }
30919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30920 return resultobj;
30921 fail:
30922 return NULL;
30923 }
30924
30925
30926 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30927 PyObject *resultobj;
30928 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30929 wxString result;
30930 PyObject * obj0 = 0 ;
30931 char *kwnames[] = {
30932 (char *) "self", NULL
30933 };
30934
30935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30937 if (SWIG_arg_fail(1)) SWIG_fail;
30938 {
30939 PyThreadState* __tstate = wxPyBeginAllowThreads();
30940 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30941
30942 wxPyEndAllowThreads(__tstate);
30943 if (PyErr_Occurred()) SWIG_fail;
30944 }
30945 {
30946 #if wxUSE_UNICODE
30947 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30948 #else
30949 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30950 #endif
30951 }
30952 return resultobj;
30953 fail:
30954 return NULL;
30955 }
30956
30957
30958 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30959 PyObject *resultobj;
30960 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30961 wxString result;
30962 PyObject * obj0 = 0 ;
30963 char *kwnames[] = {
30964 (char *) "self", NULL
30965 };
30966
30967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30969 if (SWIG_arg_fail(1)) SWIG_fail;
30970 {
30971 PyThreadState* __tstate = wxPyBeginAllowThreads();
30972 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30973
30974 wxPyEndAllowThreads(__tstate);
30975 if (PyErr_Occurred()) SWIG_fail;
30976 }
30977 {
30978 #if wxUSE_UNICODE
30979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30980 #else
30981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30982 #endif
30983 }
30984 return resultobj;
30985 fail:
30986 return NULL;
30987 }
30988
30989
30990 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30991 PyObject *resultobj;
30992 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30993 wxString result;
30994 PyObject * obj0 = 0 ;
30995 char *kwnames[] = {
30996 (char *) "self", NULL
30997 };
30998
30999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31001 if (SWIG_arg_fail(1)) SWIG_fail;
31002 {
31003 PyThreadState* __tstate = wxPyBeginAllowThreads();
31004 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31005
31006 wxPyEndAllowThreads(__tstate);
31007 if (PyErr_Occurred()) SWIG_fail;
31008 }
31009 {
31010 #if wxUSE_UNICODE
31011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31012 #else
31013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31014 #endif
31015 }
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31023 PyObject *resultobj;
31024 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31025 wxString result;
31026 PyObject * obj0 = 0 ;
31027 char *kwnames[] = {
31028 (char *) "self", NULL
31029 };
31030
31031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31033 if (SWIG_arg_fail(1)) SWIG_fail;
31034 {
31035 PyThreadState* __tstate = wxPyBeginAllowThreads();
31036 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31037
31038 wxPyEndAllowThreads(__tstate);
31039 if (PyErr_Occurred()) SWIG_fail;
31040 }
31041 {
31042 #if wxUSE_UNICODE
31043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31044 #else
31045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31046 #endif
31047 }
31048 return resultobj;
31049 fail:
31050 return NULL;
31051 }
31052
31053
31054 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31055 PyObject *resultobj;
31056 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31057 wxString result;
31058 PyObject * obj0 = 0 ;
31059 char *kwnames[] = {
31060 (char *) "self", NULL
31061 };
31062
31063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31065 if (SWIG_arg_fail(1)) SWIG_fail;
31066 {
31067 PyThreadState* __tstate = wxPyBeginAllowThreads();
31068 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31069
31070 wxPyEndAllowThreads(__tstate);
31071 if (PyErr_Occurred()) SWIG_fail;
31072 }
31073 {
31074 #if wxUSE_UNICODE
31075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31076 #else
31077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31078 #endif
31079 }
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj;
31088 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31089 wxString result;
31090 PyObject * obj0 = 0 ;
31091 char *kwnames[] = {
31092 (char *) "self", NULL
31093 };
31094
31095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31097 if (SWIG_arg_fail(1)) SWIG_fail;
31098 {
31099 PyThreadState* __tstate = wxPyBeginAllowThreads();
31100 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31101
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 {
31106 #if wxUSE_UNICODE
31107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31108 #else
31109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31110 #endif
31111 }
31112 return resultobj;
31113 fail:
31114 return NULL;
31115 }
31116
31117
31118 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31119 PyObject *resultobj;
31120 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31121 wxString result;
31122 PyObject * obj0 = 0 ;
31123 char *kwnames[] = {
31124 (char *) "self", NULL
31125 };
31126
31127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31129 if (SWIG_arg_fail(1)) SWIG_fail;
31130 {
31131 PyThreadState* __tstate = wxPyBeginAllowThreads();
31132 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31133
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 {
31138 #if wxUSE_UNICODE
31139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31140 #else
31141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31142 #endif
31143 }
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31151 PyObject *resultobj;
31152 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31153 wxString *arg2 = 0 ;
31154 bool temp2 = false ;
31155 PyObject * obj0 = 0 ;
31156 PyObject * obj1 = 0 ;
31157 char *kwnames[] = {
31158 (char *) "self",(char *) "prefix", NULL
31159 };
31160
31161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31163 if (SWIG_arg_fail(1)) SWIG_fail;
31164 {
31165 arg2 = wxString_in_helper(obj1);
31166 if (arg2 == NULL) SWIG_fail;
31167 temp2 = true;
31168 }
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31172
31173 wxPyEndAllowThreads(__tstate);
31174 if (PyErr_Occurred()) SWIG_fail;
31175 }
31176 Py_INCREF(Py_None); resultobj = Py_None;
31177 {
31178 if (temp2)
31179 delete arg2;
31180 }
31181 return resultobj;
31182 fail:
31183 {
31184 if (temp2)
31185 delete arg2;
31186 }
31187 return NULL;
31188 }
31189
31190
31191 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31192 PyObject *resultobj;
31193 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31194 wxString result;
31195 PyObject * obj0 = 0 ;
31196 char *kwnames[] = {
31197 (char *) "self", NULL
31198 };
31199
31200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31202 if (SWIG_arg_fail(1)) SWIG_fail;
31203 {
31204 PyThreadState* __tstate = wxPyBeginAllowThreads();
31205 result = wxStandardPaths_GetInstallPrefix(arg1);
31206
31207 wxPyEndAllowThreads(__tstate);
31208 if (PyErr_Occurred()) SWIG_fail;
31209 }
31210 {
31211 #if wxUSE_UNICODE
31212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31213 #else
31214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31215 #endif
31216 }
31217 return resultobj;
31218 fail:
31219 return NULL;
31220 }
31221
31222
31223 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31224 PyObject *obj;
31225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31226 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31227 Py_INCREF(obj);
31228 return Py_BuildValue((char *)"");
31229 }
31230 static PyMethodDef SwigMethods[] = {
31231 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31238 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31245 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31309 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31317 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31333 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31338 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31341 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31344 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31350 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31364 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31370 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31376 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31379 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31393 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31396 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31397 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31400 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31427 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31429 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31431 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31433 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31440 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31446 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31460 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31464 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31467 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31484 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31492 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31539 { (char *)"JoystickEvent_m_pos_set", (PyCFunction) _wrap_JoystickEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"JoystickEvent_m_pos_get", (PyCFunction) _wrap_JoystickEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"JoystickEvent_m_zPosition_set", (PyCFunction) _wrap_JoystickEvent_m_zPosition_set, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"JoystickEvent_m_zPosition_get", (PyCFunction) _wrap_JoystickEvent_m_zPosition_get, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"JoystickEvent_m_buttonChange_set", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_set, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"JoystickEvent_m_buttonChange_get", (PyCFunction) _wrap_JoystickEvent_m_buttonChange_get, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"JoystickEvent_m_buttonState_set", (PyCFunction) _wrap_JoystickEvent_m_buttonState_set, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"JoystickEvent_m_buttonState_get", (PyCFunction) _wrap_JoystickEvent_m_buttonState_get, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"JoystickEvent_m_joyStick_set", (PyCFunction) _wrap_JoystickEvent_m_joyStick_set, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"JoystickEvent_m_joyStick_get", (PyCFunction) _wrap_JoystickEvent_m_joyStick_get, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31567 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31577 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31593 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31609 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31623 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31632 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31675 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31678 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31681 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31685 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31778 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31779 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31780 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31781 { (char *)"DateTime___lt__", _wrap_DateTime___lt__, METH_VARARGS, NULL},
31782 { (char *)"DateTime___le__", _wrap_DateTime___le__, METH_VARARGS, NULL},
31783 { (char *)"DateTime___gt__", _wrap_DateTime___gt__, METH_VARARGS, NULL},
31784 { (char *)"DateTime___ge__", _wrap_DateTime___ge__, METH_VARARGS, NULL},
31785 { (char *)"DateTime___eq__", _wrap_DateTime___eq__, METH_VARARGS, NULL},
31786 { (char *)"DateTime___ne__", _wrap_DateTime___ne__, METH_VARARGS, NULL},
31787 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31798 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31843 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31877 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31885 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31886 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31891 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31900 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31907 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31910 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31913 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31918 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31921 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31925 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31928 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31932 { (char *)"new_CustomDataObject", (PyCFunction) _wrap_new_CustomDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31937 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31941 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31945 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31955 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31966 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31974 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31982 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31996 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32000 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32018 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32032 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32043 { NULL, NULL, 0, NULL }
32044 };
32045
32046
32047 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32048
32049 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32050 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32051 }
32052 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32053 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32054 }
32055 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32056 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32057 }
32058 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32059 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32060 }
32061 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32062 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32063 }
32064 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32065 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32066 }
32067 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32068 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32069 }
32070 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32071 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32072 }
32073 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32074 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32075 }
32076 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32077 return (void *)((wxEvent *) ((wxPyEvent *) x));
32078 }
32079 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32080 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32081 }
32082 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32083 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32084 }
32085 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32086 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32087 }
32088 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32089 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32090 }
32091 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32092 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32093 }
32094 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32095 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32096 }
32097 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32098 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32099 }
32100 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32101 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32102 }
32103 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32104 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32105 }
32106 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32107 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32108 }
32109 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32110 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32111 }
32112 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32113 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32114 }
32115 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32116 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32117 }
32118 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32119 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32120 }
32121 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32122 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32123 }
32124 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32125 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32126 }
32127 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32128 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32129 }
32130 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32131 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32132 }
32133 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32134 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32135 }
32136 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32137 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32138 }
32139 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32140 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32141 }
32142 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32143 return (void *)((wxEvent *) ((wxShowEvent *) x));
32144 }
32145 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32146 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32147 }
32148 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32149 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32150 }
32151 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32152 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32153 }
32154 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32155 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32156 }
32157 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32158 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32159 }
32160 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32161 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32162 }
32163 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32164 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32165 }
32166 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32167 return (void *)((wxConfigBase *) ((wxConfig *) x));
32168 }
32169 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32170 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32171 }
32172 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32173 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32174 }
32175 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32176 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32177 }
32178 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32179 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32180 }
32181 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32182 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32183 }
32184 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32185 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32186 }
32187 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32188 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32189 }
32190 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32191 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32192 }
32193 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32194 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32195 }
32196 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32197 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32198 }
32199 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32200 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32201 }
32202 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32203 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32204 }
32205 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32206 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32207 }
32208 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32209 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32210 }
32211 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32212 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32213 }
32214 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32215 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32216 }
32217 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32218 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32219 }
32220 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32221 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32222 }
32223 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32224 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32225 }
32226 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32227 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32228 }
32229 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32230 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32231 }
32232 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32233 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32234 }
32235 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32236 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32237 }
32238 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32239 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32240 }
32241 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32242 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32243 }
32244 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32245 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32246 }
32247 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32248 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32249 }
32250 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32251 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32252 }
32253 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32254 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32255 }
32256 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32257 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32258 }
32259 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32260 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32261 }
32262 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32263 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32264 }
32265 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32266 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32267 }
32268 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32269 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32270 }
32271 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32272 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32273 }
32274 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32275 return (void *)((wxObject *) ((wxSizerItem *) x));
32276 }
32277 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32278 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32279 }
32280 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32281 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32282 }
32283 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32284 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32285 }
32286 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32287 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32288 }
32289 static void *_p_wxSizerTo_p_wxObject(void *x) {
32290 return (void *)((wxObject *) ((wxSizer *) x));
32291 }
32292 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32293 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32294 }
32295 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32296 return (void *)((wxObject *) ((wxFileHistory *) x));
32297 }
32298 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32299 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32300 }
32301 static void *_p_wxEventTo_p_wxObject(void *x) {
32302 return (void *)((wxObject *) ((wxEvent *) x));
32303 }
32304 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32305 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32306 }
32307 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32308 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32309 }
32310 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32311 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32312 }
32313 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32314 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32315 }
32316 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32317 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32318 }
32319 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32320 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32321 }
32322 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32323 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32324 }
32325 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32326 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32327 }
32328 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32329 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32330 }
32331 static void *_p_wxControlTo_p_wxObject(void *x) {
32332 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32333 }
32334 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32335 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32336 }
32337 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32338 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32339 }
32340 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32341 return (void *)((wxObject *) ((wxFSFile *) x));
32342 }
32343 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32344 return (void *)((wxObject *) ((wxClipboard *) x));
32345 }
32346 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32347 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32348 }
32349 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32350 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32351 }
32352 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32353 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32354 }
32355 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32356 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32357 }
32358 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32359 return (void *)((wxObject *) ((wxToolTip *) x));
32360 }
32361 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32362 return (void *)((wxObject *) ((wxMenuItem *) x));
32363 }
32364 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32365 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32366 }
32367 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32368 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32369 }
32370 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32371 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32372 }
32373 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32374 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32375 }
32376 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32377 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32378 }
32379 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32380 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32381 }
32382 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32383 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32384 }
32385 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32386 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32387 }
32388 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32389 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32390 }
32391 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32392 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32393 }
32394 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32395 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32396 }
32397 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32398 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32399 }
32400 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32401 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32402 }
32403 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32404 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32405 }
32406 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32407 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32408 }
32409 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32410 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32411 }
32412 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32413 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32414 }
32415 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32416 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32417 }
32418 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32419 return (void *)((wxObject *) ((wxImageHandler *) x));
32420 }
32421 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32422 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32423 }
32424 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32425 return (void *)((wxObject *) ((wxEvtHandler *) x));
32426 }
32427 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32428 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32429 }
32430 static void *_p_wxImageTo_p_wxObject(void *x) {
32431 return (void *)((wxObject *) ((wxImage *) x));
32432 }
32433 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32434 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32435 }
32436 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32437 return (void *)((wxObject *) ((wxSystemOptions *) x));
32438 }
32439 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32440 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32441 }
32442 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32443 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32444 }
32445 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32446 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32447 }
32448 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32449 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32450 }
32451 static void *_p_wxWindowTo_p_wxObject(void *x) {
32452 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32453 }
32454 static void *_p_wxMenuTo_p_wxObject(void *x) {
32455 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32456 }
32457 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32458 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32459 }
32460 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32461 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32462 }
32463 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32464 return (void *)((wxObject *) ((wxFileSystem *) x));
32465 }
32466 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32467 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32468 }
32469 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32470 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32471 }
32472 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32473 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32474 }
32475 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32476 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32477 }
32478 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32479 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32480 }
32481 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32482 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32483 }
32484 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32485 return (void *)((wxObject *) ((wxBusyInfo *) x));
32486 }
32487 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32488 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32489 }
32490 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32491 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32492 }
32493 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32494 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32495 }
32496 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32497 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32498 }
32499 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32500 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32501 }
32502 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32503 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32504 }
32505 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32506 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32507 }
32508 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32509 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32510 }
32511 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32512 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32513 }
32514 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32515 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32516 }
32517 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32518 return (void *)((wxLog *) ((wxLogStderr *) x));
32519 }
32520 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32521 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32522 }
32523 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32524 return (void *)((wxLog *) ((wxLogWindow *) x));
32525 }
32526 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32527 return (void *)((wxLog *) ((wxLogChain *) x));
32528 }
32529 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32530 return (void *)((wxLog *) ((wxLogGui *) x));
32531 }
32532 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32533 return (void *)((wxLog *) ((wxPyLog *) x));
32534 }
32535 static void *_p_wxControlTo_p_wxWindow(void *x) {
32536 return (void *)((wxWindow *) ((wxControl *) x));
32537 }
32538 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32539 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32540 }
32541 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32542 return (void *)((wxWindow *) ((wxMenuBar *) x));
32543 }
32544 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32545 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32546 }
32547 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32548 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32549 }
32550 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}};
32551 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}};
32552 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32553 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}};
32554 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}};
32555 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}};
32556 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32557 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}};
32558 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}};
32559 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}};
32560 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}};
32561 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}};
32562 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}};
32563 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}};
32564 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}};
32565 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}};
32566 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}};
32567 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}};
32568 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}};
32569 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}};
32570 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}};
32571 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}};
32572 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}};
32573 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}};
32574 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}};
32575 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}};
32576 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}};
32577 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}};
32578 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}};
32579 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}};
32580 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}};
32581 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}};
32582 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}};
32583 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}};
32584 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}};
32585 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}};
32586 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}};
32587 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}};
32588 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}};
32589 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}};
32590 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}};
32591 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}};
32592 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}};
32593 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}};
32594 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}};
32595 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}};
32596 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}};
32597 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}};
32598 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}};
32599 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}};
32600 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}};
32601 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}};
32602 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}};
32603 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}};
32604 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}};
32605 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}};
32606 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}};
32607 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}};
32608 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}};
32609 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}};
32610 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}};
32611 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}};
32612 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}};
32613 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}};
32614 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}};
32615 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}};
32616 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}};
32617 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}};
32618 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}};
32619 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}};
32620 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}};
32621 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_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}};
32622 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}};
32623 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}};
32624 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}};
32625 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}};
32626 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}};
32627 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}};
32628 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}};
32629 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}};
32630 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}};
32631 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}};
32632 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}};
32633 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}};
32634 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}};
32635 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}};
32636 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}};
32637 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}};
32638 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}};
32639 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}};
32640 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}};
32641 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}};
32642 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}};
32643 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}};
32644 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}};
32645 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}};
32646 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}};
32647
32648 static swig_type_info *swig_types_initial[] = {
32649 _swigt__p_wxLogChain,
32650 _swigt__p_wxMutexGuiLocker,
32651 _swigt__p_wxMetafile,
32652 _swigt__p_wxFileHistory,
32653 _swigt__p_wxLog,
32654 _swigt__p_wxMenu,
32655 _swigt__p_wxEvent,
32656 _swigt__p_wxDateTime__TimeZone,
32657 _swigt__p_wxConfigBase,
32658 _swigt__p_wxDisplay,
32659 _swigt__p_wxFileType,
32660 _swigt__p_wxLogGui,
32661 _swigt__p_wxFont,
32662 _swigt__p_wxDataFormat,
32663 _swigt__p_wxTimerEvent,
32664 _swigt__p_wxCaret,
32665 _swigt__ptrdiff_t,
32666 _swigt__std__ptrdiff_t,
32667 _swigt__p_int,
32668 _swigt__p_wxSize,
32669 _swigt__p_wxClipboard,
32670 _swigt__p_wxStopWatch,
32671 _swigt__p_wxDC,
32672 _swigt__p_wxClipboardLocker,
32673 _swigt__p_wxIcon,
32674 _swigt__p_wxLogStderr,
32675 _swigt__p_wxLogTextCtrl,
32676 _swigt__p_wxTextCtrl,
32677 _swigt__p_wxBusyCursor,
32678 _swigt__p_wxBitmapDataObject,
32679 _swigt__p_wxTextDataObject,
32680 _swigt__p_wxDataObject,
32681 _swigt__p_wxPyTextDataObject,
32682 _swigt__p_wxPyBitmapDataObject,
32683 _swigt__p_wxFileDataObject,
32684 _swigt__p_wxCustomDataObject,
32685 _swigt__p_wxURLDataObject,
32686 _swigt__p_wxMetafileDataObject,
32687 _swigt__p_wxSound,
32688 _swigt__p_wxTimerRunner,
32689 _swigt__p_wxLogWindow,
32690 _swigt__p_wxTimeSpan,
32691 _swigt__p_wxArrayString,
32692 _swigt__p_wxWindowDisabler,
32693 _swigt__p_form_ops_t,
32694 _swigt__p_wxToolTip,
32695 _swigt__p_wxDataObjectComposite,
32696 _swigt__p_wxSystemSettings,
32697 _swigt__p_wxFileConfig,
32698 _swigt__p_wxVideoMode,
32699 _swigt__p_wxDataObjectSimple,
32700 _swigt__p_wxPyDataObjectSimple,
32701 _swigt__p_wxDuplexMode,
32702 _swigt__p_wxEvtHandler,
32703 _swigt__p_wxRect,
32704 _swigt__p_char,
32705 _swigt__p_wxSingleInstanceChecker,
32706 _swigt__p_wxStandardPaths,
32707 _swigt__p_wxFileTypeInfo,
32708 _swigt__p_wxFrame,
32709 _swigt__p_wxTimer,
32710 _swigt__p_wxPaperSize,
32711 _swigt__p_wxMimeTypesManager,
32712 _swigt__p_wxPyArtProvider,
32713 _swigt__p_wxPyTipProvider,
32714 _swigt__p_wxTipProvider,
32715 _swigt__p_wxJoystick,
32716 _swigt__p_wxSystemOptions,
32717 _swigt__p_wxPoint,
32718 _swigt__p_wxJoystickEvent,
32719 _swigt__p_wxCursor,
32720 _swigt__p_wxObject,
32721 _swigt__p_wxOutputStream,
32722 _swigt__p_wxDateTime,
32723 _swigt__p_wxPyDropSource,
32724 _swigt__p_unsigned_long,
32725 _swigt__p_wxKillError,
32726 _swigt__p_wxWindow,
32727 _swigt__p_wxString,
32728 _swigt__p_wxPyProcess,
32729 _swigt__p_wxBitmap,
32730 _swigt__p_wxConfig,
32731 _swigt__unsigned_int,
32732 _swigt__p_unsigned_int,
32733 _swigt__p_unsigned_char,
32734 _swigt__p_wxChar,
32735 _swigt__p_wxBusyInfo,
32736 _swigt__p_wxPyDropTarget,
32737 _swigt__p_wxPyTextDropTarget,
32738 _swigt__p_wxPyFileDropTarget,
32739 _swigt__p_wxProcessEvent,
32740 _swigt__p_wxPyLog,
32741 _swigt__p_wxLogNull,
32742 _swigt__p_wxColour,
32743 _swigt__p_wxPyTimer,
32744 _swigt__p_wxConfigPathChanger,
32745 _swigt__p_wxDateSpan,
32746 0
32747 };
32748
32749
32750 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32751
32752 static swig_const_info swig_const_table[] = {
32753 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32754 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32755 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32756 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32757 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32758 {0, 0, 0, 0.0, 0, 0}};
32759
32760 #ifdef __cplusplus
32761 }
32762 #endif
32763
32764
32765 #ifdef __cplusplus
32766 extern "C" {
32767 #endif
32768
32769 /* Python-specific SWIG API */
32770 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32771 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32772 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32773
32774 /* -----------------------------------------------------------------------------
32775 * global variable support code.
32776 * ----------------------------------------------------------------------------- */
32777
32778 typedef struct swig_globalvar {
32779 char *name; /* Name of global variable */
32780 PyObject *(*get_attr)(); /* Return the current value */
32781 int (*set_attr)(PyObject *); /* Set the value */
32782 struct swig_globalvar *next;
32783 } swig_globalvar;
32784
32785 typedef struct swig_varlinkobject {
32786 PyObject_HEAD
32787 swig_globalvar *vars;
32788 } swig_varlinkobject;
32789
32790 static PyObject *
32791 swig_varlink_repr(swig_varlinkobject *v) {
32792 v = v;
32793 return PyString_FromString("<Swig global variables>");
32794 }
32795
32796 static int
32797 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32798 swig_globalvar *var;
32799 flags = flags;
32800 fprintf(fp,"Swig global variables { ");
32801 for (var = v->vars; var; var=var->next) {
32802 fprintf(fp,"%s", var->name);
32803 if (var->next) fprintf(fp,", ");
32804 }
32805 fprintf(fp," }\n");
32806 return 0;
32807 }
32808
32809 static PyObject *
32810 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32811 swig_globalvar *var = v->vars;
32812 while (var) {
32813 if (strcmp(var->name,n) == 0) {
32814 return (*var->get_attr)();
32815 }
32816 var = var->next;
32817 }
32818 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32819 return NULL;
32820 }
32821
32822 static int
32823 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32824 swig_globalvar *var = v->vars;
32825 while (var) {
32826 if (strcmp(var->name,n) == 0) {
32827 return (*var->set_attr)(p);
32828 }
32829 var = var->next;
32830 }
32831 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32832 return 1;
32833 }
32834
32835 static PyTypeObject varlinktype = {
32836 PyObject_HEAD_INIT(0)
32837 0, /* Number of items in variable part (ob_size) */
32838 (char *)"swigvarlink", /* Type name (tp_name) */
32839 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32840 0, /* Itemsize (tp_itemsize) */
32841 0, /* Deallocator (tp_dealloc) */
32842 (printfunc) swig_varlink_print, /* Print (tp_print) */
32843 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32844 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32845 0, /* tp_compare */
32846 (reprfunc) swig_varlink_repr, /* tp_repr */
32847 0, /* tp_as_number */
32848 0, /* tp_as_sequence */
32849 0, /* tp_as_mapping */
32850 0, /* tp_hash */
32851 0, /* tp_call */
32852 0, /* tp_str */
32853 0, /* tp_getattro */
32854 0, /* tp_setattro */
32855 0, /* tp_as_buffer */
32856 0, /* tp_flags */
32857 0, /* tp_doc */
32858 #if PY_VERSION_HEX >= 0x02000000
32859 0, /* tp_traverse */
32860 0, /* tp_clear */
32861 #endif
32862 #if PY_VERSION_HEX >= 0x02010000
32863 0, /* tp_richcompare */
32864 0, /* tp_weaklistoffset */
32865 #endif
32866 #if PY_VERSION_HEX >= 0x02020000
32867 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32868 #endif
32869 #if PY_VERSION_HEX >= 0x02030000
32870 0, /* tp_del */
32871 #endif
32872 #ifdef COUNT_ALLOCS
32873 0,0,0,0 /* tp_alloc -> tp_next */
32874 #endif
32875 };
32876
32877 /* Create a variable linking object for use later */
32878 static PyObject *
32879 SWIG_Python_newvarlink(void) {
32880 swig_varlinkobject *result = 0;
32881 result = PyMem_NEW(swig_varlinkobject,1);
32882 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32883 result->ob_type = &varlinktype;
32884 result->vars = 0;
32885 result->ob_refcnt = 0;
32886 Py_XINCREF((PyObject *) result);
32887 return ((PyObject*) result);
32888 }
32889
32890 static void
32891 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32892 swig_varlinkobject *v;
32893 swig_globalvar *gv;
32894 v= (swig_varlinkobject *) p;
32895 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32896 gv->name = (char *) malloc(strlen(name)+1);
32897 strcpy(gv->name,name);
32898 gv->get_attr = get_attr;
32899 gv->set_attr = set_attr;
32900 gv->next = v->vars;
32901 v->vars = gv;
32902 }
32903
32904 /* -----------------------------------------------------------------------------
32905 * constants/methods manipulation
32906 * ----------------------------------------------------------------------------- */
32907
32908 /* Install Constants */
32909 static void
32910 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32911 PyObject *obj = 0;
32912 size_t i;
32913 for (i = 0; constants[i].type; i++) {
32914 switch(constants[i].type) {
32915 case SWIG_PY_INT:
32916 obj = PyInt_FromLong(constants[i].lvalue);
32917 break;
32918 case SWIG_PY_FLOAT:
32919 obj = PyFloat_FromDouble(constants[i].dvalue);
32920 break;
32921 case SWIG_PY_STRING:
32922 if (constants[i].pvalue) {
32923 obj = PyString_FromString((char *) constants[i].pvalue);
32924 } else {
32925 Py_INCREF(Py_None);
32926 obj = Py_None;
32927 }
32928 break;
32929 case SWIG_PY_POINTER:
32930 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32931 break;
32932 case SWIG_PY_BINARY:
32933 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32934 break;
32935 default:
32936 obj = 0;
32937 break;
32938 }
32939 if (obj) {
32940 PyDict_SetItemString(d,constants[i].name,obj);
32941 Py_DECREF(obj);
32942 }
32943 }
32944 }
32945
32946 /* -----------------------------------------------------------------------------*/
32947 /* Fix SwigMethods to carry the callback ptrs when needed */
32948 /* -----------------------------------------------------------------------------*/
32949
32950 static void
32951 SWIG_Python_FixMethods(PyMethodDef *methods,
32952 swig_const_info *const_table,
32953 swig_type_info **types,
32954 swig_type_info **types_initial) {
32955 size_t i;
32956 for (i = 0; methods[i].ml_name; ++i) {
32957 char *c = methods[i].ml_doc;
32958 if (c && (c = strstr(c, "swig_ptr: "))) {
32959 int j;
32960 swig_const_info *ci = 0;
32961 char *name = c + 10;
32962 for (j = 0; const_table[j].type; j++) {
32963 if (strncmp(const_table[j].name, name,
32964 strlen(const_table[j].name)) == 0) {
32965 ci = &(const_table[j]);
32966 break;
32967 }
32968 }
32969 if (ci) {
32970 size_t shift = (ci->ptype) - types;
32971 swig_type_info *ty = types_initial[shift];
32972 size_t ldoc = (c - methods[i].ml_doc);
32973 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32974 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32975 char *buff = ndoc;
32976 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32977 strncpy(buff, methods[i].ml_doc, ldoc);
32978 buff += ldoc;
32979 strncpy(buff, "swig_ptr: ", 10);
32980 buff += 10;
32981 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32982 methods[i].ml_doc = ndoc;
32983 }
32984 }
32985 }
32986 }
32987
32988 /* -----------------------------------------------------------------------------*
32989 * Initialize type list
32990 * -----------------------------------------------------------------------------*/
32991
32992 #if PY_MAJOR_VERSION < 2
32993 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32994 is copied out of Python/modsupport.c in python version 2.3.4 */
32995 static int
32996 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32997 {
32998 PyObject *dict;
32999 if (!PyModule_Check(m)) {
33000 PyErr_SetString(PyExc_TypeError,
33001 "PyModule_AddObject() needs module as first arg");
33002 return -1;
33003 }
33004 if (!o) {
33005 PyErr_SetString(PyExc_TypeError,
33006 "PyModule_AddObject() needs non-NULL value");
33007 return -1;
33008 }
33009
33010 dict = PyModule_GetDict(m);
33011 if (dict == NULL) {
33012 /* Internal error -- modules must have a dict! */
33013 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33014 PyModule_GetName(m));
33015 return -1;
33016 }
33017 if (PyDict_SetItemString(dict, name, o))
33018 return -1;
33019 Py_DECREF(o);
33020 return 0;
33021 }
33022 #endif
33023
33024 static swig_type_info **
33025 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33026 static PyMethodDef swig_empty_runtime_method_table[] = {
33027 {
33028 NULL, NULL, 0, NULL
33029 }
33030 };/* Sentinel */
33031
33032 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33033 swig_empty_runtime_method_table);
33034 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33035 if (pointer && module) {
33036 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33037 }
33038 return type_list_handle;
33039 }
33040
33041 static swig_type_info **
33042 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33043 swig_type_info **type_pointer;
33044
33045 /* first check if module already created */
33046 type_pointer = SWIG_Python_GetTypeListHandle();
33047 if (type_pointer) {
33048 return type_pointer;
33049 } else {
33050 /* create a new module and variable */
33051 return SWIG_Python_SetTypeListHandle(type_list_handle);
33052 }
33053 }
33054
33055 #ifdef __cplusplus
33056 }
33057 #endif
33058
33059 /* -----------------------------------------------------------------------------*
33060 * Partial Init method
33061 * -----------------------------------------------------------------------------*/
33062
33063 #ifdef SWIG_LINK_RUNTIME
33064 #ifdef __cplusplus
33065 extern "C"
33066 #endif
33067 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33068 #endif
33069
33070 #ifdef __cplusplus
33071 extern "C"
33072 #endif
33073 SWIGEXPORT(void) SWIG_init(void) {
33074 static PyObject *SWIG_globals = 0;
33075 static int typeinit = 0;
33076 PyObject *m, *d;
33077 int i;
33078 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33079
33080 /* Fix SwigMethods to carry the callback ptrs when needed */
33081 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33082
33083 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33084 d = PyModule_GetDict(m);
33085
33086 if (!typeinit) {
33087 #ifdef SWIG_LINK_RUNTIME
33088 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33089 #else
33090 # ifndef SWIG_STATIC_RUNTIME
33091 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33092 # endif
33093 #endif
33094 for (i = 0; swig_types_initial[i]; i++) {
33095 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33096 }
33097 typeinit = 1;
33098 }
33099 SWIG_InstallConstants(d,swig_const_table);
33100
33101 {
33102 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33103 }
33104 {
33105 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33106 }
33107 {
33108 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33109 }
33110 {
33111 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33112 }
33113 {
33114 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33115 }
33116 {
33117 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33118 }
33119 {
33120 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33121 }
33122 {
33123 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33124 }
33125 {
33126 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33127 }
33128 {
33129 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33130 }
33131 {
33132 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33133 }
33134 {
33135 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33136 }
33137 {
33138 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33139 }
33140 {
33141 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33142 }
33143 {
33144 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33145 }
33146 {
33147 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33148 }
33149 {
33150 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33151 }
33152 {
33153 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33154 }
33155 {
33156 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33157 }
33158 {
33159 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33160 }
33161 {
33162 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33163 }
33164 {
33165 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33166 }
33167 {
33168 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33169 }
33170 {
33171 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33172 }
33173 {
33174 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33175 }
33176 {
33177 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33178 }
33179 {
33180 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33181 }
33182 {
33183 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33184 }
33185 {
33186 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33187 }
33188 {
33189 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33190 }
33191 {
33192 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33193 }
33194 {
33195 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33196 }
33197 {
33198 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33199 }
33200 {
33201 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33202 }
33203 {
33204 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33205 }
33206 {
33207 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33208 }
33209 {
33210 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33256 }
33257 {
33258 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33259 }
33260 {
33261 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33262 }
33263 {
33264 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33265 }
33266 {
33267 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33268 }
33269 {
33270 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33277 }
33278 {
33279 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33286 }
33287 {
33288 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33289 }
33290 {
33291 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33292 }
33293 {
33294 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33295 }
33296 {
33297 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33298 }
33299 {
33300 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33301 }
33302 {
33303 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33304 }
33305 {
33306 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33307 }
33308 {
33309 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33310 }
33311 {
33312 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33313 }
33314 {
33315 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33316 }
33317 {
33318 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33319 }
33320 {
33321 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33322 }
33323 {
33324 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33325 }
33326 {
33327 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33328 }
33329 {
33330 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33331 }
33332 {
33333 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33334 }
33335 {
33336 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33355 }
33356 {
33357 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33358 }
33359 {
33360 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33373 }
33374 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33375 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33376 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33377 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33378 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33379 {
33380 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33381 }
33382 {
33383 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33384 }
33385 {
33386 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33387 }
33388 {
33389 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33390 }
33391 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33392
33393 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33394
33395 {
33396 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33427 }
33428 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33429 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33430 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33431 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33432 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33433 {
33434 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33435 }
33436 {
33437 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33438 }
33439 {
33440 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33441 }
33442 {
33443 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33444 }
33445 {
33446 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33447 }
33448 {
33449 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33450 }
33451 {
33452 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33453 }
33454 {
33455 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33492 }
33493 {
33494 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33495 }
33496 {
33497 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33498 }
33499 {
33500 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33525 }
33526 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33527 {
33528 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33541 }
33542
33543 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33544
33545 {
33546 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33565 }
33566 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33567 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33568 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33569 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33570 {
33571 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33593 }
33594 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33595 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33596 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33597 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33598 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33599 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33600 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33601 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33602 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33603 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33604 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33605 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33606 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33607 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33608 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33609 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33610 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33611 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33612 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33613 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33614 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33615 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33616 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33617 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33618 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33619 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33620 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33621 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33622 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33623 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33624 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33625 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33626 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33627 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33628 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33629 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33630 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33631 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33632 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33633 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33634 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33635 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33636 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33637 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33638 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33639
33640 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33641
33642 {
33643 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33668 }
33669 SWIG_addvarlink(SWIG_globals,(char*)"DateFormatStr",_wrap_DateFormatStr_get, _wrap_DateFormatStr_set);
33670 SWIG_addvarlink(SWIG_globals,(char*)"TimeSpanFormatStr",_wrap_TimeSpanFormatStr_get, _wrap_TimeSpanFormatStr_set);
33671 {
33672 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33859 }
33860 {
33861 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33862 }
33863 {
33864 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33865 }
33866 {
33867 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33868 }
33869 {
33870 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33895 }
33896 {
33897 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33898 }
33899 {
33900 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33901 }
33902 {
33903 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33937 }
33938 {
33939 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33946 }
33947 {
33948 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33949 }
33950 {
33951 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33994 }
33995 {
33996 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33997 }
33998 {
33999 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34132 }
34133 {
34134 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34135 }
34136 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34137 {
34138 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34196 }
34197 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34198 {
34199 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34233 }
34234
34235 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34236 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34237 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34238 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34239
34240 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34241 }
34242
wxWidgets (Impactor)