]> 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
reSWIGged
[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 static void wxCaret_Destroy(wxCaret *self){
1713 delete self;
1714 }
1715
1716 #include <wx/snglinst.h>
1717
1718
1719 #ifdef __WXMSW__
1720 #include <wx/msw/private.h>
1721 #include <wx/dynload.h>
1722 #endif
1723
1724
1725
1726 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1727 #if 0
1728 , int method
1729 #endif
1730 )
1731 {
1732 #ifdef __WXMSW__
1733 #if 0
1734 switch (method)
1735 {
1736 case 1:
1737 // This one only partially works. Appears to be an undocumented
1738 // "standard" convention that not all widgets adhear to. For
1739 // example, for some widgets backgrounds or non-client areas may
1740 // not be painted.
1741 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1742 break;
1743
1744 case 2:
1745 #endif
1746 // This one works much better, nearly all widgets and their
1747 // children are captured correctly[**]. Prior to the big
1748 // background erase changes that Vadim did in 2004-2005 this
1749 // method failed badly on XP with Themes activated, most native
1750 // widgets draw only partially, if at all. Without themes it
1751 // worked just like on Win2k. After those changes this method
1752 // works very well.
1753 //
1754 // ** For example the radio buttons in a wxRadioBox are not its
1755 // children by default, but you can capture it via the panel
1756 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1757 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1758 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1759 PRF_ERASEBKGND | PRF_OWNED );
1760 return true;
1761 #if 0
1762 break;
1763
1764 case 3:
1765 // This one is only defined in the latest SDK and is only
1766 // available on XP. MSDN says it is similar to sending WM_PRINT
1767 // so I expect that it will work similar to the above. Since it
1768 // is avaialble only on XP, it can't be compiled like this and
1769 // will have to be loaded dynamically.
1770 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1771
1772 // fall through
1773
1774 case 4:
1775 // Use PrintWindow if available, or fallback to WM_PRINT
1776 // otherwise. Unfortunately using PrintWindow is even worse than
1777 // WM_PRINT. For most native widgets nothing is drawn to the dc
1778 // at all, with or without Themes.
1779 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1780 static bool s_triedToLoad = false;
1781 static PrintWindow_t pfnPrintWindow = NULL;
1782 if ( !s_triedToLoad )
1783 {
1784
1785 s_triedToLoad = true;
1786 wxDynamicLibrary dllUser32(_T("user32.dll"));
1787 if ( dllUser32.IsLoaded() )
1788 {
1789 wxLogNull nolog; // Don't report errors here
1790 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1791 }
1792 }
1793 if (pfnPrintWindow)
1794 {
1795 //printf("Using PrintWindow\n");
1796 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1797 }
1798 else
1799 {
1800 //printf("Using WM_PRINT\n");
1801 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1802 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1803 PRF_ERASEBKGND | PRF_OWNED );
1804 }
1805 }
1806 #endif // 0
1807 #else
1808 return false;
1809 #endif // __WXMSW__
1810 }
1811
1812
1813
1814 #include <wx/tipdlg.h>
1815
1816
1817 class wxPyTipProvider : public wxTipProvider {
1818 public:
1819 wxPyTipProvider(size_t currentTip)
1820 : wxTipProvider(currentTip) {}
1821
1822 DEC_PYCALLBACK_STRING__pure(GetTip);
1823 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1824 PYPRIVATE;
1825 };
1826
1827 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1828 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1829
1830
1831 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1832
1833 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1834
1835 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1836 : wxTimer(owner, id)
1837 {
1838 if (owner == NULL) SetOwner(this);
1839 }
1840
1841
1842 void wxPyTimer::Notify() {
1843 bool found;
1844 bool blocked = wxPyBeginBlockThreads();
1845 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1846 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1847 wxPyEndBlockThreads(blocked);
1848 if (! found)
1849 wxTimer::Notify();
1850 }
1851 void wxPyTimer::base_Notify() {
1852 wxTimer::Notify();
1853 }
1854
1855
1856
1857 SWIGINTERN PyObject *
1858 SWIG_FromCharPtr(const char* cptr)
1859 {
1860 if (cptr) {
1861 size_t size = strlen(cptr);
1862 if (size > INT_MAX) {
1863 return SWIG_NewPointerObj((char*)(cptr),
1864 SWIG_TypeQuery("char *"), 0);
1865 } else {
1866 if (size != 0) {
1867 return PyString_FromStringAndSize(cptr, size);
1868 } else {
1869 return PyString_FromString(cptr);
1870 }
1871 }
1872 }
1873 Py_INCREF(Py_None);
1874 return Py_None;
1875 }
1876
1877
1878 SWIGINTERNSHORT int
1879 SWIG_CheckUnsignedLongInRange(unsigned long value,
1880 unsigned long max_value,
1881 const char *errmsg)
1882 {
1883 if (value > max_value) {
1884 if (errmsg) {
1885 PyErr_Format(PyExc_OverflowError,
1886 "value %lu is greater than '%s' minimum %lu",
1887 value, errmsg, max_value);
1888 }
1889 return 0;
1890 }
1891 return 1;
1892 }
1893
1894
1895 #if UINT_MAX != ULONG_MAX
1896 SWIGINTERN int
1897 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1898 {
1899 const char* errmsg = val ? "unsigned int" : (char*)0;
1900 unsigned long v;
1901 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1902 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1903 if (val) *val = (unsigned int)(v);
1904 return 1;
1905 }
1906 } else {
1907 PyErr_Clear();
1908 }
1909 if (val) {
1910 SWIG_type_error(errmsg, obj);
1911 }
1912 return 0;
1913 }
1914 #else
1915 SWIGINTERNSHORT unsigned int
1916 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1917 {
1918 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1919 }
1920 #endif
1921
1922
1923 SWIGINTERNSHORT unsigned int
1924 SWIG_As_unsigned_SS_int(PyObject* obj)
1925 {
1926 unsigned int v;
1927 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1928 /*
1929 this is needed to make valgrind/purify happier.
1930 */
1931 memset((void*)&v, 0, sizeof(unsigned int));
1932 }
1933 return v;
1934 }
1935
1936
1937 SWIGINTERNSHORT int
1938 SWIG_Check_unsigned_SS_int(PyObject* obj)
1939 {
1940 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1941 }
1942
1943 static wxString Log_TimeStamp(){
1944 wxString msg;
1945 wxLog::TimeStamp(&msg);
1946 return msg;
1947 }
1948 static void wxLog_Destroy(wxLog *self){ delete self; }
1949 // Make somce wrappers that double any % signs so they are 'escaped'
1950 void wxPyLogFatalError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogFatalError(m);
1955 }
1956
1957 void wxPyLogError(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogError(m);
1962 }
1963
1964 void wxPyLogWarning(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogWarning(m);
1969 }
1970
1971 void wxPyLogMessage(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogMessage(m);
1976 }
1977
1978 void wxPyLogInfo(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogInfo(m);
1983 }
1984
1985 void wxPyLogDebug(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogDebug(m);
1990 }
1991
1992 void wxPyLogVerbose(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogVerbose(m);
1997 }
1998
1999 void wxPyLogStatus(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(m);
2004 }
2005
2006 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogStatus(pFrame, m);
2011 }
2012
2013 void wxPyLogSysError(const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogSysError(m);
2018 }
2019
2020 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogGeneric(level, m);
2025 }
2026
2027 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogTrace(mask, m);
2039 }
2040
2041
2042
2043 // A wxLog class that can be derived from in wxPython
2044 class wxPyLog : public wxLog {
2045 public:
2046 wxPyLog() : wxLog() {}
2047
2048 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2049 bool found;
2050 bool blocked = wxPyBeginBlockThreads();
2051 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2052 PyObject* s = wx2PyString(szString);
2053 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2054 Py_DECREF(s);
2055 }
2056 wxPyEndBlockThreads(blocked);
2057 if (! found)
2058 wxLog::DoLog(level, szString, t);
2059 }
2060
2061 virtual void DoLogString(const wxChar *szString, time_t t) {
2062 bool found;
2063 bool blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLogString(szString, t);
2072 }
2073
2074 PYPRIVATE;
2075 };
2076
2077
2078
2079
2080 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2081
2082
2083 #include <wx/joystick.h>
2084
2085
2086 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2087 // A C++ stub class for wxJoystick for platforms that don't have it.
2088 class wxJoystick : public wxObject {
2089 public:
2090 wxJoystick(int joystick = wxJOYSTICK1) {
2091 bool blocked = wxPyBeginBlockThreads();
2092 PyErr_SetString(PyExc_NotImplementedError,
2093 "wxJoystick is not available on this platform.");
2094 wxPyEndBlockThreads(blocked);
2095 }
2096 wxPoint GetPosition() { return wxPoint(-1,-1); }
2097 int GetZPosition() { return -1; }
2098 int GetButtonState() { return -1; }
2099 int GetPOVPosition() { return -1; }
2100 int GetPOVCTSPosition() { return -1; }
2101 int GetRudderPosition() { return -1; }
2102 int GetUPosition() { return -1; }
2103 int GetVPosition() { return -1; }
2104 int GetMovementThreshold() { return -1; }
2105 void SetMovementThreshold(int threshold) {}
2106
2107 bool IsOk(void) { return false; }
2108 int GetNumberJoysticks() { return -1; }
2109 int GetManufacturerId() { return -1; }
2110 int GetProductId() { return -1; }
2111 wxString GetProductName() { return wxEmptyString; }
2112 int GetXMin() { return -1; }
2113 int GetYMin() { return -1; }
2114 int GetZMin() { return -1; }
2115 int GetXMax() { return -1; }
2116 int GetYMax() { return -1; }
2117 int GetZMax() { return -1; }
2118 int GetNumberButtons() { return -1; }
2119 int GetNumberAxes() { return -1; }
2120 int GetMaxButtons() { return -1; }
2121 int GetMaxAxes() { return -1; }
2122 int GetPollingMin() { return -1; }
2123 int GetPollingMax() { return -1; }
2124 int GetRudderMin() { return -1; }
2125 int GetRudderMax() { return -1; }
2126 int GetUMin() { return -1; }
2127 int GetUMax() { return -1; }
2128 int GetVMin() { return -1; }
2129 int GetVMax() { return -1; }
2130
2131 bool HasRudder() { return false; }
2132 bool HasZ() { return false; }
2133 bool HasU() { return false; }
2134 bool HasV() { return false; }
2135 bool HasPOV() { return false; }
2136 bool HasPOV4Dir() { return false; }
2137 bool HasPOVCTS() { return false; }
2138
2139 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2140 bool ReleaseCapture() { return false; }
2141 };
2142 #endif
2143
2144
2145 #include <wx/sound.h>
2146
2147
2148 #if !wxUSE_SOUND
2149 // A C++ stub class for wxWave for platforms that don't have it.
2150 class wxSound : public wxObject
2151 {
2152 public:
2153 wxSound() {
2154 bool blocked = wxPyBeginBlockThreads();
2155 PyErr_SetString(PyExc_NotImplementedError,
2156 "wxSound is not available on this platform.");
2157 wxPyEndBlockThreads(blocked);
2158 }
2159 wxSound(const wxString&/*, bool*/) {
2160 bool blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(int, const wxByte*) {
2166 bool blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171
2172 ~wxSound() {};
2173
2174 bool Create(const wxString&/*, bool*/) { return false; }
2175 bool Create(int, const wxByte*) { return false; };
2176 bool IsOk() { return false; };
2177 bool Play(unsigned) const { return false; }
2178 static bool Play(const wxString&, unsigned) { return false; }
2179 static void Stop() {}
2180 };
2181
2182 #endif
2183
2184 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2185 if (fileName.Length() == 0)
2186 return new wxSound;
2187 else
2188 return new wxSound(fileName);
2189 }
2190 static wxSound *new_wxSound(PyObject *data){
2191 unsigned char* buffer; int size;
2192 wxSound *sound = NULL;
2193
2194 bool blocked = wxPyBeginBlockThreads();
2195 if (!PyArg_Parse(data, "t#", &buffer, &size))
2196 goto done;
2197 sound = new wxSound(size, buffer);
2198 done:
2199 wxPyEndBlockThreads(blocked);
2200 return sound;
2201 }
2202 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2203 #ifndef __WXMAC__
2204 unsigned char* buffer;
2205 int size;
2206 bool rv = false;
2207
2208 bool blocked = wxPyBeginBlockThreads();
2209 if (!PyArg_Parse(data, "t#", &buffer, &size))
2210 goto done;
2211 rv = self->Create(size, buffer);
2212 done:
2213 wxPyEndBlockThreads(blocked);
2214 return rv;
2215 #else
2216 bool blocked = wxPyBeginBlockThreads();
2217 PyErr_SetString(PyExc_NotImplementedError,
2218 "Create from data is not available on this platform.");
2219 wxPyEndBlockThreads(blocked);
2220 return false;
2221 #endif
2222 }
2223
2224 #include <wx/mimetype.h>
2225
2226 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2227 wxString str;
2228 if (self->GetMimeType(&str))
2229 return wx2PyString(str);
2230 else
2231 RETURN_NONE();
2232 }
2233 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2234 wxArrayString arr;
2235 if (self->GetMimeTypes(arr))
2236 return wxArrayString2PyList_helper(arr);
2237 else
2238 RETURN_NONE();
2239 }
2240 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2241 wxArrayString arr;
2242 if (self->GetExtensions(arr))
2243 return wxArrayString2PyList_helper(arr);
2244 else
2245 RETURN_NONE();
2246 }
2247 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2248 wxIconLocation loc;
2249 if (self->GetIcon(&loc))
2250 return new wxIcon(loc);
2251 else
2252 return NULL;
2253 }
2254 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2255 wxIconLocation loc;
2256 if (self->GetIcon(&loc)) {
2257 wxString iconFile = loc.GetFileName();
2258 int iconIndex = -1;
2259
2260
2261
2262 // Make a tuple and put the values in it
2263 bool blocked = wxPyBeginBlockThreads();
2264 PyObject* tuple = PyTuple_New(3);
2265 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2266 wxT("wxIcon"), true));
2267 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2268 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2269 wxPyEndBlockThreads(blocked);
2270 return tuple;
2271 }
2272 else
2273 RETURN_NONE();
2274 }
2275 static PyObject *wxFileType_GetDescription(wxFileType *self){
2276 wxString str;
2277 if (self->GetDescription(&str))
2278 return wx2PyString(str);
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2283 wxString str;
2284 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxString str;
2291 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxArrayString verbs;
2298 wxArrayString commands;
2299 if (self->GetAllCommands(&verbs, &commands,
2300 wxFileType::MessageParameters(filename, mimetype))) {
2301 bool blocked = wxPyBeginBlockThreads();
2302 PyObject* tuple = PyTuple_New(2);
2303 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2304 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2305 wxPyEndBlockThreads(blocked);
2306 return tuple;
2307 }
2308 else
2309 RETURN_NONE();
2310 }
2311 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2312 return wxFileType::ExpandCommand(command,
2313 wxFileType::MessageParameters(filename, mimetype));
2314 }
2315 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2316 wxArrayString arr;
2317 self->EnumAllFileTypes(arr);
2318 return wxArrayString2PyList_helper(arr);
2319 }
2320
2321 #include <wx/artprov.h>
2322
2323 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2324 static const wxString wxPyART_MENU(wxART_MENU);
2325 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2326 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2327 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2328 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2329 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2330 static const wxString wxPyART_OTHER(wxART_OTHER);
2331 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2332 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2333 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2334 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2335 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2336 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2337 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2338 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2339 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2340 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2341 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2342 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2343 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2344 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2345 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2346 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2347 static const wxString wxPyART_PRINT(wxART_PRINT);
2348 static const wxString wxPyART_HELP(wxART_HELP);
2349 static const wxString wxPyART_TIP(wxART_TIP);
2350 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2351 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2352 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2353 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2354 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2355 static const wxString wxPyART_CDROM(wxART_CDROM);
2356 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2357 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2358 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2359 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2360 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2361 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2362 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2363 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2364 static const wxString wxPyART_ERROR(wxART_ERROR);
2365 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2366 static const wxString wxPyART_WARNING(wxART_WARNING);
2367 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2368 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2369 static const wxString wxPyART_COPY(wxART_COPY);
2370 static const wxString wxPyART_CUT(wxART_CUT);
2371 static const wxString wxPyART_PASTE(wxART_PASTE);
2372 static const wxString wxPyART_DELETE(wxART_DELETE);
2373 static const wxString wxPyART_UNDO(wxART_UNDO);
2374 static const wxString wxPyART_REDO(wxART_REDO);
2375 static const wxString wxPyART_QUIT(wxART_QUIT);
2376 static const wxString wxPyART_FIND(wxART_FIND);
2377 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2378 // Python aware wxArtProvider
2379 class wxPyArtProvider : public wxArtProvider {
2380 public:
2381
2382 virtual wxBitmap CreateBitmap(const wxArtID& id,
2383 const wxArtClient& client,
2384 const wxSize& size) {
2385 wxBitmap rval = wxNullBitmap;
2386 bool blocked = wxPyBeginBlockThreads();
2387 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2388 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2389 PyObject* ro;
2390 wxBitmap* ptr;
2391 PyObject* s1, *s2;
2392 s1 = wx2PyString(id);
2393 s2 = wx2PyString(client);
2394 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2395 Py_DECREF(so);
2396 Py_DECREF(s1);
2397 Py_DECREF(s2);
2398 if (ro) {
2399 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2400 rval = *ptr;
2401 Py_DECREF(ro);
2402 }
2403 }
2404 wxPyEndBlockThreads(blocked);
2405 return rval;
2406 }
2407
2408 PYPRIVATE;
2409 };
2410
2411 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2412
2413
2414
2415 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2416 PyObject* ret = PyTuple_New(3);
2417 if (ret) {
2418 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2419 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2420 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2421 }
2422 return ret;
2423 }
2424
2425 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2426 bool cont;
2427 long index = 0;
2428 wxString value;
2429
2430 cont = self->GetFirstGroup(value, index);
2431 return __EnumerationHelper(cont, value, index);
2432 }
2433 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2434 bool cont;
2435 wxString value;
2436
2437 cont = self->GetNextGroup(value, index);
2438 return __EnumerationHelper(cont, value, index);
2439 }
2440 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2441 bool cont;
2442 long index = 0;
2443 wxString value;
2444
2445 cont = self->GetFirstEntry(value, index);
2446 return __EnumerationHelper(cont, value, index);
2447 }
2448 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2449 bool cont;
2450 wxString value;
2451
2452 cont = self->GetNextEntry(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2456 long rv;
2457 self->Read(key, &rv, defaultVal);
2458 return rv;
2459 }
2460
2461 SWIGINTERN int
2462 SWIG_AsVal_double(PyObject *obj, double* val)
2463 {
2464 if (PyNumber_Check(obj)) {
2465 if (val) *val = PyFloat_AsDouble(obj);
2466 return 1;
2467 }
2468 else {
2469 SWIG_type_error("number", obj);
2470 }
2471 return 0;
2472 }
2473
2474
2475 SWIGINTERNSHORT double
2476 SWIG_As_double(PyObject* obj)
2477 {
2478 double v;
2479 if (!SWIG_AsVal_double(obj, &v)) {
2480 /*
2481 this is needed to make valgrind/purify happier.
2482 */
2483 memset((void*)&v, 0, sizeof(double));
2484 }
2485 return v;
2486 }
2487
2488
2489 SWIGINTERNSHORT int
2490 SWIG_Check_double(PyObject* obj)
2491 {
2492 return SWIG_AsVal_double(obj, (double*)0);
2493 }
2494
2495 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2496 double rv;
2497 self->Read(key, &rv, defaultVal);
2498 return rv;
2499 }
2500
2501 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2502 #define SWIG_From_double PyFloat_FromDouble
2503 /*@@*/
2504
2505 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2506 bool rv;
2507 self->Read(key, &rv, defaultVal);
2508 return rv;
2509 }
2510
2511 #include <wx/datetime.h>
2512
2513 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2514 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2515
2516 #define LOCAL_TZ wxDateTime::Local
2517
2518 static PyObject *DateTime_GetAmPmStrings(){
2519 wxString am;
2520 wxString pm;
2521 wxDateTime::GetAmPmStrings(&am, &pm);
2522 bool blocked = wxPyBeginBlockThreads();
2523 PyObject* tup = PyTuple_New(2);
2524 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2525 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2526 wxPyEndBlockThreads(blocked);
2527 return tup;
2528 }
2529
2530 #if UINT_MAX < LONG_MAX
2531 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2532 #define SWIG_From_unsigned_SS_int SWIG_From_long
2533 /*@@*/
2534 #else
2535 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2536 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2537 /*@@*/
2538 #endif
2539
2540 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2541 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2542 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2543 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2544 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2545 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2546 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2547 return (*self < *other);
2548 }
2549 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2550 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2551 return (*self <= *other);
2552 }
2553 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2554 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2555 return (*self > *other);
2556 }
2557 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2558 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2559 return (*self >= *other);
2560 }
2561 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2562 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2563 return (*self == *other);
2564 }
2565 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2566 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2567 return (*self != *other);
2568 }
2569 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2570 const wxChar* rv;
2571 const wxChar* _date = date;
2572 rv = self->ParseRfc822Date(_date);
2573 if (rv == NULL) return -1;
2574 return rv - _date;
2575 }
2576 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2577 const wxChar* rv;
2578 const wxChar* _date = date;
2579 rv = self->ParseFormat(_date, format, dateDef);
2580 if (rv == NULL) return -1;
2581 return rv - _date;
2582 }
2583 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2584 const wxChar* rv;
2585 const wxChar* _datetime = datetime;
2586 rv = self->ParseDateTime(_datetime);
2587 if (rv == NULL) return -1;
2588 return rv - _datetime;
2589 }
2590 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2591 const wxChar* rv;
2592 const wxChar* _date = date;
2593 rv = self->ParseDate(_date);
2594 if (rv == NULL) return -1;
2595 return rv - _date;
2596 }
2597 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2598 const wxChar* rv;
2599 const wxChar* _time = time;
2600 rv = self->ParseTime(_time);
2601 if (rv == NULL) return -1;
2602 return rv - _time;
2603 }
2604 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2605 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2606 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2607 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2608 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2609 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2610 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2611 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2612 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2613 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2614 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2615 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2616 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2617 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2618 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2620
2621 #include <wx/dataobj.h>
2622
2623 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2624 size_t count = self->GetFormatCount(dir);
2625 wxDataFormat* formats = new wxDataFormat[count];
2626 self->GetAllFormats(formats, dir);
2627
2628 bool blocked = wxPyBeginBlockThreads();
2629 PyObject* list = PyList_New(count);
2630 for (size_t i=0; i<count; i++) {
2631 wxDataFormat* format = new wxDataFormat(formats[i]);
2632 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2633 PyList_Append(list, obj);
2634 Py_DECREF(obj);
2635 }
2636 wxPyEndBlockThreads(blocked);
2637 delete [] formats;
2638 return list;
2639 }
2640 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2641 PyObject* rval = NULL;
2642 size_t size = self->GetDataSize(format);
2643 bool blocked = wxPyBeginBlockThreads();
2644 if (size) {
2645 char* buf = new char[size];
2646 if (self->GetDataHere(format, buf))
2647 rval = PyString_FromStringAndSize(buf, size);
2648 delete [] buf;
2649 }
2650 if (! rval) {
2651 rval = Py_None;
2652 Py_INCREF(rval);
2653 }
2654 wxPyEndBlockThreads(blocked);
2655 return rval;
2656 }
2657 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2658 bool rval;
2659 bool blocked = wxPyBeginBlockThreads();
2660 if (PyString_Check(data)) {
2661 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2662 }
2663 else {
2664 // raise a TypeError if not a string
2665 PyErr_SetString(PyExc_TypeError, "String expected.");
2666 rval = false;
2667 }
2668 wxPyEndBlockThreads(blocked);
2669 return rval;
2670 }
2671 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2672 PyObject* rval = NULL;
2673 size_t size = self->GetDataSize();
2674 bool blocked = wxPyBeginBlockThreads();
2675 if (size) {
2676 char* buf = new char[size];
2677 if (self->GetDataHere(buf))
2678 rval = PyString_FromStringAndSize(buf, size);
2679 delete [] buf;
2680 }
2681 if (! rval) {
2682 rval = Py_None;
2683 Py_INCREF(rval);
2684 }
2685 wxPyEndBlockThreads(blocked);
2686 return rval;
2687 }
2688 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2689 bool rval;
2690 bool blocked = wxPyBeginBlockThreads();
2691 if (PyString_Check(data)) {
2692 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2693 }
2694 else {
2695 // raise a TypeError if not a string
2696 PyErr_SetString(PyExc_TypeError, "String expected.");
2697 rval = false;
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 return rval;
2701 }
2702 // Create a new class for wxPython to use
2703 class wxPyDataObjectSimple : public wxDataObjectSimple {
2704 public:
2705 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2706 : wxDataObjectSimple(format) {}
2707
2708 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2709 bool GetDataHere(void *buf) const;
2710 bool SetData(size_t len, const void *buf) const;
2711 PYPRIVATE;
2712 };
2713
2714 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2715
2716 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2717 // We need to get the data for this object and write it to buf. I think
2718 // the best way to do this for wxPython is to have the Python method
2719 // return either a string or None and then act appropriately with the
2720 // C++ version.
2721
2722 bool rval = false;
2723 bool blocked = wxPyBeginBlockThreads();
2724 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2725 PyObject* ro;
2726 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2727 if (ro) {
2728 rval = (ro != Py_None && PyString_Check(ro));
2729 if (rval)
2730 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2731 Py_DECREF(ro);
2732 }
2733 }
2734 wxPyEndBlockThreads(blocked);
2735 return rval;
2736 }
2737
2738 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2739 // For this one we simply need to make a string from buf and len
2740 // and send it to the Python method.
2741 bool rval = false;
2742 bool blocked = wxPyBeginBlockThreads();
2743 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2744 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2745 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2746 Py_DECREF(data);
2747 }
2748 wxPyEndBlockThreads(blocked);
2749 return rval;
2750 }
2751
2752 // Create a new class for wxPython to use
2753 class wxPyTextDataObject : public wxTextDataObject {
2754 public:
2755 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2756 : wxTextDataObject(text) {}
2757
2758 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2759 DEC_PYCALLBACK_STRING__const(GetText);
2760 DEC_PYCALLBACK__STRING(SetText);
2761 PYPRIVATE;
2762 };
2763
2764 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2765 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2766 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2767
2768
2769 // Create a new class for wxPython to use
2770 class wxPyBitmapDataObject : public wxBitmapDataObject {
2771 public:
2772 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2773 : wxBitmapDataObject(bitmap) {}
2774
2775 wxBitmap GetBitmap() const;
2776 void SetBitmap(const wxBitmap& bitmap);
2777 PYPRIVATE;
2778 };
2779
2780 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2781 wxBitmap* rval = &wxNullBitmap;
2782 bool blocked = wxPyBeginBlockThreads();
2783 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2784 PyObject* ro;
2785 wxBitmap* ptr;
2786 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2787 if (ro) {
2788 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2789 rval = ptr;
2790 Py_DECREF(ro);
2791 }
2792 }
2793 wxPyEndBlockThreads(blocked);
2794 return *rval;
2795 }
2796
2797 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2798 bool blocked = wxPyBeginBlockThreads();
2799 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2800 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2801 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2802 Py_DECREF(bo);
2803 }
2804 wxPyEndBlockThreads(blocked);
2805 }
2806
2807 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2808 return new wxCustomDataObject(wxDataFormat(formatName));
2809 }
2810 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2811 bool rval;
2812 bool blocked = wxPyBeginBlockThreads();
2813 if (PyString_Check(data)) {
2814 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2815 }
2816 else {
2817 // raise a TypeError if not a string
2818 PyErr_SetString(PyExc_TypeError, "String expected.");
2819 rval = false;
2820 }
2821 wxPyEndBlockThreads(blocked);
2822 return rval;
2823 }
2824 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2825 PyObject* obj;
2826 bool blocked = wxPyBeginBlockThreads();
2827 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2828 wxPyEndBlockThreads(blocked);
2829 return obj;
2830 }
2831
2832 #include <wx/metafile.h>
2833
2834
2835 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2836
2837
2838 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2839 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2840 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2841 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2842 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2843
2844
2845 class wxPyTextDropTarget : public wxTextDropTarget {
2846 public:
2847 wxPyTextDropTarget() {}
2848
2849 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2850
2851 DEC_PYCALLBACK__(OnLeave);
2852 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2854 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2855 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2856
2857 PYPRIVATE;
2858 };
2859
2860 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2861 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2862 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2865 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2866
2867
2868
2869 class wxPyFileDropTarget : public wxFileDropTarget {
2870 public:
2871 wxPyFileDropTarget() {}
2872
2873 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2874
2875 DEC_PYCALLBACK__(OnLeave);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2879 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2880
2881 PYPRIVATE;
2882 };
2883
2884 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2885 const wxArrayString& filenames) {
2886 bool rval = false;
2887 bool blocked = wxPyBeginBlockThreads();
2888 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2889 PyObject* list = wxArrayString2PyList_helper(filenames);
2890 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2891 Py_DECREF(list);
2892 }
2893 wxPyEndBlockThreads(blocked);
2894 return rval;
2895 }
2896
2897
2898
2899 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2900 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2902 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2903 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2904
2905
2906
2907
2908 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2909
2910 #include <wx/display.h>
2911
2912 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2913 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2914
2915 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2916 #if !wxUSE_DISPLAY
2917 #include <wx/dynarray.h>
2918 #include <wx/vidmode.h>
2919
2920 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2921 #include "wx/arrimpl.cpp"
2922 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2923 const wxVideoMode wxDefaultVideoMode;
2924
2925 class wxDisplay
2926 {
2927 public:
2928 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2929 ~wxDisplay() {}
2930
2931 static size_t GetCount()
2932 { wxPyRaiseNotImplemented(); return 0; }
2933
2934 static int GetFromPoint(const wxPoint& pt)
2935 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2936 static int GetFromWindow(wxWindow *window)
2937 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2938
2939 virtual bool IsOk() const { return false; }
2940 virtual wxRect GetGeometry() const { wxRect r; return r; }
2941 virtual wxString GetName() const { return wxEmptyString; }
2942 bool IsPrimary() const { return false; }
2943
2944 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2945 { wxArrayVideoModes a; return a; }
2946
2947 virtual wxVideoMode GetCurrentMode() const
2948 { return wxDefaultVideoMode; }
2949
2950 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2951 { return false; }
2952
2953 void ResetMode() {}
2954 };
2955 #endif
2956
2957 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2958 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2959 PyObject* pyList = NULL;
2960 wxArrayVideoModes arr = self->GetModes(mode);
2961 bool blocked = wxPyBeginBlockThreads();
2962 pyList = PyList_New(0);
2963 for (int i=0; i < arr.GetCount(); i++) {
2964 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2965 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2966 PyList_Append(pyList, pyObj);
2967 Py_DECREF(pyObj);
2968 }
2969 wxPyEndBlockThreads(blocked);
2970 return pyList;
2971 }
2972
2973 #include <wx/stdpaths.h>
2974
2975 static wxStandardPaths *StandardPaths_Get(){
2976 return (wxStandardPaths*) &wxStandardPaths::Get();
2977 }
2978 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2979 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2980 #ifdef __cplusplus
2981 extern "C" {
2982 #endif
2983 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2984 PyObject *resultobj;
2985 wxSystemColour arg1 ;
2986 wxColour result;
2987 PyObject * obj0 = 0 ;
2988 char *kwnames[] = {
2989 (char *) "index", NULL
2990 };
2991
2992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2993 {
2994 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2995 if (SWIG_arg_fail(1)) SWIG_fail;
2996 }
2997 {
2998 if (!wxPyCheckForApp()) SWIG_fail;
2999 PyThreadState* __tstate = wxPyBeginAllowThreads();
3000 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3001
3002 wxPyEndAllowThreads(__tstate);
3003 if (PyErr_Occurred()) SWIG_fail;
3004 }
3005 {
3006 wxColour * resultptr;
3007 resultptr = new wxColour((wxColour &)(result));
3008 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3009 }
3010 return resultobj;
3011 fail:
3012 return NULL;
3013 }
3014
3015
3016 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3017 PyObject *resultobj;
3018 wxSystemFont arg1 ;
3019 wxFont result;
3020 PyObject * obj0 = 0 ;
3021 char *kwnames[] = {
3022 (char *) "index", NULL
3023 };
3024
3025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3026 {
3027 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3028 if (SWIG_arg_fail(1)) SWIG_fail;
3029 }
3030 {
3031 if (!wxPyCheckForApp()) SWIG_fail;
3032 PyThreadState* __tstate = wxPyBeginAllowThreads();
3033 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3034
3035 wxPyEndAllowThreads(__tstate);
3036 if (PyErr_Occurred()) SWIG_fail;
3037 }
3038 {
3039 wxFont * resultptr;
3040 resultptr = new wxFont((wxFont &)(result));
3041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3042 }
3043 return resultobj;
3044 fail:
3045 return NULL;
3046 }
3047
3048
3049 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3050 PyObject *resultobj;
3051 wxSystemMetric arg1 ;
3052 int result;
3053 PyObject * obj0 = 0 ;
3054 char *kwnames[] = {
3055 (char *) "index", NULL
3056 };
3057
3058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3059 {
3060 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3061 if (SWIG_arg_fail(1)) SWIG_fail;
3062 }
3063 {
3064 if (!wxPyCheckForApp()) SWIG_fail;
3065 PyThreadState* __tstate = wxPyBeginAllowThreads();
3066 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3067
3068 wxPyEndAllowThreads(__tstate);
3069 if (PyErr_Occurred()) SWIG_fail;
3070 }
3071 {
3072 resultobj = SWIG_From_int((int)(result));
3073 }
3074 return resultobj;
3075 fail:
3076 return NULL;
3077 }
3078
3079
3080 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3081 PyObject *resultobj;
3082 wxSystemFeature arg1 ;
3083 bool result;
3084 PyObject * obj0 = 0 ;
3085 char *kwnames[] = {
3086 (char *) "index", NULL
3087 };
3088
3089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3090 {
3091 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3092 if (SWIG_arg_fail(1)) SWIG_fail;
3093 }
3094 {
3095 if (!wxPyCheckForApp()) SWIG_fail;
3096 PyThreadState* __tstate = wxPyBeginAllowThreads();
3097 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3098
3099 wxPyEndAllowThreads(__tstate);
3100 if (PyErr_Occurred()) SWIG_fail;
3101 }
3102 {
3103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3104 }
3105 return resultobj;
3106 fail:
3107 return NULL;
3108 }
3109
3110
3111 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3112 PyObject *resultobj;
3113 wxSystemScreenType result;
3114 char *kwnames[] = {
3115 NULL
3116 };
3117
3118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3119 {
3120 if (!wxPyCheckForApp()) SWIG_fail;
3121 PyThreadState* __tstate = wxPyBeginAllowThreads();
3122 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3123
3124 wxPyEndAllowThreads(__tstate);
3125 if (PyErr_Occurred()) SWIG_fail;
3126 }
3127 resultobj = SWIG_From_int((result));
3128 return resultobj;
3129 fail:
3130 return NULL;
3131 }
3132
3133
3134 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3135 PyObject *resultobj;
3136 wxSystemScreenType arg1 ;
3137 PyObject * obj0 = 0 ;
3138 char *kwnames[] = {
3139 (char *) "screen", NULL
3140 };
3141
3142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3143 {
3144 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3145 if (SWIG_arg_fail(1)) SWIG_fail;
3146 }
3147 {
3148 if (!wxPyCheckForApp()) SWIG_fail;
3149 PyThreadState* __tstate = wxPyBeginAllowThreads();
3150 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3151
3152 wxPyEndAllowThreads(__tstate);
3153 if (PyErr_Occurred()) SWIG_fail;
3154 }
3155 Py_INCREF(Py_None); resultobj = Py_None;
3156 return resultobj;
3157 fail:
3158 return NULL;
3159 }
3160
3161
3162 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3163 PyObject *obj;
3164 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3165 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3166 Py_INCREF(obj);
3167 return Py_BuildValue((char *)"");
3168 }
3169 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3170 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3171 return 1;
3172 }
3173
3174
3175 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3176 PyObject *pyobj;
3177
3178 {
3179 #if wxUSE_UNICODE
3180 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3181 #else
3182 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3183 #endif
3184 }
3185 return pyobj;
3186 }
3187
3188
3189 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3190 PyObject *resultobj;
3191 wxSystemOptions *result;
3192 char *kwnames[] = {
3193 NULL
3194 };
3195
3196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3197 {
3198 PyThreadState* __tstate = wxPyBeginAllowThreads();
3199 result = (wxSystemOptions *)new wxSystemOptions();
3200
3201 wxPyEndAllowThreads(__tstate);
3202 if (PyErr_Occurred()) SWIG_fail;
3203 }
3204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3205 return resultobj;
3206 fail:
3207 return NULL;
3208 }
3209
3210
3211 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3212 PyObject *resultobj;
3213 wxString *arg1 = 0 ;
3214 wxString *arg2 = 0 ;
3215 bool temp1 = false ;
3216 bool temp2 = false ;
3217 PyObject * obj0 = 0 ;
3218 PyObject * obj1 = 0 ;
3219 char *kwnames[] = {
3220 (char *) "name",(char *) "value", NULL
3221 };
3222
3223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3224 {
3225 arg1 = wxString_in_helper(obj0);
3226 if (arg1 == NULL) SWIG_fail;
3227 temp1 = true;
3228 }
3229 {
3230 arg2 = wxString_in_helper(obj1);
3231 if (arg2 == NULL) SWIG_fail;
3232 temp2 = true;
3233 }
3234 {
3235 PyThreadState* __tstate = wxPyBeginAllowThreads();
3236 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3237
3238 wxPyEndAllowThreads(__tstate);
3239 if (PyErr_Occurred()) SWIG_fail;
3240 }
3241 Py_INCREF(Py_None); resultobj = Py_None;
3242 {
3243 if (temp1)
3244 delete arg1;
3245 }
3246 {
3247 if (temp2)
3248 delete arg2;
3249 }
3250 return resultobj;
3251 fail:
3252 {
3253 if (temp1)
3254 delete arg1;
3255 }
3256 {
3257 if (temp2)
3258 delete arg2;
3259 }
3260 return NULL;
3261 }
3262
3263
3264 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3265 PyObject *resultobj;
3266 wxString *arg1 = 0 ;
3267 int arg2 ;
3268 bool temp1 = false ;
3269 PyObject * obj0 = 0 ;
3270 PyObject * obj1 = 0 ;
3271 char *kwnames[] = {
3272 (char *) "name",(char *) "value", NULL
3273 };
3274
3275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3276 {
3277 arg1 = wxString_in_helper(obj0);
3278 if (arg1 == NULL) SWIG_fail;
3279 temp1 = true;
3280 }
3281 {
3282 arg2 = (int)(SWIG_As_int(obj1));
3283 if (SWIG_arg_fail(2)) SWIG_fail;
3284 }
3285 {
3286 PyThreadState* __tstate = wxPyBeginAllowThreads();
3287 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3288
3289 wxPyEndAllowThreads(__tstate);
3290 if (PyErr_Occurred()) SWIG_fail;
3291 }
3292 Py_INCREF(Py_None); resultobj = Py_None;
3293 {
3294 if (temp1)
3295 delete arg1;
3296 }
3297 return resultobj;
3298 fail:
3299 {
3300 if (temp1)
3301 delete arg1;
3302 }
3303 return NULL;
3304 }
3305
3306
3307 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3308 PyObject *resultobj;
3309 wxString *arg1 = 0 ;
3310 wxString result;
3311 bool temp1 = false ;
3312 PyObject * obj0 = 0 ;
3313 char *kwnames[] = {
3314 (char *) "name", NULL
3315 };
3316
3317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3318 {
3319 arg1 = wxString_in_helper(obj0);
3320 if (arg1 == NULL) SWIG_fail;
3321 temp1 = true;
3322 }
3323 {
3324 PyThreadState* __tstate = wxPyBeginAllowThreads();
3325 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3326
3327 wxPyEndAllowThreads(__tstate);
3328 if (PyErr_Occurred()) SWIG_fail;
3329 }
3330 {
3331 #if wxUSE_UNICODE
3332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3333 #else
3334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3335 #endif
3336 }
3337 {
3338 if (temp1)
3339 delete arg1;
3340 }
3341 return resultobj;
3342 fail:
3343 {
3344 if (temp1)
3345 delete arg1;
3346 }
3347 return NULL;
3348 }
3349
3350
3351 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3352 PyObject *resultobj;
3353 wxString *arg1 = 0 ;
3354 int result;
3355 bool temp1 = false ;
3356 PyObject * obj0 = 0 ;
3357 char *kwnames[] = {
3358 (char *) "name", NULL
3359 };
3360
3361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3362 {
3363 arg1 = wxString_in_helper(obj0);
3364 if (arg1 == NULL) SWIG_fail;
3365 temp1 = true;
3366 }
3367 {
3368 PyThreadState* __tstate = wxPyBeginAllowThreads();
3369 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3370
3371 wxPyEndAllowThreads(__tstate);
3372 if (PyErr_Occurred()) SWIG_fail;
3373 }
3374 {
3375 resultobj = SWIG_From_int((int)(result));
3376 }
3377 {
3378 if (temp1)
3379 delete arg1;
3380 }
3381 return resultobj;
3382 fail:
3383 {
3384 if (temp1)
3385 delete arg1;
3386 }
3387 return NULL;
3388 }
3389
3390
3391 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3392 PyObject *resultobj;
3393 wxString *arg1 = 0 ;
3394 bool result;
3395 bool temp1 = false ;
3396 PyObject * obj0 = 0 ;
3397 char *kwnames[] = {
3398 (char *) "name", NULL
3399 };
3400
3401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3402 {
3403 arg1 = wxString_in_helper(obj0);
3404 if (arg1 == NULL) SWIG_fail;
3405 temp1 = true;
3406 }
3407 {
3408 PyThreadState* __tstate = wxPyBeginAllowThreads();
3409 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3410
3411 wxPyEndAllowThreads(__tstate);
3412 if (PyErr_Occurred()) SWIG_fail;
3413 }
3414 {
3415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3416 }
3417 {
3418 if (temp1)
3419 delete arg1;
3420 }
3421 return resultobj;
3422 fail:
3423 {
3424 if (temp1)
3425 delete arg1;
3426 }
3427 return NULL;
3428 }
3429
3430
3431 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3432 PyObject *obj;
3433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3434 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3435 Py_INCREF(obj);
3436 return Py_BuildValue((char *)"");
3437 }
3438 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3439 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3440 return 1;
3441 }
3442
3443
3444 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3445 PyObject *pyobj;
3446
3447 {
3448 #if wxUSE_UNICODE
3449 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3450 #else
3451 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3452 #endif
3453 }
3454 return pyobj;
3455 }
3456
3457
3458 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3459 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3460 return 1;
3461 }
3462
3463
3464 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3465 PyObject *pyobj;
3466
3467 {
3468 #if wxUSE_UNICODE
3469 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3470 #else
3471 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3472 #endif
3473 }
3474 return pyobj;
3475 }
3476
3477
3478 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3479 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3480 return 1;
3481 }
3482
3483
3484 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3485 PyObject *pyobj;
3486
3487 {
3488 #if wxUSE_UNICODE
3489 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3490 #else
3491 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3492 #endif
3493 }
3494 return pyobj;
3495 }
3496
3497
3498 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 long result;
3501 char *kwnames[] = {
3502 NULL
3503 };
3504
3505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3506 {
3507 PyThreadState* __tstate = wxPyBeginAllowThreads();
3508 result = (long)wxNewId();
3509
3510 wxPyEndAllowThreads(__tstate);
3511 if (PyErr_Occurred()) SWIG_fail;
3512 }
3513 {
3514 resultobj = SWIG_From_long((long)(result));
3515 }
3516 return resultobj;
3517 fail:
3518 return NULL;
3519 }
3520
3521
3522 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3523 PyObject *resultobj;
3524 long arg1 ;
3525 PyObject * obj0 = 0 ;
3526 char *kwnames[] = {
3527 (char *) "id", NULL
3528 };
3529
3530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3531 {
3532 arg1 = (long)(SWIG_As_long(obj0));
3533 if (SWIG_arg_fail(1)) SWIG_fail;
3534 }
3535 {
3536 PyThreadState* __tstate = wxPyBeginAllowThreads();
3537 wxRegisterId(arg1);
3538
3539 wxPyEndAllowThreads(__tstate);
3540 if (PyErr_Occurred()) SWIG_fail;
3541 }
3542 Py_INCREF(Py_None); resultobj = Py_None;
3543 return resultobj;
3544 fail:
3545 return NULL;
3546 }
3547
3548
3549 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3550 PyObject *resultobj;
3551 long result;
3552 char *kwnames[] = {
3553 NULL
3554 };
3555
3556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3557 {
3558 PyThreadState* __tstate = wxPyBeginAllowThreads();
3559 result = (long)wxGetCurrentId();
3560
3561 wxPyEndAllowThreads(__tstate);
3562 if (PyErr_Occurred()) SWIG_fail;
3563 }
3564 {
3565 resultobj = SWIG_From_long((long)(result));
3566 }
3567 return resultobj;
3568 fail:
3569 return NULL;
3570 }
3571
3572
3573 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3574 PyObject *resultobj;
3575 int arg1 ;
3576 bool result;
3577 PyObject * obj0 = 0 ;
3578 char *kwnames[] = {
3579 (char *) "id", NULL
3580 };
3581
3582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3583 {
3584 arg1 = (int)(SWIG_As_int(obj0));
3585 if (SWIG_arg_fail(1)) SWIG_fail;
3586 }
3587 {
3588 PyThreadState* __tstate = wxPyBeginAllowThreads();
3589 result = (bool)wxIsStockID(arg1);
3590
3591 wxPyEndAllowThreads(__tstate);
3592 if (PyErr_Occurred()) SWIG_fail;
3593 }
3594 {
3595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3596 }
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3604 PyObject *resultobj;
3605 int arg1 ;
3606 wxString *arg2 = 0 ;
3607 bool result;
3608 bool temp2 = false ;
3609 PyObject * obj0 = 0 ;
3610 PyObject * obj1 = 0 ;
3611 char *kwnames[] = {
3612 (char *) "id",(char *) "label", NULL
3613 };
3614
3615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3616 {
3617 arg1 = (int)(SWIG_As_int(obj0));
3618 if (SWIG_arg_fail(1)) SWIG_fail;
3619 }
3620 {
3621 arg2 = wxString_in_helper(obj1);
3622 if (arg2 == NULL) SWIG_fail;
3623 temp2 = true;
3624 }
3625 {
3626 PyThreadState* __tstate = wxPyBeginAllowThreads();
3627 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3628
3629 wxPyEndAllowThreads(__tstate);
3630 if (PyErr_Occurred()) SWIG_fail;
3631 }
3632 {
3633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3634 }
3635 {
3636 if (temp2)
3637 delete arg2;
3638 }
3639 return resultobj;
3640 fail:
3641 {
3642 if (temp2)
3643 delete arg2;
3644 }
3645 return NULL;
3646 }
3647
3648
3649 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3650 PyObject *resultobj;
3651 int arg1 ;
3652 bool arg2 = (bool) true ;
3653 wxString arg3 = (wxString) wxPyEmptyString ;
3654 wxString result;
3655 PyObject * obj0 = 0 ;
3656 PyObject * obj1 = 0 ;
3657 PyObject * obj2 = 0 ;
3658 char *kwnames[] = {
3659 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3660 };
3661
3662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3663 {
3664 arg1 = (int)(SWIG_As_int(obj0));
3665 if (SWIG_arg_fail(1)) SWIG_fail;
3666 }
3667 if (obj1) {
3668 {
3669 arg2 = (bool)(SWIG_As_bool(obj1));
3670 if (SWIG_arg_fail(2)) SWIG_fail;
3671 }
3672 }
3673 if (obj2) {
3674 {
3675 wxString* sptr = wxString_in_helper(obj2);
3676 if (sptr == NULL) SWIG_fail;
3677 arg3 = *sptr;
3678 delete sptr;
3679 }
3680 }
3681 {
3682 PyThreadState* __tstate = wxPyBeginAllowThreads();
3683 result = wxGetStockLabel(arg1,arg2,arg3);
3684
3685 wxPyEndAllowThreads(__tstate);
3686 if (PyErr_Occurred()) SWIG_fail;
3687 }
3688 {
3689 #if wxUSE_UNICODE
3690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3691 #else
3692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3693 #endif
3694 }
3695 return resultobj;
3696 fail:
3697 return NULL;
3698 }
3699
3700
3701 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3702 PyObject *resultobj;
3703 char *kwnames[] = {
3704 NULL
3705 };
3706
3707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3708 {
3709 if (!wxPyCheckForApp()) SWIG_fail;
3710 PyThreadState* __tstate = wxPyBeginAllowThreads();
3711 wxBell();
3712
3713 wxPyEndAllowThreads(__tstate);
3714 if (PyErr_Occurred()) SWIG_fail;
3715 }
3716 Py_INCREF(Py_None); resultobj = Py_None;
3717 return resultobj;
3718 fail:
3719 return NULL;
3720 }
3721
3722
3723 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3724 PyObject *resultobj;
3725 char *kwnames[] = {
3726 NULL
3727 };
3728
3729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3730 {
3731 if (!wxPyCheckForApp()) SWIG_fail;
3732 PyThreadState* __tstate = wxPyBeginAllowThreads();
3733 wxEndBusyCursor();
3734
3735 wxPyEndAllowThreads(__tstate);
3736 if (PyErr_Occurred()) SWIG_fail;
3737 }
3738 Py_INCREF(Py_None); resultobj = Py_None;
3739 return resultobj;
3740 fail:
3741 return NULL;
3742 }
3743
3744
3745 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3746 PyObject *resultobj;
3747 bool arg1 = (bool) true ;
3748 long result;
3749 PyObject * obj0 = 0 ;
3750 char *kwnames[] = {
3751 (char *) "resetTimer", NULL
3752 };
3753
3754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3755 if (obj0) {
3756 {
3757 arg1 = (bool)(SWIG_As_bool(obj0));
3758 if (SWIG_arg_fail(1)) SWIG_fail;
3759 }
3760 }
3761 {
3762 PyThreadState* __tstate = wxPyBeginAllowThreads();
3763 result = (long)wxGetElapsedTime(arg1);
3764
3765 wxPyEndAllowThreads(__tstate);
3766 if (PyErr_Occurred()) SWIG_fail;
3767 }
3768 {
3769 resultobj = SWIG_From_long((long)(result));
3770 }
3771 return resultobj;
3772 fail:
3773 return NULL;
3774 }
3775
3776
3777 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3778 PyObject *resultobj;
3779 int *arg1 = (int *) 0 ;
3780 int *arg2 = (int *) 0 ;
3781 int temp1 ;
3782 int res1 = 0 ;
3783 int temp2 ;
3784 int res2 = 0 ;
3785 char *kwnames[] = {
3786 NULL
3787 };
3788
3789 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3790 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3792 {
3793 if (!wxPyCheckForApp()) SWIG_fail;
3794 PyThreadState* __tstate = wxPyBeginAllowThreads();
3795 wxGetMousePosition(arg1,arg2);
3796
3797 wxPyEndAllowThreads(__tstate);
3798 if (PyErr_Occurred()) SWIG_fail;
3799 }
3800 Py_INCREF(Py_None); resultobj = Py_None;
3801 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3802 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3803 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3804 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3805 return resultobj;
3806 fail:
3807 return NULL;
3808 }
3809
3810
3811 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3812 PyObject *resultobj;
3813 bool result;
3814 char *kwnames[] = {
3815 NULL
3816 };
3817
3818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3819 {
3820 PyThreadState* __tstate = wxPyBeginAllowThreads();
3821 result = (bool)wxIsBusy();
3822
3823 wxPyEndAllowThreads(__tstate);
3824 if (PyErr_Occurred()) SWIG_fail;
3825 }
3826 {
3827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3828 }
3829 return resultobj;
3830 fail:
3831 return NULL;
3832 }
3833
3834
3835 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3836 PyObject *resultobj;
3837 wxString result;
3838 char *kwnames[] = {
3839 NULL
3840 };
3841
3842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3843 {
3844 PyThreadState* __tstate = wxPyBeginAllowThreads();
3845 result = wxNow();
3846
3847 wxPyEndAllowThreads(__tstate);
3848 if (PyErr_Occurred()) SWIG_fail;
3849 }
3850 {
3851 #if wxUSE_UNICODE
3852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3853 #else
3854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3855 #endif
3856 }
3857 return resultobj;
3858 fail:
3859 return NULL;
3860 }
3861
3862
3863 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3864 PyObject *resultobj;
3865 wxString const &arg1_defvalue = wxPyEmptyString ;
3866 wxString *arg1 = (wxString *) &arg1_defvalue ;
3867 bool result;
3868 bool temp1 = false ;
3869 PyObject * obj0 = 0 ;
3870 char *kwnames[] = {
3871 (char *) "command", NULL
3872 };
3873
3874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3875 if (obj0) {
3876 {
3877 arg1 = wxString_in_helper(obj0);
3878 if (arg1 == NULL) SWIG_fail;
3879 temp1 = true;
3880 }
3881 }
3882 {
3883 PyThreadState* __tstate = wxPyBeginAllowThreads();
3884 result = (bool)wxShell((wxString const &)*arg1);
3885
3886 wxPyEndAllowThreads(__tstate);
3887 if (PyErr_Occurred()) SWIG_fail;
3888 }
3889 {
3890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3891 }
3892 {
3893 if (temp1)
3894 delete arg1;
3895 }
3896 return resultobj;
3897 fail:
3898 {
3899 if (temp1)
3900 delete arg1;
3901 }
3902 return NULL;
3903 }
3904
3905
3906 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3907 PyObject *resultobj;
3908 char *kwnames[] = {
3909 NULL
3910 };
3911
3912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3913 {
3914 PyThreadState* __tstate = wxPyBeginAllowThreads();
3915 wxStartTimer();
3916
3917 wxPyEndAllowThreads(__tstate);
3918 if (PyErr_Occurred()) SWIG_fail;
3919 }
3920 Py_INCREF(Py_None); resultobj = Py_None;
3921 return resultobj;
3922 fail:
3923 return NULL;
3924 }
3925
3926
3927 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3928 PyObject *resultobj;
3929 int *arg1 = (int *) 0 ;
3930 int *arg2 = (int *) 0 ;
3931 int result;
3932 int temp1 ;
3933 int res1 = 0 ;
3934 int temp2 ;
3935 int res2 = 0 ;
3936 char *kwnames[] = {
3937 NULL
3938 };
3939
3940 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3941 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3943 {
3944 PyThreadState* __tstate = wxPyBeginAllowThreads();
3945 result = (int)wxGetOsVersion(arg1,arg2);
3946
3947 wxPyEndAllowThreads(__tstate);
3948 if (PyErr_Occurred()) SWIG_fail;
3949 }
3950 {
3951 resultobj = SWIG_From_int((int)(result));
3952 }
3953 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3954 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3955 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3956 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3957 return resultobj;
3958 fail:
3959 return NULL;
3960 }
3961
3962
3963 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3964 PyObject *resultobj;
3965 wxString result;
3966 char *kwnames[] = {
3967 NULL
3968 };
3969
3970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3971 {
3972 PyThreadState* __tstate = wxPyBeginAllowThreads();
3973 result = wxGetOsDescription();
3974
3975 wxPyEndAllowThreads(__tstate);
3976 if (PyErr_Occurred()) SWIG_fail;
3977 }
3978 {
3979 #if wxUSE_UNICODE
3980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3981 #else
3982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3983 #endif
3984 }
3985 return resultobj;
3986 fail:
3987 return NULL;
3988 }
3989
3990
3991 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3992 PyObject *resultobj;
3993 long result;
3994 char *kwnames[] = {
3995 NULL
3996 };
3997
3998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3999 {
4000 PyThreadState* __tstate = wxPyBeginAllowThreads();
4001 result = (long)wxGetFreeMemory();
4002
4003 wxPyEndAllowThreads(__tstate);
4004 if (PyErr_Occurred()) SWIG_fail;
4005 }
4006 {
4007 resultobj = SWIG_From_long((long)(result));
4008 }
4009 return resultobj;
4010 fail:
4011 return NULL;
4012 }
4013
4014
4015 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4016 PyObject *resultobj;
4017 wxShutdownFlags arg1 ;
4018 bool result;
4019 PyObject * obj0 = 0 ;
4020 char *kwnames[] = {
4021 (char *) "wFlags", NULL
4022 };
4023
4024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4025 {
4026 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4027 if (SWIG_arg_fail(1)) SWIG_fail;
4028 }
4029 {
4030 if (!wxPyCheckForApp()) SWIG_fail;
4031 PyThreadState* __tstate = wxPyBeginAllowThreads();
4032 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4033
4034 wxPyEndAllowThreads(__tstate);
4035 if (PyErr_Occurred()) SWIG_fail;
4036 }
4037 {
4038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4039 }
4040 return resultobj;
4041 fail:
4042 return NULL;
4043 }
4044
4045
4046 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4047 PyObject *resultobj;
4048 int arg1 ;
4049 PyObject * obj0 = 0 ;
4050 char *kwnames[] = {
4051 (char *) "secs", NULL
4052 };
4053
4054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4055 {
4056 arg1 = (int)(SWIG_As_int(obj0));
4057 if (SWIG_arg_fail(1)) SWIG_fail;
4058 }
4059 {
4060 PyThreadState* __tstate = wxPyBeginAllowThreads();
4061 wxSleep(arg1);
4062
4063 wxPyEndAllowThreads(__tstate);
4064 if (PyErr_Occurred()) SWIG_fail;
4065 }
4066 Py_INCREF(Py_None); resultobj = Py_None;
4067 return resultobj;
4068 fail:
4069 return NULL;
4070 }
4071
4072
4073 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4074 PyObject *resultobj;
4075 unsigned long arg1 ;
4076 PyObject * obj0 = 0 ;
4077 char *kwnames[] = {
4078 (char *) "milliseconds", NULL
4079 };
4080
4081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4082 {
4083 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4084 if (SWIG_arg_fail(1)) SWIG_fail;
4085 }
4086 {
4087 PyThreadState* __tstate = wxPyBeginAllowThreads();
4088 wxMilliSleep(arg1);
4089
4090 wxPyEndAllowThreads(__tstate);
4091 if (PyErr_Occurred()) SWIG_fail;
4092 }
4093 Py_INCREF(Py_None); resultobj = Py_None;
4094 return resultobj;
4095 fail:
4096 return NULL;
4097 }
4098
4099
4100 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj;
4102 unsigned long arg1 ;
4103 PyObject * obj0 = 0 ;
4104 char *kwnames[] = {
4105 (char *) "microseconds", NULL
4106 };
4107
4108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4109 {
4110 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4111 if (SWIG_arg_fail(1)) SWIG_fail;
4112 }
4113 {
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 wxMicroSleep(arg1);
4116
4117 wxPyEndAllowThreads(__tstate);
4118 if (PyErr_Occurred()) SWIG_fail;
4119 }
4120 Py_INCREF(Py_None); resultobj = Py_None;
4121 return resultobj;
4122 fail:
4123 return NULL;
4124 }
4125
4126
4127 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4128 PyObject *resultobj;
4129 bool arg1 ;
4130 PyObject * obj0 = 0 ;
4131 char *kwnames[] = {
4132 (char *) "enable", NULL
4133 };
4134
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4136 {
4137 arg1 = (bool)(SWIG_As_bool(obj0));
4138 if (SWIG_arg_fail(1)) SWIG_fail;
4139 }
4140 {
4141 PyThreadState* __tstate = wxPyBeginAllowThreads();
4142 wxEnableTopLevelWindows(arg1);
4143
4144 wxPyEndAllowThreads(__tstate);
4145 if (PyErr_Occurred()) SWIG_fail;
4146 }
4147 Py_INCREF(Py_None); resultobj = Py_None;
4148 return resultobj;
4149 fail:
4150 return NULL;
4151 }
4152
4153
4154 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4155 PyObject *resultobj;
4156 wxString *arg1 = 0 ;
4157 wxString result;
4158 bool temp1 = false ;
4159 PyObject * obj0 = 0 ;
4160 char *kwnames[] = {
4161 (char *) "in", NULL
4162 };
4163
4164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4165 {
4166 arg1 = wxString_in_helper(obj0);
4167 if (arg1 == NULL) SWIG_fail;
4168 temp1 = true;
4169 }
4170 {
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 result = wxStripMenuCodes((wxString const &)*arg1);
4173
4174 wxPyEndAllowThreads(__tstate);
4175 if (PyErr_Occurred()) SWIG_fail;
4176 }
4177 {
4178 #if wxUSE_UNICODE
4179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4180 #else
4181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4182 #endif
4183 }
4184 {
4185 if (temp1)
4186 delete arg1;
4187 }
4188 return resultobj;
4189 fail:
4190 {
4191 if (temp1)
4192 delete arg1;
4193 }
4194 return NULL;
4195 }
4196
4197
4198 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj;
4200 wxString result;
4201 char *kwnames[] = {
4202 NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4206 {
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 result = wxGetEmailAddress();
4209
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 {
4214 #if wxUSE_UNICODE
4215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4216 #else
4217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4218 #endif
4219 }
4220 return resultobj;
4221 fail:
4222 return NULL;
4223 }
4224
4225
4226 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4227 PyObject *resultobj;
4228 wxString result;
4229 char *kwnames[] = {
4230 NULL
4231 };
4232
4233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4234 {
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 result = wxGetHostName();
4237
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 {
4242 #if wxUSE_UNICODE
4243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4244 #else
4245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4246 #endif
4247 }
4248 return resultobj;
4249 fail:
4250 return NULL;
4251 }
4252
4253
4254 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4255 PyObject *resultobj;
4256 wxString result;
4257 char *kwnames[] = {
4258 NULL
4259 };
4260
4261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4262 {
4263 PyThreadState* __tstate = wxPyBeginAllowThreads();
4264 result = wxGetFullHostName();
4265
4266 wxPyEndAllowThreads(__tstate);
4267 if (PyErr_Occurred()) SWIG_fail;
4268 }
4269 {
4270 #if wxUSE_UNICODE
4271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4272 #else
4273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4274 #endif
4275 }
4276 return resultobj;
4277 fail:
4278 return NULL;
4279 }
4280
4281
4282 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4283 PyObject *resultobj;
4284 wxString result;
4285 char *kwnames[] = {
4286 NULL
4287 };
4288
4289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 result = wxGetUserId();
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 {
4298 #if wxUSE_UNICODE
4299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4300 #else
4301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4302 #endif
4303 }
4304 return resultobj;
4305 fail:
4306 return NULL;
4307 }
4308
4309
4310 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4311 PyObject *resultobj;
4312 wxString result;
4313 char *kwnames[] = {
4314 NULL
4315 };
4316
4317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4318 {
4319 PyThreadState* __tstate = wxPyBeginAllowThreads();
4320 result = wxGetUserName();
4321
4322 wxPyEndAllowThreads(__tstate);
4323 if (PyErr_Occurred()) SWIG_fail;
4324 }
4325 {
4326 #if wxUSE_UNICODE
4327 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4328 #else
4329 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4330 #endif
4331 }
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj;
4340 wxString result;
4341 char *kwnames[] = {
4342 NULL
4343 };
4344
4345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4346 {
4347 PyThreadState* __tstate = wxPyBeginAllowThreads();
4348 result = wxGetHomeDir();
4349
4350 wxPyEndAllowThreads(__tstate);
4351 if (PyErr_Occurred()) SWIG_fail;
4352 }
4353 {
4354 #if wxUSE_UNICODE
4355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4356 #else
4357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4358 #endif
4359 }
4360 return resultobj;
4361 fail:
4362 return NULL;
4363 }
4364
4365
4366 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4367 PyObject *resultobj;
4368 wxString const &arg1_defvalue = wxPyEmptyString ;
4369 wxString *arg1 = (wxString *) &arg1_defvalue ;
4370 wxString result;
4371 bool temp1 = false ;
4372 PyObject * obj0 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "user", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4378 if (obj0) {
4379 {
4380 arg1 = wxString_in_helper(obj0);
4381 if (arg1 == NULL) SWIG_fail;
4382 temp1 = true;
4383 }
4384 }
4385 {
4386 PyThreadState* __tstate = wxPyBeginAllowThreads();
4387 result = wxGetUserHome((wxString const &)*arg1);
4388
4389 wxPyEndAllowThreads(__tstate);
4390 if (PyErr_Occurred()) SWIG_fail;
4391 }
4392 {
4393 #if wxUSE_UNICODE
4394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4395 #else
4396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4397 #endif
4398 }
4399 {
4400 if (temp1)
4401 delete arg1;
4402 }
4403 return resultobj;
4404 fail:
4405 {
4406 if (temp1)
4407 delete arg1;
4408 }
4409 return NULL;
4410 }
4411
4412
4413 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4414 PyObject *resultobj;
4415 unsigned long result;
4416 char *kwnames[] = {
4417 NULL
4418 };
4419
4420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4421 {
4422 PyThreadState* __tstate = wxPyBeginAllowThreads();
4423 result = (unsigned long)wxGetProcessId();
4424
4425 wxPyEndAllowThreads(__tstate);
4426 if (PyErr_Occurred()) SWIG_fail;
4427 }
4428 {
4429 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4430 }
4431 return resultobj;
4432 fail:
4433 return NULL;
4434 }
4435
4436
4437 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4438 PyObject *resultobj;
4439 char *kwnames[] = {
4440 NULL
4441 };
4442
4443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4444 {
4445 PyThreadState* __tstate = wxPyBeginAllowThreads();
4446 wxTrap();
4447
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 Py_INCREF(Py_None); resultobj = Py_None;
4452 return resultobj;
4453 fail:
4454 return NULL;
4455 }
4456
4457
4458 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4459 PyObject *resultobj;
4460 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4461 wxString *arg1 = (wxString *) &arg1_defvalue ;
4462 wxString const &arg2_defvalue = wxPyEmptyString ;
4463 wxString *arg2 = (wxString *) &arg2_defvalue ;
4464 wxString const &arg3_defvalue = wxPyEmptyString ;
4465 wxString *arg3 = (wxString *) &arg3_defvalue ;
4466 wxString const &arg4_defvalue = wxPyEmptyString ;
4467 wxString *arg4 = (wxString *) &arg4_defvalue ;
4468 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4469 wxString *arg5 = (wxString *) &arg5_defvalue ;
4470 int arg6 = (int) 0 ;
4471 wxWindow *arg7 = (wxWindow *) NULL ;
4472 int arg8 = (int) -1 ;
4473 int arg9 = (int) -1 ;
4474 wxString result;
4475 bool temp1 = false ;
4476 bool temp2 = false ;
4477 bool temp3 = false ;
4478 bool temp4 = false ;
4479 bool temp5 = false ;
4480 PyObject * obj0 = 0 ;
4481 PyObject * obj1 = 0 ;
4482 PyObject * obj2 = 0 ;
4483 PyObject * obj3 = 0 ;
4484 PyObject * obj4 = 0 ;
4485 PyObject * obj5 = 0 ;
4486 PyObject * obj6 = 0 ;
4487 PyObject * obj7 = 0 ;
4488 PyObject * obj8 = 0 ;
4489 char *kwnames[] = {
4490 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4491 };
4492
4493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4494 if (obj0) {
4495 {
4496 arg1 = wxString_in_helper(obj0);
4497 if (arg1 == NULL) SWIG_fail;
4498 temp1 = true;
4499 }
4500 }
4501 if (obj1) {
4502 {
4503 arg2 = wxString_in_helper(obj1);
4504 if (arg2 == NULL) SWIG_fail;
4505 temp2 = true;
4506 }
4507 }
4508 if (obj2) {
4509 {
4510 arg3 = wxString_in_helper(obj2);
4511 if (arg3 == NULL) SWIG_fail;
4512 temp3 = true;
4513 }
4514 }
4515 if (obj3) {
4516 {
4517 arg4 = wxString_in_helper(obj3);
4518 if (arg4 == NULL) SWIG_fail;
4519 temp4 = true;
4520 }
4521 }
4522 if (obj4) {
4523 {
4524 arg5 = wxString_in_helper(obj4);
4525 if (arg5 == NULL) SWIG_fail;
4526 temp5 = true;
4527 }
4528 }
4529 if (obj5) {
4530 {
4531 arg6 = (int)(SWIG_As_int(obj5));
4532 if (SWIG_arg_fail(6)) SWIG_fail;
4533 }
4534 }
4535 if (obj6) {
4536 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4537 if (SWIG_arg_fail(7)) SWIG_fail;
4538 }
4539 if (obj7) {
4540 {
4541 arg8 = (int)(SWIG_As_int(obj7));
4542 if (SWIG_arg_fail(8)) SWIG_fail;
4543 }
4544 }
4545 if (obj8) {
4546 {
4547 arg9 = (int)(SWIG_As_int(obj8));
4548 if (SWIG_arg_fail(9)) SWIG_fail;
4549 }
4550 }
4551 {
4552 if (!wxPyCheckForApp()) SWIG_fail;
4553 PyThreadState* __tstate = wxPyBeginAllowThreads();
4554 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4555
4556 wxPyEndAllowThreads(__tstate);
4557 if (PyErr_Occurred()) SWIG_fail;
4558 }
4559 {
4560 #if wxUSE_UNICODE
4561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4562 #else
4563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4564 #endif
4565 }
4566 {
4567 if (temp1)
4568 delete arg1;
4569 }
4570 {
4571 if (temp2)
4572 delete arg2;
4573 }
4574 {
4575 if (temp3)
4576 delete arg3;
4577 }
4578 {
4579 if (temp4)
4580 delete arg4;
4581 }
4582 {
4583 if (temp5)
4584 delete arg5;
4585 }
4586 return resultobj;
4587 fail:
4588 {
4589 if (temp1)
4590 delete arg1;
4591 }
4592 {
4593 if (temp2)
4594 delete arg2;
4595 }
4596 {
4597 if (temp3)
4598 delete arg3;
4599 }
4600 {
4601 if (temp4)
4602 delete arg4;
4603 }
4604 {
4605 if (temp5)
4606 delete arg5;
4607 }
4608 return NULL;
4609 }
4610
4611
4612 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4613 PyObject *resultobj;
4614 wxString *arg1 = 0 ;
4615 wxString *arg2 = 0 ;
4616 wxString const &arg3_defvalue = wxPyEmptyString ;
4617 wxString *arg3 = (wxString *) &arg3_defvalue ;
4618 wxWindow *arg4 = (wxWindow *) NULL ;
4619 wxString result;
4620 bool temp1 = false ;
4621 bool temp2 = false ;
4622 bool temp3 = false ;
4623 PyObject * obj0 = 0 ;
4624 PyObject * obj1 = 0 ;
4625 PyObject * obj2 = 0 ;
4626 PyObject * obj3 = 0 ;
4627 char *kwnames[] = {
4628 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4629 };
4630
4631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4632 {
4633 arg1 = wxString_in_helper(obj0);
4634 if (arg1 == NULL) SWIG_fail;
4635 temp1 = true;
4636 }
4637 {
4638 arg2 = wxString_in_helper(obj1);
4639 if (arg2 == NULL) SWIG_fail;
4640 temp2 = true;
4641 }
4642 if (obj2) {
4643 {
4644 arg3 = wxString_in_helper(obj2);
4645 if (arg3 == NULL) SWIG_fail;
4646 temp3 = true;
4647 }
4648 }
4649 if (obj3) {
4650 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4651 if (SWIG_arg_fail(4)) SWIG_fail;
4652 }
4653 {
4654 if (!wxPyCheckForApp()) SWIG_fail;
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 {
4662 #if wxUSE_UNICODE
4663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4664 #else
4665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4666 #endif
4667 }
4668 {
4669 if (temp1)
4670 delete arg1;
4671 }
4672 {
4673 if (temp2)
4674 delete arg2;
4675 }
4676 {
4677 if (temp3)
4678 delete arg3;
4679 }
4680 return resultobj;
4681 fail:
4682 {
4683 if (temp1)
4684 delete arg1;
4685 }
4686 {
4687 if (temp2)
4688 delete arg2;
4689 }
4690 {
4691 if (temp3)
4692 delete arg3;
4693 }
4694 return NULL;
4695 }
4696
4697
4698 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4699 PyObject *resultobj;
4700 wxString *arg1 = 0 ;
4701 wxString *arg2 = 0 ;
4702 wxString const &arg3_defvalue = wxPyEmptyString ;
4703 wxString *arg3 = (wxString *) &arg3_defvalue ;
4704 wxWindow *arg4 = (wxWindow *) NULL ;
4705 wxString result;
4706 bool temp1 = false ;
4707 bool temp2 = false ;
4708 bool temp3 = false ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 PyObject * obj2 = 0 ;
4712 PyObject * obj3 = 0 ;
4713 char *kwnames[] = {
4714 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4715 };
4716
4717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4718 {
4719 arg1 = wxString_in_helper(obj0);
4720 if (arg1 == NULL) SWIG_fail;
4721 temp1 = true;
4722 }
4723 {
4724 arg2 = wxString_in_helper(obj1);
4725 if (arg2 == NULL) SWIG_fail;
4726 temp2 = true;
4727 }
4728 if (obj2) {
4729 {
4730 arg3 = wxString_in_helper(obj2);
4731 if (arg3 == NULL) SWIG_fail;
4732 temp3 = true;
4733 }
4734 }
4735 if (obj3) {
4736 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4737 if (SWIG_arg_fail(4)) SWIG_fail;
4738 }
4739 {
4740 if (!wxPyCheckForApp()) SWIG_fail;
4741 PyThreadState* __tstate = wxPyBeginAllowThreads();
4742 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4743
4744 wxPyEndAllowThreads(__tstate);
4745 if (PyErr_Occurred()) SWIG_fail;
4746 }
4747 {
4748 #if wxUSE_UNICODE
4749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4750 #else
4751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4752 #endif
4753 }
4754 {
4755 if (temp1)
4756 delete arg1;
4757 }
4758 {
4759 if (temp2)
4760 delete arg2;
4761 }
4762 {
4763 if (temp3)
4764 delete arg3;
4765 }
4766 return resultobj;
4767 fail:
4768 {
4769 if (temp1)
4770 delete arg1;
4771 }
4772 {
4773 if (temp2)
4774 delete arg2;
4775 }
4776 {
4777 if (temp3)
4778 delete arg3;
4779 }
4780 return NULL;
4781 }
4782
4783
4784 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj;
4786 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4787 wxString *arg1 = (wxString *) &arg1_defvalue ;
4788 wxString const &arg2_defvalue = wxPyEmptyString ;
4789 wxString *arg2 = (wxString *) &arg2_defvalue ;
4790 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4791 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4792 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4793 wxWindow *arg5 = (wxWindow *) NULL ;
4794 wxString result;
4795 bool temp1 = false ;
4796 bool temp2 = false ;
4797 wxPoint temp4 ;
4798 PyObject * obj0 = 0 ;
4799 PyObject * obj1 = 0 ;
4800 PyObject * obj2 = 0 ;
4801 PyObject * obj3 = 0 ;
4802 PyObject * obj4 = 0 ;
4803 char *kwnames[] = {
4804 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4805 };
4806
4807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4808 if (obj0) {
4809 {
4810 arg1 = wxString_in_helper(obj0);
4811 if (arg1 == NULL) SWIG_fail;
4812 temp1 = true;
4813 }
4814 }
4815 if (obj1) {
4816 {
4817 arg2 = wxString_in_helper(obj1);
4818 if (arg2 == NULL) SWIG_fail;
4819 temp2 = true;
4820 }
4821 }
4822 if (obj2) {
4823 {
4824 arg3 = (long)(SWIG_As_long(obj2));
4825 if (SWIG_arg_fail(3)) SWIG_fail;
4826 }
4827 }
4828 if (obj3) {
4829 {
4830 arg4 = &temp4;
4831 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4832 }
4833 }
4834 if (obj4) {
4835 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4836 if (SWIG_arg_fail(5)) SWIG_fail;
4837 }
4838 {
4839 if (!wxPyCheckForApp()) SWIG_fail;
4840 PyThreadState* __tstate = wxPyBeginAllowThreads();
4841 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4842
4843 wxPyEndAllowThreads(__tstate);
4844 if (PyErr_Occurred()) SWIG_fail;
4845 }
4846 {
4847 #if wxUSE_UNICODE
4848 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4849 #else
4850 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4851 #endif
4852 }
4853 {
4854 if (temp1)
4855 delete arg1;
4856 }
4857 {
4858 if (temp2)
4859 delete arg2;
4860 }
4861 return resultobj;
4862 fail:
4863 {
4864 if (temp1)
4865 delete arg1;
4866 }
4867 {
4868 if (temp2)
4869 delete arg2;
4870 }
4871 return NULL;
4872 }
4873
4874
4875 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4876 PyObject *resultobj;
4877 wxString *arg1 = 0 ;
4878 wxString const &arg2_defvalue = wxPyEmptyString ;
4879 wxString *arg2 = (wxString *) &arg2_defvalue ;
4880 wxString const &arg3_defvalue = wxPyEmptyString ;
4881 wxString *arg3 = (wxString *) &arg3_defvalue ;
4882 wxWindow *arg4 = (wxWindow *) NULL ;
4883 int arg5 = (int) -1 ;
4884 int arg6 = (int) -1 ;
4885 bool arg7 = (bool) true ;
4886 wxString result;
4887 bool temp1 = false ;
4888 bool temp2 = false ;
4889 bool temp3 = false ;
4890 PyObject * obj0 = 0 ;
4891 PyObject * obj1 = 0 ;
4892 PyObject * obj2 = 0 ;
4893 PyObject * obj3 = 0 ;
4894 PyObject * obj4 = 0 ;
4895 PyObject * obj5 = 0 ;
4896 PyObject * obj6 = 0 ;
4897 char *kwnames[] = {
4898 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4899 };
4900
4901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4902 {
4903 arg1 = wxString_in_helper(obj0);
4904 if (arg1 == NULL) SWIG_fail;
4905 temp1 = true;
4906 }
4907 if (obj1) {
4908 {
4909 arg2 = wxString_in_helper(obj1);
4910 if (arg2 == NULL) SWIG_fail;
4911 temp2 = true;
4912 }
4913 }
4914 if (obj2) {
4915 {
4916 arg3 = wxString_in_helper(obj2);
4917 if (arg3 == NULL) SWIG_fail;
4918 temp3 = true;
4919 }
4920 }
4921 if (obj3) {
4922 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4923 if (SWIG_arg_fail(4)) SWIG_fail;
4924 }
4925 if (obj4) {
4926 {
4927 arg5 = (int)(SWIG_As_int(obj4));
4928 if (SWIG_arg_fail(5)) SWIG_fail;
4929 }
4930 }
4931 if (obj5) {
4932 {
4933 arg6 = (int)(SWIG_As_int(obj5));
4934 if (SWIG_arg_fail(6)) SWIG_fail;
4935 }
4936 }
4937 if (obj6) {
4938 {
4939 arg7 = (bool)(SWIG_As_bool(obj6));
4940 if (SWIG_arg_fail(7)) SWIG_fail;
4941 }
4942 }
4943 {
4944 if (!wxPyCheckForApp()) SWIG_fail;
4945 PyThreadState* __tstate = wxPyBeginAllowThreads();
4946 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4947
4948 wxPyEndAllowThreads(__tstate);
4949 if (PyErr_Occurred()) SWIG_fail;
4950 }
4951 {
4952 #if wxUSE_UNICODE
4953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4954 #else
4955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4956 #endif
4957 }
4958 {
4959 if (temp1)
4960 delete arg1;
4961 }
4962 {
4963 if (temp2)
4964 delete arg2;
4965 }
4966 {
4967 if (temp3)
4968 delete arg3;
4969 }
4970 return resultobj;
4971 fail:
4972 {
4973 if (temp1)
4974 delete arg1;
4975 }
4976 {
4977 if (temp2)
4978 delete arg2;
4979 }
4980 {
4981 if (temp3)
4982 delete arg3;
4983 }
4984 return NULL;
4985 }
4986
4987
4988 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4989 PyObject *resultobj;
4990 wxString *arg1 = 0 ;
4991 wxString const &arg2_defvalue = wxPyEmptyString ;
4992 wxString *arg2 = (wxString *) &arg2_defvalue ;
4993 wxString const &arg3_defvalue = wxPyEmptyString ;
4994 wxString *arg3 = (wxString *) &arg3_defvalue ;
4995 wxWindow *arg4 = (wxWindow *) NULL ;
4996 wxString result;
4997 bool temp1 = false ;
4998 bool temp2 = false ;
4999 bool temp3 = false ;
5000 PyObject * obj0 = 0 ;
5001 PyObject * obj1 = 0 ;
5002 PyObject * obj2 = 0 ;
5003 PyObject * obj3 = 0 ;
5004 char *kwnames[] = {
5005 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5006 };
5007
5008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5009 {
5010 arg1 = wxString_in_helper(obj0);
5011 if (arg1 == NULL) SWIG_fail;
5012 temp1 = true;
5013 }
5014 if (obj1) {
5015 {
5016 arg2 = wxString_in_helper(obj1);
5017 if (arg2 == NULL) SWIG_fail;
5018 temp2 = true;
5019 }
5020 }
5021 if (obj2) {
5022 {
5023 arg3 = wxString_in_helper(obj2);
5024 if (arg3 == NULL) SWIG_fail;
5025 temp3 = true;
5026 }
5027 }
5028 if (obj3) {
5029 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5030 if (SWIG_arg_fail(4)) SWIG_fail;
5031 }
5032 {
5033 if (!wxPyCheckForApp()) SWIG_fail;
5034 PyThreadState* __tstate = wxPyBeginAllowThreads();
5035 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5036
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 {
5041 #if wxUSE_UNICODE
5042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5043 #else
5044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5045 #endif
5046 }
5047 {
5048 if (temp1)
5049 delete arg1;
5050 }
5051 {
5052 if (temp2)
5053 delete arg2;
5054 }
5055 {
5056 if (temp3)
5057 delete arg3;
5058 }
5059 return resultobj;
5060 fail:
5061 {
5062 if (temp1)
5063 delete arg1;
5064 }
5065 {
5066 if (temp2)
5067 delete arg2;
5068 }
5069 {
5070 if (temp3)
5071 delete arg3;
5072 }
5073 return NULL;
5074 }
5075
5076
5077 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5078 PyObject *resultobj;
5079 wxString *arg1 = 0 ;
5080 wxString *arg2 = 0 ;
5081 int arg3 ;
5082 wxString *arg4 = (wxString *) 0 ;
5083 wxWindow *arg5 = (wxWindow *) NULL ;
5084 int arg6 = (int) -1 ;
5085 int arg7 = (int) -1 ;
5086 bool arg8 = (bool) true ;
5087 int arg9 = (int) 150 ;
5088 int arg10 = (int) 200 ;
5089 wxString result;
5090 bool temp1 = false ;
5091 bool temp2 = false ;
5092 PyObject * obj0 = 0 ;
5093 PyObject * obj1 = 0 ;
5094 PyObject * obj2 = 0 ;
5095 PyObject * obj3 = 0 ;
5096 PyObject * obj4 = 0 ;
5097 PyObject * obj5 = 0 ;
5098 PyObject * obj6 = 0 ;
5099 PyObject * obj7 = 0 ;
5100 PyObject * obj8 = 0 ;
5101 char *kwnames[] = {
5102 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5103 };
5104
5105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5106 {
5107 arg1 = wxString_in_helper(obj0);
5108 if (arg1 == NULL) SWIG_fail;
5109 temp1 = true;
5110 }
5111 {
5112 arg2 = wxString_in_helper(obj1);
5113 if (arg2 == NULL) SWIG_fail;
5114 temp2 = true;
5115 }
5116 {
5117 arg3 = PyList_Size(obj2);
5118 arg4 = wxString_LIST_helper(obj2);
5119 if (arg4 == NULL) SWIG_fail;
5120 }
5121 if (obj3) {
5122 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5123 if (SWIG_arg_fail(5)) SWIG_fail;
5124 }
5125 if (obj4) {
5126 {
5127 arg6 = (int)(SWIG_As_int(obj4));
5128 if (SWIG_arg_fail(6)) SWIG_fail;
5129 }
5130 }
5131 if (obj5) {
5132 {
5133 arg7 = (int)(SWIG_As_int(obj5));
5134 if (SWIG_arg_fail(7)) SWIG_fail;
5135 }
5136 }
5137 if (obj6) {
5138 {
5139 arg8 = (bool)(SWIG_As_bool(obj6));
5140 if (SWIG_arg_fail(8)) SWIG_fail;
5141 }
5142 }
5143 if (obj7) {
5144 {
5145 arg9 = (int)(SWIG_As_int(obj7));
5146 if (SWIG_arg_fail(9)) SWIG_fail;
5147 }
5148 }
5149 if (obj8) {
5150 {
5151 arg10 = (int)(SWIG_As_int(obj8));
5152 if (SWIG_arg_fail(10)) SWIG_fail;
5153 }
5154 }
5155 {
5156 if (!wxPyCheckForApp()) SWIG_fail;
5157 PyThreadState* __tstate = wxPyBeginAllowThreads();
5158 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5159
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 {
5164 #if wxUSE_UNICODE
5165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5166 #else
5167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5168 #endif
5169 }
5170 {
5171 if (temp1)
5172 delete arg1;
5173 }
5174 {
5175 if (temp2)
5176 delete arg2;
5177 }
5178 {
5179 if (arg4) delete [] arg4;
5180 }
5181 return resultobj;
5182 fail:
5183 {
5184 if (temp1)
5185 delete arg1;
5186 }
5187 {
5188 if (temp2)
5189 delete arg2;
5190 }
5191 {
5192 if (arg4) delete [] arg4;
5193 }
5194 return NULL;
5195 }
5196
5197
5198 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5199 PyObject *resultobj;
5200 wxString *arg1 = 0 ;
5201 wxString *arg2 = 0 ;
5202 int arg3 ;
5203 wxString *arg4 = (wxString *) 0 ;
5204 wxWindow *arg5 = (wxWindow *) NULL ;
5205 int arg6 = (int) -1 ;
5206 int arg7 = (int) -1 ;
5207 bool arg8 = (bool) true ;
5208 int arg9 = (int) 150 ;
5209 int arg10 = (int) 200 ;
5210 int result;
5211 bool temp1 = false ;
5212 bool temp2 = false ;
5213 PyObject * obj0 = 0 ;
5214 PyObject * obj1 = 0 ;
5215 PyObject * obj2 = 0 ;
5216 PyObject * obj3 = 0 ;
5217 PyObject * obj4 = 0 ;
5218 PyObject * obj5 = 0 ;
5219 PyObject * obj6 = 0 ;
5220 PyObject * obj7 = 0 ;
5221 PyObject * obj8 = 0 ;
5222 char *kwnames[] = {
5223 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5224 };
5225
5226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5227 {
5228 arg1 = wxString_in_helper(obj0);
5229 if (arg1 == NULL) SWIG_fail;
5230 temp1 = true;
5231 }
5232 {
5233 arg2 = wxString_in_helper(obj1);
5234 if (arg2 == NULL) SWIG_fail;
5235 temp2 = true;
5236 }
5237 {
5238 arg3 = PyList_Size(obj2);
5239 arg4 = wxString_LIST_helper(obj2);
5240 if (arg4 == NULL) SWIG_fail;
5241 }
5242 if (obj3) {
5243 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5244 if (SWIG_arg_fail(5)) SWIG_fail;
5245 }
5246 if (obj4) {
5247 {
5248 arg6 = (int)(SWIG_As_int(obj4));
5249 if (SWIG_arg_fail(6)) SWIG_fail;
5250 }
5251 }
5252 if (obj5) {
5253 {
5254 arg7 = (int)(SWIG_As_int(obj5));
5255 if (SWIG_arg_fail(7)) SWIG_fail;
5256 }
5257 }
5258 if (obj6) {
5259 {
5260 arg8 = (bool)(SWIG_As_bool(obj6));
5261 if (SWIG_arg_fail(8)) SWIG_fail;
5262 }
5263 }
5264 if (obj7) {
5265 {
5266 arg9 = (int)(SWIG_As_int(obj7));
5267 if (SWIG_arg_fail(9)) SWIG_fail;
5268 }
5269 }
5270 if (obj8) {
5271 {
5272 arg10 = (int)(SWIG_As_int(obj8));
5273 if (SWIG_arg_fail(10)) SWIG_fail;
5274 }
5275 }
5276 {
5277 if (!wxPyCheckForApp()) SWIG_fail;
5278 PyThreadState* __tstate = wxPyBeginAllowThreads();
5279 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5280
5281 wxPyEndAllowThreads(__tstate);
5282 if (PyErr_Occurred()) SWIG_fail;
5283 }
5284 {
5285 resultobj = SWIG_From_int((int)(result));
5286 }
5287 {
5288 if (temp1)
5289 delete arg1;
5290 }
5291 {
5292 if (temp2)
5293 delete arg2;
5294 }
5295 {
5296 if (arg4) delete [] arg4;
5297 }
5298 return resultobj;
5299 fail:
5300 {
5301 if (temp1)
5302 delete arg1;
5303 }
5304 {
5305 if (temp2)
5306 delete arg2;
5307 }
5308 {
5309 if (arg4) delete [] arg4;
5310 }
5311 return NULL;
5312 }
5313
5314
5315 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5316 PyObject *resultobj;
5317 wxString *arg1 = 0 ;
5318 wxString const &arg2_defvalue = wxPyEmptyString ;
5319 wxString *arg2 = (wxString *) &arg2_defvalue ;
5320 int arg3 = (int) wxOK|wxCENTRE ;
5321 wxWindow *arg4 = (wxWindow *) NULL ;
5322 int arg5 = (int) -1 ;
5323 int arg6 = (int) -1 ;
5324 int result;
5325 bool temp1 = false ;
5326 bool temp2 = false ;
5327 PyObject * obj0 = 0 ;
5328 PyObject * obj1 = 0 ;
5329 PyObject * obj2 = 0 ;
5330 PyObject * obj3 = 0 ;
5331 PyObject * obj4 = 0 ;
5332 PyObject * obj5 = 0 ;
5333 char *kwnames[] = {
5334 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5335 };
5336
5337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5338 {
5339 arg1 = wxString_in_helper(obj0);
5340 if (arg1 == NULL) SWIG_fail;
5341 temp1 = true;
5342 }
5343 if (obj1) {
5344 {
5345 arg2 = wxString_in_helper(obj1);
5346 if (arg2 == NULL) SWIG_fail;
5347 temp2 = true;
5348 }
5349 }
5350 if (obj2) {
5351 {
5352 arg3 = (int)(SWIG_As_int(obj2));
5353 if (SWIG_arg_fail(3)) SWIG_fail;
5354 }
5355 }
5356 if (obj3) {
5357 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5358 if (SWIG_arg_fail(4)) SWIG_fail;
5359 }
5360 if (obj4) {
5361 {
5362 arg5 = (int)(SWIG_As_int(obj4));
5363 if (SWIG_arg_fail(5)) SWIG_fail;
5364 }
5365 }
5366 if (obj5) {
5367 {
5368 arg6 = (int)(SWIG_As_int(obj5));
5369 if (SWIG_arg_fail(6)) SWIG_fail;
5370 }
5371 }
5372 {
5373 if (!wxPyCheckForApp()) SWIG_fail;
5374 PyThreadState* __tstate = wxPyBeginAllowThreads();
5375 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5376
5377 wxPyEndAllowThreads(__tstate);
5378 if (PyErr_Occurred()) SWIG_fail;
5379 }
5380 {
5381 resultobj = SWIG_From_int((int)(result));
5382 }
5383 {
5384 if (temp1)
5385 delete arg1;
5386 }
5387 {
5388 if (temp2)
5389 delete arg2;
5390 }
5391 return resultobj;
5392 fail:
5393 {
5394 if (temp1)
5395 delete arg1;
5396 }
5397 {
5398 if (temp2)
5399 delete arg2;
5400 }
5401 return NULL;
5402 }
5403
5404
5405 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5406 PyObject *resultobj;
5407 wxString *arg1 = 0 ;
5408 wxString *arg2 = 0 ;
5409 wxString *arg3 = 0 ;
5410 long arg4 ;
5411 long arg5 = (long) 0 ;
5412 long arg6 = (long) 100 ;
5413 wxWindow *arg7 = (wxWindow *) NULL ;
5414 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5415 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5416 long result;
5417 bool temp1 = false ;
5418 bool temp2 = false ;
5419 bool temp3 = false ;
5420 wxPoint temp8 ;
5421 PyObject * obj0 = 0 ;
5422 PyObject * obj1 = 0 ;
5423 PyObject * obj2 = 0 ;
5424 PyObject * obj3 = 0 ;
5425 PyObject * obj4 = 0 ;
5426 PyObject * obj5 = 0 ;
5427 PyObject * obj6 = 0 ;
5428 PyObject * obj7 = 0 ;
5429 char *kwnames[] = {
5430 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5431 };
5432
5433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5434 {
5435 arg1 = wxString_in_helper(obj0);
5436 if (arg1 == NULL) SWIG_fail;
5437 temp1 = true;
5438 }
5439 {
5440 arg2 = wxString_in_helper(obj1);
5441 if (arg2 == NULL) SWIG_fail;
5442 temp2 = true;
5443 }
5444 {
5445 arg3 = wxString_in_helper(obj2);
5446 if (arg3 == NULL) SWIG_fail;
5447 temp3 = true;
5448 }
5449 {
5450 arg4 = (long)(SWIG_As_long(obj3));
5451 if (SWIG_arg_fail(4)) SWIG_fail;
5452 }
5453 if (obj4) {
5454 {
5455 arg5 = (long)(SWIG_As_long(obj4));
5456 if (SWIG_arg_fail(5)) SWIG_fail;
5457 }
5458 }
5459 if (obj5) {
5460 {
5461 arg6 = (long)(SWIG_As_long(obj5));
5462 if (SWIG_arg_fail(6)) SWIG_fail;
5463 }
5464 }
5465 if (obj6) {
5466 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5467 if (SWIG_arg_fail(7)) SWIG_fail;
5468 }
5469 if (obj7) {
5470 {
5471 arg8 = &temp8;
5472 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5473 }
5474 }
5475 {
5476 if (!wxPyCheckForApp()) SWIG_fail;
5477 PyThreadState* __tstate = wxPyBeginAllowThreads();
5478 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5479
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 {
5484 resultobj = SWIG_From_long((long)(result));
5485 }
5486 {
5487 if (temp1)
5488 delete arg1;
5489 }
5490 {
5491 if (temp2)
5492 delete arg2;
5493 }
5494 {
5495 if (temp3)
5496 delete arg3;
5497 }
5498 return resultobj;
5499 fail:
5500 {
5501 if (temp1)
5502 delete arg1;
5503 }
5504 {
5505 if (temp2)
5506 delete arg2;
5507 }
5508 {
5509 if (temp3)
5510 delete arg3;
5511 }
5512 return NULL;
5513 }
5514
5515
5516 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj;
5518 bool result;
5519 char *kwnames[] = {
5520 NULL
5521 };
5522
5523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5524 {
5525 if (!wxPyCheckForApp()) SWIG_fail;
5526 PyThreadState* __tstate = wxPyBeginAllowThreads();
5527 result = (bool)wxColourDisplay();
5528
5529 wxPyEndAllowThreads(__tstate);
5530 if (PyErr_Occurred()) SWIG_fail;
5531 }
5532 {
5533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5534 }
5535 return resultobj;
5536 fail:
5537 return NULL;
5538 }
5539
5540
5541 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5542 PyObject *resultobj;
5543 int result;
5544 char *kwnames[] = {
5545 NULL
5546 };
5547
5548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5549 {
5550 if (!wxPyCheckForApp()) SWIG_fail;
5551 PyThreadState* __tstate = wxPyBeginAllowThreads();
5552 result = (int)wxDisplayDepth();
5553
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 {
5558 resultobj = SWIG_From_int((int)(result));
5559 }
5560 return resultobj;
5561 fail:
5562 return NULL;
5563 }
5564
5565
5566 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5567 PyObject *resultobj;
5568 int result;
5569 char *kwnames[] = {
5570 NULL
5571 };
5572
5573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5574 {
5575 if (!wxPyCheckForApp()) SWIG_fail;
5576 PyThreadState* __tstate = wxPyBeginAllowThreads();
5577 result = (int)wxGetDisplayDepth();
5578
5579 wxPyEndAllowThreads(__tstate);
5580 if (PyErr_Occurred()) SWIG_fail;
5581 }
5582 {
5583 resultobj = SWIG_From_int((int)(result));
5584 }
5585 return resultobj;
5586 fail:
5587 return NULL;
5588 }
5589
5590
5591 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5592 PyObject *resultobj;
5593 int *arg1 = (int *) 0 ;
5594 int *arg2 = (int *) 0 ;
5595 int temp1 ;
5596 int res1 = 0 ;
5597 int temp2 ;
5598 int res2 = 0 ;
5599 char *kwnames[] = {
5600 NULL
5601 };
5602
5603 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5604 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5606 {
5607 if (!wxPyCheckForApp()) SWIG_fail;
5608 PyThreadState* __tstate = wxPyBeginAllowThreads();
5609 wxDisplaySize(arg1,arg2);
5610
5611 wxPyEndAllowThreads(__tstate);
5612 if (PyErr_Occurred()) SWIG_fail;
5613 }
5614 Py_INCREF(Py_None); resultobj = Py_None;
5615 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5616 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5617 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5618 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5619 return resultobj;
5620 fail:
5621 return NULL;
5622 }
5623
5624
5625 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5626 PyObject *resultobj;
5627 wxSize result;
5628 char *kwnames[] = {
5629 NULL
5630 };
5631
5632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5633 {
5634 if (!wxPyCheckForApp()) SWIG_fail;
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = wxGetDisplaySize();
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 wxSize * resultptr;
5643 resultptr = new wxSize((wxSize &)(result));
5644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5645 }
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5653 PyObject *resultobj;
5654 int *arg1 = (int *) 0 ;
5655 int *arg2 = (int *) 0 ;
5656 int temp1 ;
5657 int res1 = 0 ;
5658 int temp2 ;
5659 int res2 = 0 ;
5660 char *kwnames[] = {
5661 NULL
5662 };
5663
5664 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5665 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5667 {
5668 if (!wxPyCheckForApp()) SWIG_fail;
5669 PyThreadState* __tstate = wxPyBeginAllowThreads();
5670 wxDisplaySizeMM(arg1,arg2);
5671
5672 wxPyEndAllowThreads(__tstate);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 Py_INCREF(Py_None); resultobj = Py_None;
5676 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5677 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5678 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5679 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5687 PyObject *resultobj;
5688 wxSize result;
5689 char *kwnames[] = {
5690 NULL
5691 };
5692
5693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5694 {
5695 if (!wxPyCheckForApp()) SWIG_fail;
5696 PyThreadState* __tstate = wxPyBeginAllowThreads();
5697 result = wxGetDisplaySizeMM();
5698
5699 wxPyEndAllowThreads(__tstate);
5700 if (PyErr_Occurred()) SWIG_fail;
5701 }
5702 {
5703 wxSize * resultptr;
5704 resultptr = new wxSize((wxSize &)(result));
5705 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5706 }
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5714 PyObject *resultobj;
5715 int *arg1 = (int *) 0 ;
5716 int *arg2 = (int *) 0 ;
5717 int *arg3 = (int *) 0 ;
5718 int *arg4 = (int *) 0 ;
5719 int temp1 ;
5720 int res1 = 0 ;
5721 int temp2 ;
5722 int res2 = 0 ;
5723 int temp3 ;
5724 int res3 = 0 ;
5725 int temp4 ;
5726 int res4 = 0 ;
5727 char *kwnames[] = {
5728 NULL
5729 };
5730
5731 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5732 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5733 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5734 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5736 {
5737 if (!wxPyCheckForApp()) SWIG_fail;
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5740
5741 wxPyEndAllowThreads(__tstate);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 Py_INCREF(Py_None); resultobj = Py_None;
5745 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5746 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5747 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5748 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5749 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5750 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5751 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5752 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5753 return resultobj;
5754 fail:
5755 return NULL;
5756 }
5757
5758
5759 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5760 PyObject *resultobj;
5761 wxRect result;
5762 char *kwnames[] = {
5763 NULL
5764 };
5765
5766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5767 {
5768 if (!wxPyCheckForApp()) SWIG_fail;
5769 PyThreadState* __tstate = wxPyBeginAllowThreads();
5770 result = wxGetClientDisplayRect();
5771
5772 wxPyEndAllowThreads(__tstate);
5773 if (PyErr_Occurred()) SWIG_fail;
5774 }
5775 {
5776 wxRect * resultptr;
5777 resultptr = new wxRect((wxRect &)(result));
5778 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5779 }
5780 return resultobj;
5781 fail:
5782 return NULL;
5783 }
5784
5785
5786 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5787 PyObject *resultobj;
5788 wxCursor *arg1 = 0 ;
5789 PyObject * obj0 = 0 ;
5790 char *kwnames[] = {
5791 (char *) "cursor", NULL
5792 };
5793
5794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5795 {
5796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5797 if (SWIG_arg_fail(1)) SWIG_fail;
5798 if (arg1 == NULL) {
5799 SWIG_null_ref("wxCursor");
5800 }
5801 if (SWIG_arg_fail(1)) SWIG_fail;
5802 }
5803 {
5804 if (!wxPyCheckForApp()) SWIG_fail;
5805 PyThreadState* __tstate = wxPyBeginAllowThreads();
5806 wxSetCursor(*arg1);
5807
5808 wxPyEndAllowThreads(__tstate);
5809 if (PyErr_Occurred()) SWIG_fail;
5810 }
5811 Py_INCREF(Py_None); resultobj = Py_None;
5812 return resultobj;
5813 fail:
5814 return NULL;
5815 }
5816
5817
5818 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5819 PyObject *resultobj;
5820 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5821 PyObject * obj0 = 0 ;
5822 char *kwnames[] = {
5823 (char *) "cursor", NULL
5824 };
5825
5826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5827 if (obj0) {
5828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5829 if (SWIG_arg_fail(1)) SWIG_fail;
5830 }
5831 {
5832 if (!wxPyCheckForApp()) SWIG_fail;
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 wxBeginBusyCursor(arg1);
5835
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 Py_INCREF(Py_None); resultobj = Py_None;
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj;
5848 wxWindow *result;
5849 char *kwnames[] = {
5850 NULL
5851 };
5852
5853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5854 {
5855 if (!wxPyCheckForApp()) SWIG_fail;
5856 PyThreadState* __tstate = wxPyBeginAllowThreads();
5857 result = (wxWindow *)wxGetActiveWindow();
5858
5859 wxPyEndAllowThreads(__tstate);
5860 if (PyErr_Occurred()) SWIG_fail;
5861 }
5862 {
5863 resultobj = wxPyMake_wxObject(result, 0);
5864 }
5865 return resultobj;
5866 fail:
5867 return NULL;
5868 }
5869
5870
5871 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5872 PyObject *resultobj;
5873 wxPoint *arg1 = 0 ;
5874 wxWindow *result;
5875 wxPoint temp1 ;
5876 PyObject * obj0 = 0 ;
5877 char *kwnames[] = {
5878 (char *) "pt", NULL
5879 };
5880
5881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5882 {
5883 arg1 = &temp1;
5884 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5885 }
5886 {
5887 if (!wxPyCheckForApp()) SWIG_fail;
5888 PyThreadState* __tstate = wxPyBeginAllowThreads();
5889 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5890
5891 wxPyEndAllowThreads(__tstate);
5892 if (PyErr_Occurred()) SWIG_fail;
5893 }
5894 {
5895 resultobj = wxPyMake_wxObject(result, 0);
5896 }
5897 return resultobj;
5898 fail:
5899 return NULL;
5900 }
5901
5902
5903 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5904 PyObject *resultobj;
5905 wxPoint *arg1 = 0 ;
5906 wxWindow *result;
5907 wxPoint temp1 ;
5908 PyObject * obj0 = 0 ;
5909 char *kwnames[] = {
5910 (char *) "pt", NULL
5911 };
5912
5913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5914 {
5915 arg1 = &temp1;
5916 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5917 }
5918 {
5919 if (!wxPyCheckForApp()) SWIG_fail;
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5922
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 {
5927 resultobj = wxPyMake_wxObject(result, 0);
5928 }
5929 return resultobj;
5930 fail:
5931 return NULL;
5932 }
5933
5934
5935 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5936 PyObject *resultobj;
5937 wxWindow *arg1 = (wxWindow *) 0 ;
5938 wxWindow *result;
5939 PyObject * obj0 = 0 ;
5940 char *kwnames[] = {
5941 (char *) "win", NULL
5942 };
5943
5944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5946 if (SWIG_arg_fail(1)) SWIG_fail;
5947 {
5948 if (!wxPyCheckForApp()) SWIG_fail;
5949 PyThreadState* __tstate = wxPyBeginAllowThreads();
5950 result = (wxWindow *)wxGetTopLevelParent(arg1);
5951
5952 wxPyEndAllowThreads(__tstate);
5953 if (PyErr_Occurred()) SWIG_fail;
5954 }
5955 {
5956 resultobj = wxPyMake_wxObject(result, 0);
5957 }
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj;
5966 wxKeyCode arg1 ;
5967 bool result;
5968 PyObject * obj0 = 0 ;
5969 char *kwnames[] = {
5970 (char *) "key", NULL
5971 };
5972
5973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5974 {
5975 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5976 if (SWIG_arg_fail(1)) SWIG_fail;
5977 }
5978 {
5979 if (!wxPyCheckForApp()) SWIG_fail;
5980 PyThreadState* __tstate = wxPyBeginAllowThreads();
5981 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5982
5983 wxPyEndAllowThreads(__tstate);
5984 if (PyErr_Occurred()) SWIG_fail;
5985 }
5986 {
5987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5988 }
5989 return resultobj;
5990 fail:
5991 return NULL;
5992 }
5993
5994
5995 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5996 PyObject *resultobj;
5997 char *kwnames[] = {
5998 NULL
5999 };
6000
6001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6002 {
6003 if (!wxPyCheckForApp()) SWIG_fail;
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 wxWakeUpMainThread();
6006
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 Py_INCREF(Py_None); resultobj = Py_None;
6011 return resultobj;
6012 fail:
6013 return NULL;
6014 }
6015
6016
6017 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6018 PyObject *resultobj;
6019 char *kwnames[] = {
6020 NULL
6021 };
6022
6023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6024 {
6025 if (!wxPyCheckForApp()) SWIG_fail;
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 wxMutexGuiEnter();
6028
6029 wxPyEndAllowThreads(__tstate);
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 Py_INCREF(Py_None); resultobj = Py_None;
6033 return resultobj;
6034 fail:
6035 return NULL;
6036 }
6037
6038
6039 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6040 PyObject *resultobj;
6041 char *kwnames[] = {
6042 NULL
6043 };
6044
6045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6046 {
6047 if (!wxPyCheckForApp()) SWIG_fail;
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 wxMutexGuiLeave();
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 *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6062 PyObject *resultobj;
6063 wxMutexGuiLocker *result;
6064 char *kwnames[] = {
6065 NULL
6066 };
6067
6068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6069 {
6070 if (!wxPyCheckForApp()) SWIG_fail;
6071 PyThreadState* __tstate = wxPyBeginAllowThreads();
6072 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6073
6074 wxPyEndAllowThreads(__tstate);
6075 if (PyErr_Occurred()) SWIG_fail;
6076 }
6077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj;
6086 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6087 PyObject * obj0 = 0 ;
6088 char *kwnames[] = {
6089 (char *) "self", NULL
6090 };
6091
6092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6094 if (SWIG_arg_fail(1)) SWIG_fail;
6095 {
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 delete arg1;
6098
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 Py_INCREF(Py_None); resultobj = Py_None;
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6110 PyObject *obj;
6111 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6112 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6113 Py_INCREF(obj);
6114 return Py_BuildValue((char *)"");
6115 }
6116 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj;
6118 bool result;
6119 char *kwnames[] = {
6120 NULL
6121 };
6122
6123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6124 {
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (bool)wxThread_IsMain();
6127
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 {
6132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6133 }
6134 return resultobj;
6135 fail:
6136 return NULL;
6137 }
6138
6139
6140 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6141 PyObject *resultobj;
6142 wxString *arg1 = 0 ;
6143 wxToolTip *result;
6144 bool temp1 = false ;
6145 PyObject * obj0 = 0 ;
6146 char *kwnames[] = {
6147 (char *) "tip", NULL
6148 };
6149
6150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6151 {
6152 arg1 = wxString_in_helper(obj0);
6153 if (arg1 == NULL) SWIG_fail;
6154 temp1 = true;
6155 }
6156 {
6157 if (!wxPyCheckForApp()) SWIG_fail;
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 {
6165 resultobj = wxPyMake_wxObject(result, 1);
6166 }
6167 {
6168 if (temp1)
6169 delete arg1;
6170 }
6171 return resultobj;
6172 fail:
6173 {
6174 if (temp1)
6175 delete arg1;
6176 }
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj;
6183 wxToolTip *arg1 = (wxToolTip *) 0 ;
6184 wxString *arg2 = 0 ;
6185 bool temp2 = false ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 char *kwnames[] = {
6189 (char *) "self",(char *) "tip", NULL
6190 };
6191
6192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 {
6196 arg2 = wxString_in_helper(obj1);
6197 if (arg2 == NULL) SWIG_fail;
6198 temp2 = true;
6199 }
6200 {
6201 PyThreadState* __tstate = wxPyBeginAllowThreads();
6202 (arg1)->SetTip((wxString const &)*arg2);
6203
6204 wxPyEndAllowThreads(__tstate);
6205 if (PyErr_Occurred()) SWIG_fail;
6206 }
6207 Py_INCREF(Py_None); resultobj = Py_None;
6208 {
6209 if (temp2)
6210 delete arg2;
6211 }
6212 return resultobj;
6213 fail:
6214 {
6215 if (temp2)
6216 delete arg2;
6217 }
6218 return NULL;
6219 }
6220
6221
6222 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj;
6224 wxToolTip *arg1 = (wxToolTip *) 0 ;
6225 wxString result;
6226 PyObject * obj0 = 0 ;
6227 char *kwnames[] = {
6228 (char *) "self", NULL
6229 };
6230
6231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6233 if (SWIG_arg_fail(1)) SWIG_fail;
6234 {
6235 PyThreadState* __tstate = wxPyBeginAllowThreads();
6236 result = (arg1)->GetTip();
6237
6238 wxPyEndAllowThreads(__tstate);
6239 if (PyErr_Occurred()) SWIG_fail;
6240 }
6241 {
6242 #if wxUSE_UNICODE
6243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6244 #else
6245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6246 #endif
6247 }
6248 return resultobj;
6249 fail:
6250 return NULL;
6251 }
6252
6253
6254 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6255 PyObject *resultobj;
6256 wxToolTip *arg1 = (wxToolTip *) 0 ;
6257 wxWindow *result;
6258 PyObject * obj0 = 0 ;
6259 char *kwnames[] = {
6260 (char *) "self", NULL
6261 };
6262
6263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6265 if (SWIG_arg_fail(1)) SWIG_fail;
6266 {
6267 PyThreadState* __tstate = wxPyBeginAllowThreads();
6268 result = (wxWindow *)(arg1)->GetWindow();
6269
6270 wxPyEndAllowThreads(__tstate);
6271 if (PyErr_Occurred()) SWIG_fail;
6272 }
6273 {
6274 resultobj = wxPyMake_wxObject(result, 0);
6275 }
6276 return resultobj;
6277 fail:
6278 return NULL;
6279 }
6280
6281
6282 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6283 PyObject *resultobj;
6284 bool arg1 ;
6285 PyObject * obj0 = 0 ;
6286 char *kwnames[] = {
6287 (char *) "flag", NULL
6288 };
6289
6290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6291 {
6292 arg1 = (bool)(SWIG_As_bool(obj0));
6293 if (SWIG_arg_fail(1)) SWIG_fail;
6294 }
6295 {
6296 PyThreadState* __tstate = wxPyBeginAllowThreads();
6297 wxToolTip::Enable(arg1);
6298
6299 wxPyEndAllowThreads(__tstate);
6300 if (PyErr_Occurred()) SWIG_fail;
6301 }
6302 Py_INCREF(Py_None); resultobj = Py_None;
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj;
6311 long arg1 ;
6312 PyObject * obj0 = 0 ;
6313 char *kwnames[] = {
6314 (char *) "milliseconds", NULL
6315 };
6316
6317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6318 {
6319 arg1 = (long)(SWIG_As_long(obj0));
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 }
6322 {
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 wxToolTip::SetDelay(arg1);
6325
6326 wxPyEndAllowThreads(__tstate);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 Py_INCREF(Py_None); resultobj = Py_None;
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6337 PyObject *obj;
6338 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6339 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6340 Py_INCREF(obj);
6341 return Py_BuildValue((char *)"");
6342 }
6343 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6344 PyObject *resultobj;
6345 wxWindow *arg1 = (wxWindow *) 0 ;
6346 wxSize *arg2 = 0 ;
6347 wxCaret *result;
6348 wxSize temp2 ;
6349 PyObject * obj0 = 0 ;
6350 PyObject * obj1 = 0 ;
6351 char *kwnames[] = {
6352 (char *) "window",(char *) "size", NULL
6353 };
6354
6355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6357 if (SWIG_arg_fail(1)) SWIG_fail;
6358 {
6359 arg2 = &temp2;
6360 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6361 }
6362 {
6363 if (!wxPyCheckForApp()) SWIG_fail;
6364 PyThreadState* __tstate = wxPyBeginAllowThreads();
6365 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6366
6367 wxPyEndAllowThreads(__tstate);
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6371 return resultobj;
6372 fail:
6373 return NULL;
6374 }
6375
6376
6377 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj;
6379 wxCaret *arg1 = (wxCaret *) 0 ;
6380 PyObject * obj0 = 0 ;
6381 char *kwnames[] = {
6382 (char *) "self", NULL
6383 };
6384
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(1)) SWIG_fail;
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 wxCaret_Destroy(arg1);
6391
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 Py_INCREF(Py_None); resultobj = Py_None;
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj;
6404 wxCaret *arg1 = (wxCaret *) 0 ;
6405 bool result;
6406 PyObject * obj0 = 0 ;
6407 char *kwnames[] = {
6408 (char *) "self", NULL
6409 };
6410
6411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6413 if (SWIG_arg_fail(1)) SWIG_fail;
6414 {
6415 PyThreadState* __tstate = wxPyBeginAllowThreads();
6416 result = (bool)(arg1)->IsOk();
6417
6418 wxPyEndAllowThreads(__tstate);
6419 if (PyErr_Occurred()) SWIG_fail;
6420 }
6421 {
6422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6423 }
6424 return resultobj;
6425 fail:
6426 return NULL;
6427 }
6428
6429
6430 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6431 PyObject *resultobj;
6432 wxCaret *arg1 = (wxCaret *) 0 ;
6433 bool result;
6434 PyObject * obj0 = 0 ;
6435 char *kwnames[] = {
6436 (char *) "self", NULL
6437 };
6438
6439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6441 if (SWIG_arg_fail(1)) SWIG_fail;
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 result = (bool)(arg1)->IsVisible();
6445
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 {
6450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6451 }
6452 return resultobj;
6453 fail:
6454 return NULL;
6455 }
6456
6457
6458 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6459 PyObject *resultobj;
6460 wxCaret *arg1 = (wxCaret *) 0 ;
6461 wxPoint result;
6462 PyObject * obj0 = 0 ;
6463 char *kwnames[] = {
6464 (char *) "self", NULL
6465 };
6466
6467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6469 if (SWIG_arg_fail(1)) SWIG_fail;
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 result = (arg1)->GetPosition();
6473
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 {
6478 wxPoint * resultptr;
6479 resultptr = new wxPoint((wxPoint &)(result));
6480 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6481 }
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj;
6490 wxCaret *arg1 = (wxCaret *) 0 ;
6491 int *arg2 = (int *) 0 ;
6492 int *arg3 = (int *) 0 ;
6493 int temp2 ;
6494 int res2 = 0 ;
6495 int temp3 ;
6496 int res3 = 0 ;
6497 PyObject * obj0 = 0 ;
6498 char *kwnames[] = {
6499 (char *) "self", NULL
6500 };
6501
6502 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6503 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6506 if (SWIG_arg_fail(1)) SWIG_fail;
6507 {
6508 PyThreadState* __tstate = wxPyBeginAllowThreads();
6509 (arg1)->GetPosition(arg2,arg3);
6510
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 Py_INCREF(Py_None); resultobj = Py_None;
6515 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6516 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6517 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6518 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6519 return resultobj;
6520 fail:
6521 return NULL;
6522 }
6523
6524
6525 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6526 PyObject *resultobj;
6527 wxCaret *arg1 = (wxCaret *) 0 ;
6528 wxSize result;
6529 PyObject * obj0 = 0 ;
6530 char *kwnames[] = {
6531 (char *) "self", NULL
6532 };
6533
6534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6536 if (SWIG_arg_fail(1)) SWIG_fail;
6537 {
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = (arg1)->GetSize();
6540
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 {
6545 wxSize * resultptr;
6546 resultptr = new wxSize((wxSize &)(result));
6547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6548 }
6549 return resultobj;
6550 fail:
6551 return NULL;
6552 }
6553
6554
6555 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6556 PyObject *resultobj;
6557 wxCaret *arg1 = (wxCaret *) 0 ;
6558 int *arg2 = (int *) 0 ;
6559 int *arg3 = (int *) 0 ;
6560 int temp2 ;
6561 int res2 = 0 ;
6562 int temp3 ;
6563 int res3 = 0 ;
6564 PyObject * obj0 = 0 ;
6565 char *kwnames[] = {
6566 (char *) "self", NULL
6567 };
6568
6569 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6570 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6573 if (SWIG_arg_fail(1)) SWIG_fail;
6574 {
6575 PyThreadState* __tstate = wxPyBeginAllowThreads();
6576 (arg1)->GetSize(arg2,arg3);
6577
6578 wxPyEndAllowThreads(__tstate);
6579 if (PyErr_Occurred()) SWIG_fail;
6580 }
6581 Py_INCREF(Py_None); resultobj = Py_None;
6582 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6583 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6584 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6585 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6586 return resultobj;
6587 fail:
6588 return NULL;
6589 }
6590
6591
6592 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6593 PyObject *resultobj;
6594 wxCaret *arg1 = (wxCaret *) 0 ;
6595 wxWindow *result;
6596 PyObject * obj0 = 0 ;
6597 char *kwnames[] = {
6598 (char *) "self", NULL
6599 };
6600
6601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6603 if (SWIG_arg_fail(1)) SWIG_fail;
6604 {
6605 PyThreadState* __tstate = wxPyBeginAllowThreads();
6606 result = (wxWindow *)(arg1)->GetWindow();
6607
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 {
6612 resultobj = wxPyMake_wxObject(result, 0);
6613 }
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6621 PyObject *resultobj;
6622 wxCaret *arg1 = (wxCaret *) 0 ;
6623 int arg2 ;
6624 int arg3 ;
6625 PyObject * obj0 = 0 ;
6626 PyObject * obj1 = 0 ;
6627 PyObject * obj2 = 0 ;
6628 char *kwnames[] = {
6629 (char *) "self",(char *) "x",(char *) "y", NULL
6630 };
6631
6632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6634 if (SWIG_arg_fail(1)) SWIG_fail;
6635 {
6636 arg2 = (int)(SWIG_As_int(obj1));
6637 if (SWIG_arg_fail(2)) SWIG_fail;
6638 }
6639 {
6640 arg3 = (int)(SWIG_As_int(obj2));
6641 if (SWIG_arg_fail(3)) SWIG_fail;
6642 }
6643 {
6644 PyThreadState* __tstate = wxPyBeginAllowThreads();
6645 (arg1)->Move(arg2,arg3);
6646
6647 wxPyEndAllowThreads(__tstate);
6648 if (PyErr_Occurred()) SWIG_fail;
6649 }
6650 Py_INCREF(Py_None); resultobj = Py_None;
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6658 PyObject *resultobj;
6659 wxCaret *arg1 = (wxCaret *) 0 ;
6660 wxPoint *arg2 = 0 ;
6661 wxPoint temp2 ;
6662 PyObject * obj0 = 0 ;
6663 PyObject * obj1 = 0 ;
6664 char *kwnames[] = {
6665 (char *) "self",(char *) "pt", NULL
6666 };
6667
6668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6670 if (SWIG_arg_fail(1)) SWIG_fail;
6671 {
6672 arg2 = &temp2;
6673 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6674 }
6675 {
6676 PyThreadState* __tstate = wxPyBeginAllowThreads();
6677 (arg1)->Move((wxPoint const &)*arg2);
6678
6679 wxPyEndAllowThreads(__tstate);
6680 if (PyErr_Occurred()) SWIG_fail;
6681 }
6682 Py_INCREF(Py_None); resultobj = Py_None;
6683 return resultobj;
6684 fail:
6685 return NULL;
6686 }
6687
6688
6689 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6690 PyObject *resultobj;
6691 wxCaret *arg1 = (wxCaret *) 0 ;
6692 int arg2 ;
6693 int arg3 ;
6694 PyObject * obj0 = 0 ;
6695 PyObject * obj1 = 0 ;
6696 PyObject * obj2 = 0 ;
6697 char *kwnames[] = {
6698 (char *) "self",(char *) "width",(char *) "height", NULL
6699 };
6700
6701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6703 if (SWIG_arg_fail(1)) SWIG_fail;
6704 {
6705 arg2 = (int)(SWIG_As_int(obj1));
6706 if (SWIG_arg_fail(2)) SWIG_fail;
6707 }
6708 {
6709 arg3 = (int)(SWIG_As_int(obj2));
6710 if (SWIG_arg_fail(3)) SWIG_fail;
6711 }
6712 {
6713 PyThreadState* __tstate = wxPyBeginAllowThreads();
6714 (arg1)->SetSize(arg2,arg3);
6715
6716 wxPyEndAllowThreads(__tstate);
6717 if (PyErr_Occurred()) SWIG_fail;
6718 }
6719 Py_INCREF(Py_None); resultobj = Py_None;
6720 return resultobj;
6721 fail:
6722 return NULL;
6723 }
6724
6725
6726 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6727 PyObject *resultobj;
6728 wxCaret *arg1 = (wxCaret *) 0 ;
6729 wxSize *arg2 = 0 ;
6730 wxSize temp2 ;
6731 PyObject * obj0 = 0 ;
6732 PyObject * obj1 = 0 ;
6733 char *kwnames[] = {
6734 (char *) "self",(char *) "size", NULL
6735 };
6736
6737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6739 if (SWIG_arg_fail(1)) SWIG_fail;
6740 {
6741 arg2 = &temp2;
6742 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6743 }
6744 {
6745 PyThreadState* __tstate = wxPyBeginAllowThreads();
6746 (arg1)->SetSize((wxSize const &)*arg2);
6747
6748 wxPyEndAllowThreads(__tstate);
6749 if (PyErr_Occurred()) SWIG_fail;
6750 }
6751 Py_INCREF(Py_None); resultobj = Py_None;
6752 return resultobj;
6753 fail:
6754 return NULL;
6755 }
6756
6757
6758 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6759 PyObject *resultobj;
6760 wxCaret *arg1 = (wxCaret *) 0 ;
6761 int arg2 = (int) true ;
6762 PyObject * obj0 = 0 ;
6763 PyObject * obj1 = 0 ;
6764 char *kwnames[] = {
6765 (char *) "self",(char *) "show", NULL
6766 };
6767
6768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6770 if (SWIG_arg_fail(1)) SWIG_fail;
6771 if (obj1) {
6772 {
6773 arg2 = (int)(SWIG_As_int(obj1));
6774 if (SWIG_arg_fail(2)) SWIG_fail;
6775 }
6776 }
6777 {
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 (arg1)->Show(arg2);
6780
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 Py_INCREF(Py_None); resultobj = Py_None;
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj;
6793 wxCaret *arg1 = (wxCaret *) 0 ;
6794 PyObject * obj0 = 0 ;
6795 char *kwnames[] = {
6796 (char *) "self", NULL
6797 };
6798
6799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6801 if (SWIG_arg_fail(1)) SWIG_fail;
6802 {
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 (arg1)->Hide();
6805
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 Py_INCREF(Py_None); resultobj = Py_None;
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj;
6818 int result;
6819 char *kwnames[] = {
6820 NULL
6821 };
6822
6823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6824 {
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = (int)wxCaret::GetBlinkTime();
6827
6828 wxPyEndAllowThreads(__tstate);
6829 if (PyErr_Occurred()) SWIG_fail;
6830 }
6831 {
6832 resultobj = SWIG_From_int((int)(result));
6833 }
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6841 PyObject *resultobj;
6842 int arg1 ;
6843 PyObject * obj0 = 0 ;
6844 char *kwnames[] = {
6845 (char *) "milliseconds", NULL
6846 };
6847
6848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6849 {
6850 arg1 = (int)(SWIG_As_int(obj0));
6851 if (SWIG_arg_fail(1)) SWIG_fail;
6852 }
6853 {
6854 PyThreadState* __tstate = wxPyBeginAllowThreads();
6855 wxCaret::SetBlinkTime(arg1);
6856
6857 wxPyEndAllowThreads(__tstate);
6858 if (PyErr_Occurred()) SWIG_fail;
6859 }
6860 Py_INCREF(Py_None); resultobj = Py_None;
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6868 PyObject *obj;
6869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6870 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6871 Py_INCREF(obj);
6872 return Py_BuildValue((char *)"");
6873 }
6874 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6875 PyObject *resultobj;
6876 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6877 wxBusyCursor *result;
6878 PyObject * obj0 = 0 ;
6879 char *kwnames[] = {
6880 (char *) "cursor", NULL
6881 };
6882
6883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6884 if (obj0) {
6885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6886 if (SWIG_arg_fail(1)) SWIG_fail;
6887 }
6888 {
6889 if (!wxPyCheckForApp()) SWIG_fail;
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6892
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6904 PyObject *resultobj;
6905 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6906 PyObject * obj0 = 0 ;
6907 char *kwnames[] = {
6908 (char *) "self", NULL
6909 };
6910
6911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6913 if (SWIG_arg_fail(1)) SWIG_fail;
6914 {
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 delete arg1;
6917
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 Py_INCREF(Py_None); resultobj = Py_None;
6922 return resultobj;
6923 fail:
6924 return NULL;
6925 }
6926
6927
6928 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6929 PyObject *obj;
6930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6931 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6932 Py_INCREF(obj);
6933 return Py_BuildValue((char *)"");
6934 }
6935 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6936 PyObject *resultobj;
6937 wxWindow *arg1 = (wxWindow *) NULL ;
6938 wxWindowDisabler *result;
6939 PyObject * obj0 = 0 ;
6940 char *kwnames[] = {
6941 (char *) "winToSkip", NULL
6942 };
6943
6944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6945 if (obj0) {
6946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6947 if (SWIG_arg_fail(1)) SWIG_fail;
6948 }
6949 {
6950 if (!wxPyCheckForApp()) SWIG_fail;
6951 PyThreadState* __tstate = wxPyBeginAllowThreads();
6952 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6953
6954 wxPyEndAllowThreads(__tstate);
6955 if (PyErr_Occurred()) SWIG_fail;
6956 }
6957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6958 return resultobj;
6959 fail:
6960 return NULL;
6961 }
6962
6963
6964 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6965 PyObject *resultobj;
6966 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6967 PyObject * obj0 = 0 ;
6968 char *kwnames[] = {
6969 (char *) "self", NULL
6970 };
6971
6972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6974 if (SWIG_arg_fail(1)) SWIG_fail;
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 delete arg1;
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 Py_INCREF(Py_None); resultobj = Py_None;
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6990 PyObject *obj;
6991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6992 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6993 Py_INCREF(obj);
6994 return Py_BuildValue((char *)"");
6995 }
6996 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj;
6998 wxString *arg1 = 0 ;
6999 wxBusyInfo *result;
7000 bool temp1 = false ;
7001 PyObject * obj0 = 0 ;
7002 char *kwnames[] = {
7003 (char *) "message", NULL
7004 };
7005
7006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7007 {
7008 arg1 = wxString_in_helper(obj0);
7009 if (arg1 == NULL) SWIG_fail;
7010 temp1 = true;
7011 }
7012 {
7013 if (!wxPyCheckForApp()) SWIG_fail;
7014 PyThreadState* __tstate = wxPyBeginAllowThreads();
7015 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7021 {
7022 if (temp1)
7023 delete arg1;
7024 }
7025 return resultobj;
7026 fail:
7027 {
7028 if (temp1)
7029 delete arg1;
7030 }
7031 return NULL;
7032 }
7033
7034
7035 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7036 PyObject *resultobj;
7037 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7038 PyObject * obj0 = 0 ;
7039 char *kwnames[] = {
7040 (char *) "self", NULL
7041 };
7042
7043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7045 if (SWIG_arg_fail(1)) SWIG_fail;
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 delete arg1;
7049
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 Py_INCREF(Py_None); resultobj = Py_None;
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7061 PyObject *obj;
7062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7063 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7064 Py_INCREF(obj);
7065 return Py_BuildValue((char *)"");
7066 }
7067 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7068 PyObject *resultobj;
7069 wxStopWatch *result;
7070 char *kwnames[] = {
7071 NULL
7072 };
7073
7074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7075 {
7076 PyThreadState* __tstate = wxPyBeginAllowThreads();
7077 result = (wxStopWatch *)new wxStopWatch();
7078
7079 wxPyEndAllowThreads(__tstate);
7080 if (PyErr_Occurred()) SWIG_fail;
7081 }
7082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7083 return resultobj;
7084 fail:
7085 return NULL;
7086 }
7087
7088
7089 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj;
7091 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7092 long arg2 = (long) 0 ;
7093 PyObject * obj0 = 0 ;
7094 PyObject * obj1 = 0 ;
7095 char *kwnames[] = {
7096 (char *) "self",(char *) "t0", NULL
7097 };
7098
7099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7101 if (SWIG_arg_fail(1)) SWIG_fail;
7102 if (obj1) {
7103 {
7104 arg2 = (long)(SWIG_As_long(obj1));
7105 if (SWIG_arg_fail(2)) SWIG_fail;
7106 }
7107 }
7108 {
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 (arg1)->Start(arg2);
7111
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 Py_INCREF(Py_None); resultobj = Py_None;
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj;
7124 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7125 PyObject * obj0 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 {
7134 PyThreadState* __tstate = wxPyBeginAllowThreads();
7135 (arg1)->Pause();
7136
7137 wxPyEndAllowThreads(__tstate);
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 Py_INCREF(Py_None); resultobj = Py_None;
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7148 PyObject *resultobj;
7149 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7150 PyObject * obj0 = 0 ;
7151 char *kwnames[] = {
7152 (char *) "self", NULL
7153 };
7154
7155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7157 if (SWIG_arg_fail(1)) SWIG_fail;
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 (arg1)->Resume();
7161
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 Py_INCREF(Py_None); resultobj = Py_None;
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7173 PyObject *resultobj;
7174 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7175 long result;
7176 PyObject * obj0 = 0 ;
7177 char *kwnames[] = {
7178 (char *) "self", NULL
7179 };
7180
7181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7183 if (SWIG_arg_fail(1)) SWIG_fail;
7184 {
7185 PyThreadState* __tstate = wxPyBeginAllowThreads();
7186 result = (long)((wxStopWatch const *)arg1)->Time();
7187
7188 wxPyEndAllowThreads(__tstate);
7189 if (PyErr_Occurred()) SWIG_fail;
7190 }
7191 {
7192 resultobj = SWIG_From_long((long)(result));
7193 }
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7201 PyObject *obj;
7202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7203 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7204 Py_INCREF(obj);
7205 return Py_BuildValue((char *)"");
7206 }
7207 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7208 PyObject *resultobj;
7209 int arg1 = (int) 9 ;
7210 int arg2 = (int) wxID_FILE1 ;
7211 wxFileHistory *result;
7212 PyObject * obj0 = 0 ;
7213 PyObject * obj1 = 0 ;
7214 char *kwnames[] = {
7215 (char *) "maxFiles",(char *) "idBase", NULL
7216 };
7217
7218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7219 if (obj0) {
7220 {
7221 arg1 = (int)(SWIG_As_int(obj0));
7222 if (SWIG_arg_fail(1)) SWIG_fail;
7223 }
7224 }
7225 if (obj1) {
7226 {
7227 arg2 = (int)(SWIG_As_int(obj1));
7228 if (SWIG_arg_fail(2)) SWIG_fail;
7229 }
7230 }
7231 {
7232 PyThreadState* __tstate = wxPyBeginAllowThreads();
7233 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7234
7235 wxPyEndAllowThreads(__tstate);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
7245 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7246 PyObject *resultobj;
7247 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "self", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7255 if (SWIG_arg_fail(1)) SWIG_fail;
7256 {
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 delete arg1;
7259
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 Py_INCREF(Py_None); resultobj = Py_None;
7264 return resultobj;
7265 fail:
7266 return NULL;
7267 }
7268
7269
7270 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7271 PyObject *resultobj;
7272 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7273 wxString *arg2 = 0 ;
7274 bool temp2 = false ;
7275 PyObject * obj0 = 0 ;
7276 PyObject * obj1 = 0 ;
7277 char *kwnames[] = {
7278 (char *) "self",(char *) "file", NULL
7279 };
7280
7281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7283 if (SWIG_arg_fail(1)) SWIG_fail;
7284 {
7285 arg2 = wxString_in_helper(obj1);
7286 if (arg2 == NULL) SWIG_fail;
7287 temp2 = true;
7288 }
7289 {
7290 PyThreadState* __tstate = wxPyBeginAllowThreads();
7291 (arg1)->AddFileToHistory((wxString const &)*arg2);
7292
7293 wxPyEndAllowThreads(__tstate);
7294 if (PyErr_Occurred()) SWIG_fail;
7295 }
7296 Py_INCREF(Py_None); resultobj = Py_None;
7297 {
7298 if (temp2)
7299 delete arg2;
7300 }
7301 return resultobj;
7302 fail:
7303 {
7304 if (temp2)
7305 delete arg2;
7306 }
7307 return NULL;
7308 }
7309
7310
7311 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7312 PyObject *resultobj;
7313 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7314 int arg2 ;
7315 PyObject * obj0 = 0 ;
7316 PyObject * obj1 = 0 ;
7317 char *kwnames[] = {
7318 (char *) "self",(char *) "i", NULL
7319 };
7320
7321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7323 if (SWIG_arg_fail(1)) SWIG_fail;
7324 {
7325 arg2 = (int)(SWIG_As_int(obj1));
7326 if (SWIG_arg_fail(2)) SWIG_fail;
7327 }
7328 {
7329 PyThreadState* __tstate = wxPyBeginAllowThreads();
7330 (arg1)->RemoveFileFromHistory(arg2);
7331
7332 wxPyEndAllowThreads(__tstate);
7333 if (PyErr_Occurred()) SWIG_fail;
7334 }
7335 Py_INCREF(Py_None); resultobj = Py_None;
7336 return resultobj;
7337 fail:
7338 return NULL;
7339 }
7340
7341
7342 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7343 PyObject *resultobj;
7344 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7345 int result;
7346 PyObject * obj0 = 0 ;
7347 char *kwnames[] = {
7348 (char *) "self", NULL
7349 };
7350
7351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7353 if (SWIG_arg_fail(1)) SWIG_fail;
7354 {
7355 PyThreadState* __tstate = wxPyBeginAllowThreads();
7356 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7357
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 {
7362 resultobj = SWIG_From_int((int)(result));
7363 }
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj;
7372 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7373 wxMenu *arg2 = (wxMenu *) 0 ;
7374 PyObject * obj0 = 0 ;
7375 PyObject * obj1 = 0 ;
7376 char *kwnames[] = {
7377 (char *) "self",(char *) "menu", NULL
7378 };
7379
7380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7382 if (SWIG_arg_fail(1)) SWIG_fail;
7383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(2)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 (arg1)->UseMenu(arg2);
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 Py_INCREF(Py_None); resultobj = Py_None;
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7402 wxMenu *arg2 = (wxMenu *) 0 ;
7403 PyObject * obj0 = 0 ;
7404 PyObject * obj1 = 0 ;
7405 char *kwnames[] = {
7406 (char *) "self",(char *) "menu", NULL
7407 };
7408
7409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7411 if (SWIG_arg_fail(1)) SWIG_fail;
7412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7413 if (SWIG_arg_fail(2)) SWIG_fail;
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 (arg1)->RemoveMenu(arg2);
7417
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 Py_INCREF(Py_None); resultobj = Py_None;
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7431 wxConfigBase *arg2 = 0 ;
7432 PyObject * obj0 = 0 ;
7433 PyObject * obj1 = 0 ;
7434 char *kwnames[] = {
7435 (char *) "self",(char *) "config", NULL
7436 };
7437
7438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7440 if (SWIG_arg_fail(1)) SWIG_fail;
7441 {
7442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7443 if (SWIG_arg_fail(2)) SWIG_fail;
7444 if (arg2 == NULL) {
7445 SWIG_null_ref("wxConfigBase");
7446 }
7447 if (SWIG_arg_fail(2)) SWIG_fail;
7448 }
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 (arg1)->Load(*arg2);
7452
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 Py_INCREF(Py_None); resultobj = Py_None;
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj;
7465 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7466 wxConfigBase *arg2 = 0 ;
7467 PyObject * obj0 = 0 ;
7468 PyObject * obj1 = 0 ;
7469 char *kwnames[] = {
7470 (char *) "self",(char *) "config", NULL
7471 };
7472
7473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7475 if (SWIG_arg_fail(1)) SWIG_fail;
7476 {
7477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7478 if (SWIG_arg_fail(2)) SWIG_fail;
7479 if (arg2 == NULL) {
7480 SWIG_null_ref("wxConfigBase");
7481 }
7482 if (SWIG_arg_fail(2)) SWIG_fail;
7483 }
7484 {
7485 PyThreadState* __tstate = wxPyBeginAllowThreads();
7486 (arg1)->Save(*arg2);
7487
7488 wxPyEndAllowThreads(__tstate);
7489 if (PyErr_Occurred()) SWIG_fail;
7490 }
7491 Py_INCREF(Py_None); resultobj = Py_None;
7492 return resultobj;
7493 fail:
7494 return NULL;
7495 }
7496
7497
7498 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7499 PyObject *resultobj;
7500 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7501 PyObject * obj0 = 0 ;
7502 char *kwnames[] = {
7503 (char *) "self", NULL
7504 };
7505
7506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7508 if (SWIG_arg_fail(1)) SWIG_fail;
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 (arg1)->AddFilesToMenu();
7512
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 Py_INCREF(Py_None); resultobj = Py_None;
7517 return resultobj;
7518 fail:
7519 return NULL;
7520 }
7521
7522
7523 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7524 PyObject *resultobj;
7525 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7526 wxMenu *arg2 = (wxMenu *) 0 ;
7527 PyObject * obj0 = 0 ;
7528 PyObject * obj1 = 0 ;
7529 char *kwnames[] = {
7530 (char *) "self",(char *) "menu", NULL
7531 };
7532
7533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7535 if (SWIG_arg_fail(1)) SWIG_fail;
7536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7537 if (SWIG_arg_fail(2)) SWIG_fail;
7538 {
7539 PyThreadState* __tstate = wxPyBeginAllowThreads();
7540 (arg1)->AddFilesToMenu(arg2);
7541
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 Py_INCREF(Py_None); resultobj = Py_None;
7546 return resultobj;
7547 fail:
7548 return NULL;
7549 }
7550
7551
7552 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7553 PyObject *resultobj;
7554 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7555 int arg2 ;
7556 wxString result;
7557 PyObject * obj0 = 0 ;
7558 PyObject * obj1 = 0 ;
7559 char *kwnames[] = {
7560 (char *) "self",(char *) "i", NULL
7561 };
7562
7563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7565 if (SWIG_arg_fail(1)) SWIG_fail;
7566 {
7567 arg2 = (int)(SWIG_As_int(obj1));
7568 if (SWIG_arg_fail(2)) SWIG_fail;
7569 }
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7573
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 {
7578 #if wxUSE_UNICODE
7579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7580 #else
7581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7582 #endif
7583 }
7584 return resultobj;
7585 fail:
7586 return NULL;
7587 }
7588
7589
7590 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7591 PyObject *resultobj;
7592 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7593 int result;
7594 PyObject * obj0 = 0 ;
7595 char *kwnames[] = {
7596 (char *) "self", NULL
7597 };
7598
7599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7601 if (SWIG_arg_fail(1)) SWIG_fail;
7602 {
7603 PyThreadState* __tstate = wxPyBeginAllowThreads();
7604 result = (int)((wxFileHistory const *)arg1)->GetCount();
7605
7606 wxPyEndAllowThreads(__tstate);
7607 if (PyErr_Occurred()) SWIG_fail;
7608 }
7609 {
7610 resultobj = SWIG_From_int((int)(result));
7611 }
7612 return resultobj;
7613 fail:
7614 return NULL;
7615 }
7616
7617
7618 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7619 PyObject *obj;
7620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7621 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7622 Py_INCREF(obj);
7623 return Py_BuildValue((char *)"");
7624 }
7625 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj;
7627 wxString *arg1 = 0 ;
7628 wxString const &arg2_defvalue = wxPyEmptyString ;
7629 wxString *arg2 = (wxString *) &arg2_defvalue ;
7630 wxSingleInstanceChecker *result;
7631 bool temp1 = false ;
7632 bool temp2 = false ;
7633 PyObject * obj0 = 0 ;
7634 PyObject * obj1 = 0 ;
7635 char *kwnames[] = {
7636 (char *) "name",(char *) "path", NULL
7637 };
7638
7639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7640 {
7641 arg1 = wxString_in_helper(obj0);
7642 if (arg1 == NULL) SWIG_fail;
7643 temp1 = true;
7644 }
7645 if (obj1) {
7646 {
7647 arg2 = wxString_in_helper(obj1);
7648 if (arg2 == NULL) SWIG_fail;
7649 temp2 = true;
7650 }
7651 }
7652 {
7653 PyThreadState* __tstate = wxPyBeginAllowThreads();
7654 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7655
7656 wxPyEndAllowThreads(__tstate);
7657 if (PyErr_Occurred()) SWIG_fail;
7658 }
7659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7660 {
7661 if (temp1)
7662 delete arg1;
7663 }
7664 {
7665 if (temp2)
7666 delete arg2;
7667 }
7668 return resultobj;
7669 fail:
7670 {
7671 if (temp1)
7672 delete arg1;
7673 }
7674 {
7675 if (temp2)
7676 delete arg2;
7677 }
7678 return NULL;
7679 }
7680
7681
7682 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7683 PyObject *resultobj;
7684 wxSingleInstanceChecker *result;
7685 char *kwnames[] = {
7686 NULL
7687 };
7688
7689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj;
7706 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7707 PyObject * obj0 = 0 ;
7708 char *kwnames[] = {
7709 (char *) "self", NULL
7710 };
7711
7712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7714 if (SWIG_arg_fail(1)) SWIG_fail;
7715 {
7716 PyThreadState* __tstate = wxPyBeginAllowThreads();
7717 delete arg1;
7718
7719 wxPyEndAllowThreads(__tstate);
7720 if (PyErr_Occurred()) SWIG_fail;
7721 }
7722 Py_INCREF(Py_None); resultobj = Py_None;
7723 return resultobj;
7724 fail:
7725 return NULL;
7726 }
7727
7728
7729 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7730 PyObject *resultobj;
7731 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7732 wxString *arg2 = 0 ;
7733 wxString const &arg3_defvalue = wxPyEmptyString ;
7734 wxString *arg3 = (wxString *) &arg3_defvalue ;
7735 bool result;
7736 bool temp2 = false ;
7737 bool temp3 = false ;
7738 PyObject * obj0 = 0 ;
7739 PyObject * obj1 = 0 ;
7740 PyObject * obj2 = 0 ;
7741 char *kwnames[] = {
7742 (char *) "self",(char *) "name",(char *) "path", NULL
7743 };
7744
7745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7747 if (SWIG_arg_fail(1)) SWIG_fail;
7748 {
7749 arg2 = wxString_in_helper(obj1);
7750 if (arg2 == NULL) SWIG_fail;
7751 temp2 = true;
7752 }
7753 if (obj2) {
7754 {
7755 arg3 = wxString_in_helper(obj2);
7756 if (arg3 == NULL) SWIG_fail;
7757 temp3 = true;
7758 }
7759 }
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7763
7764 wxPyEndAllowThreads(__tstate);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 {
7768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7769 }
7770 {
7771 if (temp2)
7772 delete arg2;
7773 }
7774 {
7775 if (temp3)
7776 delete arg3;
7777 }
7778 return resultobj;
7779 fail:
7780 {
7781 if (temp2)
7782 delete arg2;
7783 }
7784 {
7785 if (temp3)
7786 delete arg3;
7787 }
7788 return NULL;
7789 }
7790
7791
7792 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7793 PyObject *resultobj;
7794 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7795 bool result;
7796 PyObject * obj0 = 0 ;
7797 char *kwnames[] = {
7798 (char *) "self", NULL
7799 };
7800
7801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7803 if (SWIG_arg_fail(1)) SWIG_fail;
7804 {
7805 PyThreadState* __tstate = wxPyBeginAllowThreads();
7806 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7807
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 {
7812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7813 }
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7821 PyObject *obj;
7822 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7823 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7824 Py_INCREF(obj);
7825 return Py_BuildValue((char *)"");
7826 }
7827 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7828 PyObject *resultobj;
7829 wxWindow *arg1 = (wxWindow *) 0 ;
7830 wxDC *arg2 = 0 ;
7831 bool result;
7832 PyObject * obj0 = 0 ;
7833 PyObject * obj1 = 0 ;
7834 char *kwnames[] = {
7835 (char *) "window",(char *) "dc", NULL
7836 };
7837
7838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7840 if (SWIG_arg_fail(1)) SWIG_fail;
7841 {
7842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7843 if (SWIG_arg_fail(2)) SWIG_fail;
7844 if (arg2 == NULL) {
7845 SWIG_null_ref("wxDC");
7846 }
7847 if (SWIG_arg_fail(2)) SWIG_fail;
7848 }
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7852
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 {
7857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7858 }
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7866 PyObject *resultobj;
7867 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7868 PyObject * obj0 = 0 ;
7869 char *kwnames[] = {
7870 (char *) "self", NULL
7871 };
7872
7873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7875 if (SWIG_arg_fail(1)) SWIG_fail;
7876 {
7877 PyThreadState* __tstate = wxPyBeginAllowThreads();
7878 delete arg1;
7879
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 Py_INCREF(Py_None); resultobj = Py_None;
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj;
7892 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7893 wxString result;
7894 PyObject * obj0 = 0 ;
7895 char *kwnames[] = {
7896 (char *) "self", NULL
7897 };
7898
7899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7901 if (SWIG_arg_fail(1)) SWIG_fail;
7902 {
7903 PyThreadState* __tstate = wxPyBeginAllowThreads();
7904 result = (arg1)->GetTip();
7905
7906 wxPyEndAllowThreads(__tstate);
7907 if (PyErr_Occurred()) SWIG_fail;
7908 }
7909 {
7910 #if wxUSE_UNICODE
7911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7912 #else
7913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7914 #endif
7915 }
7916 return resultobj;
7917 fail:
7918 return NULL;
7919 }
7920
7921
7922 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj;
7924 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7925 size_t result;
7926 PyObject * obj0 = 0 ;
7927 char *kwnames[] = {
7928 (char *) "self", NULL
7929 };
7930
7931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7933 if (SWIG_arg_fail(1)) SWIG_fail;
7934 {
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (size_t)(arg1)->GetCurrentTip();
7937
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 {
7942 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7943 }
7944 return resultobj;
7945 fail:
7946 return NULL;
7947 }
7948
7949
7950 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7951 PyObject *resultobj;
7952 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7953 wxString *arg2 = 0 ;
7954 wxString result;
7955 bool temp2 = false ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char *kwnames[] = {
7959 (char *) "self",(char *) "tip", NULL
7960 };
7961
7962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7964 if (SWIG_arg_fail(1)) SWIG_fail;
7965 {
7966 arg2 = wxString_in_helper(obj1);
7967 if (arg2 == NULL) SWIG_fail;
7968 temp2 = true;
7969 }
7970 {
7971 PyThreadState* __tstate = wxPyBeginAllowThreads();
7972 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7973
7974 wxPyEndAllowThreads(__tstate);
7975 if (PyErr_Occurred()) SWIG_fail;
7976 }
7977 {
7978 #if wxUSE_UNICODE
7979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7980 #else
7981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7982 #endif
7983 }
7984 {
7985 if (temp2)
7986 delete arg2;
7987 }
7988 return resultobj;
7989 fail:
7990 {
7991 if (temp2)
7992 delete arg2;
7993 }
7994 return NULL;
7995 }
7996
7997
7998 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7999 PyObject *obj;
8000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8001 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8002 Py_INCREF(obj);
8003 return Py_BuildValue((char *)"");
8004 }
8005 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8006 PyObject *resultobj;
8007 size_t arg1 ;
8008 wxPyTipProvider *result;
8009 PyObject * obj0 = 0 ;
8010 char *kwnames[] = {
8011 (char *) "currentTip", NULL
8012 };
8013
8014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8015 {
8016 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8017 if (SWIG_arg_fail(1)) SWIG_fail;
8018 }
8019 {
8020 PyThreadState* __tstate = wxPyBeginAllowThreads();
8021 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8022
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj;
8035 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8036 PyObject *arg2 = (PyObject *) 0 ;
8037 PyObject *arg3 = (PyObject *) 0 ;
8038 PyObject * obj0 = 0 ;
8039 PyObject * obj1 = 0 ;
8040 PyObject * obj2 = 0 ;
8041 char *kwnames[] = {
8042 (char *) "self",(char *) "self",(char *) "_class", NULL
8043 };
8044
8045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8047 if (SWIG_arg_fail(1)) SWIG_fail;
8048 arg2 = obj1;
8049 arg3 = obj2;
8050 {
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 (arg1)->_setCallbackInfo(arg2,arg3);
8053
8054 wxPyEndAllowThreads(__tstate);
8055 if (PyErr_Occurred()) SWIG_fail;
8056 }
8057 Py_INCREF(Py_None); resultobj = Py_None;
8058 return resultobj;
8059 fail:
8060 return NULL;
8061 }
8062
8063
8064 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8065 PyObject *obj;
8066 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8067 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8068 Py_INCREF(obj);
8069 return Py_BuildValue((char *)"");
8070 }
8071 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8072 PyObject *resultobj;
8073 wxWindow *arg1 = (wxWindow *) 0 ;
8074 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8075 bool arg3 = (bool) true ;
8076 bool result;
8077 PyObject * obj0 = 0 ;
8078 PyObject * obj1 = 0 ;
8079 PyObject * obj2 = 0 ;
8080 char *kwnames[] = {
8081 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8082 };
8083
8084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8086 if (SWIG_arg_fail(1)) SWIG_fail;
8087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8088 if (SWIG_arg_fail(2)) SWIG_fail;
8089 if (obj2) {
8090 {
8091 arg3 = (bool)(SWIG_As_bool(obj2));
8092 if (SWIG_arg_fail(3)) SWIG_fail;
8093 }
8094 }
8095 {
8096 if (!wxPyCheckForApp()) SWIG_fail;
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 result = (bool)wxShowTip(arg1,arg2,arg3);
8099
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 {
8104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8105 }
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8113 PyObject *resultobj;
8114 wxString *arg1 = 0 ;
8115 size_t arg2 ;
8116 wxTipProvider *result;
8117 bool temp1 = false ;
8118 PyObject * obj0 = 0 ;
8119 PyObject * obj1 = 0 ;
8120 char *kwnames[] = {
8121 (char *) "filename",(char *) "currentTip", NULL
8122 };
8123
8124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8125 {
8126 arg1 = wxString_in_helper(obj0);
8127 if (arg1 == NULL) SWIG_fail;
8128 temp1 = true;
8129 }
8130 {
8131 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8132 if (SWIG_arg_fail(2)) SWIG_fail;
8133 }
8134 {
8135 if (!wxPyCheckForApp()) SWIG_fail;
8136 PyThreadState* __tstate = wxPyBeginAllowThreads();
8137 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8138
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8143 {
8144 if (temp1)
8145 delete arg1;
8146 }
8147 return resultobj;
8148 fail:
8149 {
8150 if (temp1)
8151 delete arg1;
8152 }
8153 return NULL;
8154 }
8155
8156
8157 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8158 PyObject *resultobj;
8159 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8160 int arg2 = (int) -1 ;
8161 wxPyTimer *result;
8162 PyObject * obj0 = 0 ;
8163 PyObject * obj1 = 0 ;
8164 char *kwnames[] = {
8165 (char *) "owner",(char *) "id", NULL
8166 };
8167
8168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8169 if (obj0) {
8170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8171 if (SWIG_arg_fail(1)) SWIG_fail;
8172 }
8173 if (obj1) {
8174 {
8175 arg2 = (int)(SWIG_As_int(obj1));
8176 if (SWIG_arg_fail(2)) SWIG_fail;
8177 }
8178 }
8179 {
8180 if (!wxPyCheckForApp()) SWIG_fail;
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8183
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8188 return resultobj;
8189 fail:
8190 return NULL;
8191 }
8192
8193
8194 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8195 PyObject *resultobj;
8196 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8197 PyObject * obj0 = 0 ;
8198 char *kwnames[] = {
8199 (char *) "self", NULL
8200 };
8201
8202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8204 if (SWIG_arg_fail(1)) SWIG_fail;
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 delete arg1;
8208
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 Py_INCREF(Py_None); resultobj = Py_None;
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj;
8221 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8222 PyObject *arg2 = (PyObject *) 0 ;
8223 PyObject *arg3 = (PyObject *) 0 ;
8224 int arg4 = (int) 1 ;
8225 PyObject * obj0 = 0 ;
8226 PyObject * obj1 = 0 ;
8227 PyObject * obj2 = 0 ;
8228 PyObject * obj3 = 0 ;
8229 char *kwnames[] = {
8230 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(1)) SWIG_fail;
8236 arg2 = obj1;
8237 arg3 = obj2;
8238 if (obj3) {
8239 {
8240 arg4 = (int)(SWIG_As_int(obj3));
8241 if (SWIG_arg_fail(4)) SWIG_fail;
8242 }
8243 }
8244 {
8245 PyThreadState* __tstate = wxPyBeginAllowThreads();
8246 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8247
8248 wxPyEndAllowThreads(__tstate);
8249 if (PyErr_Occurred()) SWIG_fail;
8250 }
8251 Py_INCREF(Py_None); resultobj = Py_None;
8252 return resultobj;
8253 fail:
8254 return NULL;
8255 }
8256
8257
8258 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8259 PyObject *resultobj;
8260 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8261 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8262 int arg3 = (int) -1 ;
8263 PyObject * obj0 = 0 ;
8264 PyObject * obj1 = 0 ;
8265 PyObject * obj2 = 0 ;
8266 char *kwnames[] = {
8267 (char *) "self",(char *) "owner",(char *) "id", NULL
8268 };
8269
8270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8272 if (SWIG_arg_fail(1)) SWIG_fail;
8273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8274 if (SWIG_arg_fail(2)) SWIG_fail;
8275 if (obj2) {
8276 {
8277 arg3 = (int)(SWIG_As_int(obj2));
8278 if (SWIG_arg_fail(3)) SWIG_fail;
8279 }
8280 }
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 (arg1)->SetOwner(arg2,arg3);
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 Py_INCREF(Py_None); resultobj = Py_None;
8289 return resultobj;
8290 fail:
8291 return NULL;
8292 }
8293
8294
8295 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8296 PyObject *resultobj;
8297 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8298 wxEvtHandler *result;
8299 PyObject * obj0 = 0 ;
8300 char *kwnames[] = {
8301 (char *) "self", NULL
8302 };
8303
8304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8306 if (SWIG_arg_fail(1)) SWIG_fail;
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 result = (wxEvtHandler *)(arg1)->GetOwner();
8310
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 {
8315 resultobj = wxPyMake_wxObject(result, 0);
8316 }
8317 return resultobj;
8318 fail:
8319 return NULL;
8320 }
8321
8322
8323 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8324 PyObject *resultobj;
8325 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8326 int arg2 = (int) -1 ;
8327 bool arg3 = (bool) false ;
8328 bool result;
8329 PyObject * obj0 = 0 ;
8330 PyObject * obj1 = 0 ;
8331 PyObject * obj2 = 0 ;
8332 char *kwnames[] = {
8333 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8334 };
8335
8336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8338 if (SWIG_arg_fail(1)) SWIG_fail;
8339 if (obj1) {
8340 {
8341 arg2 = (int)(SWIG_As_int(obj1));
8342 if (SWIG_arg_fail(2)) SWIG_fail;
8343 }
8344 }
8345 if (obj2) {
8346 {
8347 arg3 = (bool)(SWIG_As_bool(obj2));
8348 if (SWIG_arg_fail(3)) SWIG_fail;
8349 }
8350 }
8351 {
8352 PyThreadState* __tstate = wxPyBeginAllowThreads();
8353 result = (bool)(arg1)->Start(arg2,arg3);
8354
8355 wxPyEndAllowThreads(__tstate);
8356 if (PyErr_Occurred()) SWIG_fail;
8357 }
8358 {
8359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8360 }
8361 return resultobj;
8362 fail:
8363 return NULL;
8364 }
8365
8366
8367 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8368 PyObject *resultobj;
8369 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8370 PyObject * obj0 = 0 ;
8371 char *kwnames[] = {
8372 (char *) "self", NULL
8373 };
8374
8375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8377 if (SWIG_arg_fail(1)) SWIG_fail;
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 (arg1)->Stop();
8381
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 Py_INCREF(Py_None); resultobj = Py_None;
8386 return resultobj;
8387 fail:
8388 return NULL;
8389 }
8390
8391
8392 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8393 PyObject *resultobj;
8394 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8395 bool result;
8396 PyObject * obj0 = 0 ;
8397 char *kwnames[] = {
8398 (char *) "self", NULL
8399 };
8400
8401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8403 if (SWIG_arg_fail(1)) SWIG_fail;
8404 {
8405 PyThreadState* __tstate = wxPyBeginAllowThreads();
8406 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8407
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 {
8412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8413 }
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8421 PyObject *resultobj;
8422 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8423 int result;
8424 PyObject * obj0 = 0 ;
8425 char *kwnames[] = {
8426 (char *) "self", NULL
8427 };
8428
8429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8431 if (SWIG_arg_fail(1)) SWIG_fail;
8432 {
8433 PyThreadState* __tstate = wxPyBeginAllowThreads();
8434 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8435
8436 wxPyEndAllowThreads(__tstate);
8437 if (PyErr_Occurred()) SWIG_fail;
8438 }
8439 {
8440 resultobj = SWIG_From_int((int)(result));
8441 }
8442 return resultobj;
8443 fail:
8444 return NULL;
8445 }
8446
8447
8448 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8449 PyObject *resultobj;
8450 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8451 bool result;
8452 PyObject * obj0 = 0 ;
8453 char *kwnames[] = {
8454 (char *) "self", NULL
8455 };
8456
8457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8459 if (SWIG_arg_fail(1)) SWIG_fail;
8460 {
8461 PyThreadState* __tstate = wxPyBeginAllowThreads();
8462 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8463
8464 wxPyEndAllowThreads(__tstate);
8465 if (PyErr_Occurred()) SWIG_fail;
8466 }
8467 {
8468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8469 }
8470 return resultobj;
8471 fail:
8472 return NULL;
8473 }
8474
8475
8476 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8477 PyObject *resultobj;
8478 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8479 int result;
8480 PyObject * obj0 = 0 ;
8481 char *kwnames[] = {
8482 (char *) "self", NULL
8483 };
8484
8485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8487 if (SWIG_arg_fail(1)) SWIG_fail;
8488 {
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 result = (int)((wxPyTimer const *)arg1)->GetId();
8491
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 {
8496 resultobj = SWIG_From_int((int)(result));
8497 }
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8505 PyObject *obj;
8506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8507 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8508 Py_INCREF(obj);
8509 return Py_BuildValue((char *)"");
8510 }
8511 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj;
8513 int arg1 = (int) 0 ;
8514 int arg2 = (int) 0 ;
8515 wxTimerEvent *result;
8516 PyObject * obj0 = 0 ;
8517 PyObject * obj1 = 0 ;
8518 char *kwnames[] = {
8519 (char *) "timerid",(char *) "interval", NULL
8520 };
8521
8522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8523 if (obj0) {
8524 {
8525 arg1 = (int)(SWIG_As_int(obj0));
8526 if (SWIG_arg_fail(1)) SWIG_fail;
8527 }
8528 }
8529 if (obj1) {
8530 {
8531 arg2 = (int)(SWIG_As_int(obj1));
8532 if (SWIG_arg_fail(2)) SWIG_fail;
8533 }
8534 }
8535 {
8536 PyThreadState* __tstate = wxPyBeginAllowThreads();
8537 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8538
8539 wxPyEndAllowThreads(__tstate);
8540 if (PyErr_Occurred()) SWIG_fail;
8541 }
8542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8543 return resultobj;
8544 fail:
8545 return NULL;
8546 }
8547
8548
8549 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8550 PyObject *resultobj;
8551 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8552 int result;
8553 PyObject * obj0 = 0 ;
8554 char *kwnames[] = {
8555 (char *) "self", NULL
8556 };
8557
8558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8560 if (SWIG_arg_fail(1)) SWIG_fail;
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8564
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 {
8569 resultobj = SWIG_From_int((int)(result));
8570 }
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8578 PyObject *obj;
8579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8580 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8581 Py_INCREF(obj);
8582 return Py_BuildValue((char *)"");
8583 }
8584 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8585 PyObject *resultobj;
8586 wxTimer *arg1 = 0 ;
8587 wxTimerRunner *result;
8588 PyObject * obj0 = 0 ;
8589
8590 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8591 {
8592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8593 if (SWIG_arg_fail(1)) SWIG_fail;
8594 if (arg1 == NULL) {
8595 SWIG_null_ref("wxTimer");
8596 }
8597 if (SWIG_arg_fail(1)) SWIG_fail;
8598 }
8599 {
8600 if (!wxPyCheckForApp()) SWIG_fail;
8601 PyThreadState* __tstate = wxPyBeginAllowThreads();
8602 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8603
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8615 PyObject *resultobj;
8616 wxTimer *arg1 = 0 ;
8617 int arg2 ;
8618 bool arg3 = (bool) false ;
8619 wxTimerRunner *result;
8620 PyObject * obj0 = 0 ;
8621 PyObject * obj1 = 0 ;
8622 PyObject * obj2 = 0 ;
8623
8624 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8625 {
8626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8627 if (SWIG_arg_fail(1)) SWIG_fail;
8628 if (arg1 == NULL) {
8629 SWIG_null_ref("wxTimer");
8630 }
8631 if (SWIG_arg_fail(1)) SWIG_fail;
8632 }
8633 {
8634 arg2 = (int)(SWIG_As_int(obj1));
8635 if (SWIG_arg_fail(2)) SWIG_fail;
8636 }
8637 if (obj2) {
8638 {
8639 arg3 = (bool)(SWIG_As_bool(obj2));
8640 if (SWIG_arg_fail(3)) SWIG_fail;
8641 }
8642 }
8643 {
8644 if (!wxPyCheckForApp()) SWIG_fail;
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8647
8648 wxPyEndAllowThreads(__tstate);
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8652 return resultobj;
8653 fail:
8654 return NULL;
8655 }
8656
8657
8658 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8659 int argc;
8660 PyObject *argv[4];
8661 int ii;
8662
8663 argc = PyObject_Length(args);
8664 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8665 argv[ii] = PyTuple_GetItem(args,ii);
8666 }
8667 if (argc == 1) {
8668 int _v;
8669 {
8670 void *ptr = 0;
8671 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8672 _v = 0;
8673 PyErr_Clear();
8674 } else {
8675 _v = (ptr != 0);
8676 }
8677 }
8678 if (_v) {
8679 return _wrap_new_TimerRunner__SWIG_0(self,args);
8680 }
8681 }
8682 if ((argc >= 2) && (argc <= 3)) {
8683 int _v;
8684 {
8685 void *ptr = 0;
8686 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8687 _v = 0;
8688 PyErr_Clear();
8689 } else {
8690 _v = (ptr != 0);
8691 }
8692 }
8693 if (_v) {
8694 _v = SWIG_Check_int(argv[1]);
8695 if (_v) {
8696 if (argc <= 2) {
8697 return _wrap_new_TimerRunner__SWIG_1(self,args);
8698 }
8699 _v = SWIG_Check_bool(argv[2]);
8700 if (_v) {
8701 return _wrap_new_TimerRunner__SWIG_1(self,args);
8702 }
8703 }
8704 }
8705 }
8706
8707 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8708 return NULL;
8709 }
8710
8711
8712 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8713 PyObject *resultobj;
8714 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8715 PyObject * obj0 = 0 ;
8716 char *kwnames[] = {
8717 (char *) "self", NULL
8718 };
8719
8720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8722 if (SWIG_arg_fail(1)) SWIG_fail;
8723 {
8724 PyThreadState* __tstate = wxPyBeginAllowThreads();
8725 delete arg1;
8726
8727 wxPyEndAllowThreads(__tstate);
8728 if (PyErr_Occurred()) SWIG_fail;
8729 }
8730 Py_INCREF(Py_None); resultobj = Py_None;
8731 return resultobj;
8732 fail:
8733 return NULL;
8734 }
8735
8736
8737 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8738 PyObject *resultobj;
8739 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8740 int arg2 ;
8741 bool arg3 = (bool) false ;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 PyObject * obj2 = 0 ;
8745 char *kwnames[] = {
8746 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8747 };
8748
8749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8751 if (SWIG_arg_fail(1)) SWIG_fail;
8752 {
8753 arg2 = (int)(SWIG_As_int(obj1));
8754 if (SWIG_arg_fail(2)) SWIG_fail;
8755 }
8756 if (obj2) {
8757 {
8758 arg3 = (bool)(SWIG_As_bool(obj2));
8759 if (SWIG_arg_fail(3)) SWIG_fail;
8760 }
8761 }
8762 {
8763 PyThreadState* __tstate = wxPyBeginAllowThreads();
8764 (arg1)->Start(arg2,arg3);
8765
8766 wxPyEndAllowThreads(__tstate);
8767 if (PyErr_Occurred()) SWIG_fail;
8768 }
8769 Py_INCREF(Py_None); resultobj = Py_None;
8770 return resultobj;
8771 fail:
8772 return NULL;
8773 }
8774
8775
8776 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8777 PyObject *obj;
8778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8779 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8780 Py_INCREF(obj);
8781 return Py_BuildValue((char *)"");
8782 }
8783 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj;
8785 wxLog *result;
8786 char *kwnames[] = {
8787 NULL
8788 };
8789
8790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8791 {
8792 PyThreadState* __tstate = wxPyBeginAllowThreads();
8793 result = (wxLog *)new wxLog();
8794
8795 wxPyEndAllowThreads(__tstate);
8796 if (PyErr_Occurred()) SWIG_fail;
8797 }
8798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8799 return resultobj;
8800 fail:
8801 return NULL;
8802 }
8803
8804
8805 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8806 PyObject *resultobj;
8807 bool result;
8808 char *kwnames[] = {
8809 NULL
8810 };
8811
8812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8813 {
8814 PyThreadState* __tstate = wxPyBeginAllowThreads();
8815 result = (bool)wxLog::IsEnabled();
8816
8817 wxPyEndAllowThreads(__tstate);
8818 if (PyErr_Occurred()) SWIG_fail;
8819 }
8820 {
8821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8822 }
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8830 PyObject *resultobj;
8831 bool arg1 = (bool) true ;
8832 bool result;
8833 PyObject * obj0 = 0 ;
8834 char *kwnames[] = {
8835 (char *) "doIt", NULL
8836 };
8837
8838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8839 if (obj0) {
8840 {
8841 arg1 = (bool)(SWIG_As_bool(obj0));
8842 if (SWIG_arg_fail(1)) SWIG_fail;
8843 }
8844 }
8845 {
8846 PyThreadState* __tstate = wxPyBeginAllowThreads();
8847 result = (bool)wxLog::EnableLogging(arg1);
8848
8849 wxPyEndAllowThreads(__tstate);
8850 if (PyErr_Occurred()) SWIG_fail;
8851 }
8852 {
8853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8854 }
8855 return resultobj;
8856 fail:
8857 return NULL;
8858 }
8859
8860
8861 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8862 PyObject *resultobj;
8863 wxLogLevel arg1 ;
8864 wxChar *arg2 = (wxChar *) 0 ;
8865 time_t arg3 ;
8866 PyObject * obj0 = 0 ;
8867 PyObject * obj1 = 0 ;
8868 PyObject * obj2 = 0 ;
8869 char *kwnames[] = {
8870 (char *) "level",(char *) "szString",(char *) "t", NULL
8871 };
8872
8873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8874 {
8875 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8876 if (SWIG_arg_fail(1)) SWIG_fail;
8877 }
8878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8879 if (SWIG_arg_fail(2)) SWIG_fail;
8880 {
8881 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8882 if (SWIG_arg_fail(3)) SWIG_fail;
8883 }
8884 {
8885 PyThreadState* __tstate = wxPyBeginAllowThreads();
8886 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8887
8888 wxPyEndAllowThreads(__tstate);
8889 if (PyErr_Occurred()) SWIG_fail;
8890 }
8891 Py_INCREF(Py_None); resultobj = Py_None;
8892 return resultobj;
8893 fail:
8894 return NULL;
8895 }
8896
8897
8898 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8899 PyObject *resultobj;
8900 wxLog *arg1 = (wxLog *) 0 ;
8901 PyObject * obj0 = 0 ;
8902 char *kwnames[] = {
8903 (char *) "self", NULL
8904 };
8905
8906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8908 if (SWIG_arg_fail(1)) SWIG_fail;
8909 {
8910 PyThreadState* __tstate = wxPyBeginAllowThreads();
8911 (arg1)->Flush();
8912
8913 wxPyEndAllowThreads(__tstate);
8914 if (PyErr_Occurred()) SWIG_fail;
8915 }
8916 Py_INCREF(Py_None); resultobj = Py_None;
8917 return resultobj;
8918 fail:
8919 return NULL;
8920 }
8921
8922
8923 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj;
8925 char *kwnames[] = {
8926 NULL
8927 };
8928
8929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 wxLog::FlushActive();
8933
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 Py_INCREF(Py_None); resultobj = Py_None;
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8945 PyObject *resultobj;
8946 wxLog *result;
8947 char *kwnames[] = {
8948 NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 result = (wxLog *)wxLog::GetActiveTarget();
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8960 return resultobj;
8961 fail:
8962 return NULL;
8963 }
8964
8965
8966 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8967 PyObject *resultobj;
8968 wxLog *arg1 = (wxLog *) 0 ;
8969 wxLog *result;
8970 PyObject * obj0 = 0 ;
8971 char *kwnames[] = {
8972 (char *) "pLogger", NULL
8973 };
8974
8975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8977 if (SWIG_arg_fail(1)) SWIG_fail;
8978 {
8979 PyThreadState* __tstate = wxPyBeginAllowThreads();
8980 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8981
8982 wxPyEndAllowThreads(__tstate);
8983 if (PyErr_Occurred()) SWIG_fail;
8984 }
8985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8986 return resultobj;
8987 fail:
8988 return NULL;
8989 }
8990
8991
8992 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8993 PyObject *resultobj;
8994 char *kwnames[] = {
8995 NULL
8996 };
8997
8998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8999 {
9000 PyThreadState* __tstate = wxPyBeginAllowThreads();
9001 wxLog::Suspend();
9002
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 Py_INCREF(Py_None); resultobj = Py_None;
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9014 PyObject *resultobj;
9015 char *kwnames[] = {
9016 NULL
9017 };
9018
9019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9020 {
9021 PyThreadState* __tstate = wxPyBeginAllowThreads();
9022 wxLog::Resume();
9023
9024 wxPyEndAllowThreads(__tstate);
9025 if (PyErr_Occurred()) SWIG_fail;
9026 }
9027 Py_INCREF(Py_None); resultobj = Py_None;
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9035 PyObject *resultobj;
9036 bool arg1 = (bool) true ;
9037 PyObject * obj0 = 0 ;
9038 char *kwnames[] = {
9039 (char *) "bVerbose", NULL
9040 };
9041
9042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9043 if (obj0) {
9044 {
9045 arg1 = (bool)(SWIG_As_bool(obj0));
9046 if (SWIG_arg_fail(1)) SWIG_fail;
9047 }
9048 }
9049 {
9050 PyThreadState* __tstate = wxPyBeginAllowThreads();
9051 wxLog::SetVerbose(arg1);
9052
9053 wxPyEndAllowThreads(__tstate);
9054 if (PyErr_Occurred()) SWIG_fail;
9055 }
9056 Py_INCREF(Py_None); resultobj = Py_None;
9057 return resultobj;
9058 fail:
9059 return NULL;
9060 }
9061
9062
9063 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9064 PyObject *resultobj;
9065 wxLogLevel arg1 ;
9066 PyObject * obj0 = 0 ;
9067 char *kwnames[] = {
9068 (char *) "logLevel", NULL
9069 };
9070
9071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9072 {
9073 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9074 if (SWIG_arg_fail(1)) SWIG_fail;
9075 }
9076 {
9077 PyThreadState* __tstate = wxPyBeginAllowThreads();
9078 wxLog::SetLogLevel(arg1);
9079
9080 wxPyEndAllowThreads(__tstate);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 Py_INCREF(Py_None); resultobj = Py_None;
9084 return resultobj;
9085 fail:
9086 return NULL;
9087 }
9088
9089
9090 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9091 PyObject *resultobj;
9092 char *kwnames[] = {
9093 NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9097 {
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 wxLog::DontCreateOnDemand();
9100
9101 wxPyEndAllowThreads(__tstate);
9102 if (PyErr_Occurred()) SWIG_fail;
9103 }
9104 Py_INCREF(Py_None); resultobj = Py_None;
9105 return resultobj;
9106 fail:
9107 return NULL;
9108 }
9109
9110
9111 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9112 PyObject *resultobj;
9113 wxTraceMask arg1 ;
9114 PyObject * obj0 = 0 ;
9115 char *kwnames[] = {
9116 (char *) "ulMask", NULL
9117 };
9118
9119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9120 {
9121 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9122 if (SWIG_arg_fail(1)) SWIG_fail;
9123 }
9124 {
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 wxLog::SetTraceMask(arg1);
9127
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 Py_INCREF(Py_None); resultobj = Py_None;
9132 return resultobj;
9133 fail:
9134 return NULL;
9135 }
9136
9137
9138 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9139 PyObject *resultobj;
9140 wxString *arg1 = 0 ;
9141 bool temp1 = false ;
9142 PyObject * obj0 = 0 ;
9143 char *kwnames[] = {
9144 (char *) "str", NULL
9145 };
9146
9147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9148 {
9149 arg1 = wxString_in_helper(obj0);
9150 if (arg1 == NULL) SWIG_fail;
9151 temp1 = true;
9152 }
9153 {
9154 PyThreadState* __tstate = wxPyBeginAllowThreads();
9155 wxLog::AddTraceMask((wxString const &)*arg1);
9156
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 Py_INCREF(Py_None); resultobj = Py_None;
9161 {
9162 if (temp1)
9163 delete arg1;
9164 }
9165 return resultobj;
9166 fail:
9167 {
9168 if (temp1)
9169 delete arg1;
9170 }
9171 return NULL;
9172 }
9173
9174
9175 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9176 PyObject *resultobj;
9177 wxString *arg1 = 0 ;
9178 bool temp1 = false ;
9179 PyObject * obj0 = 0 ;
9180 char *kwnames[] = {
9181 (char *) "str", NULL
9182 };
9183
9184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9185 {
9186 arg1 = wxString_in_helper(obj0);
9187 if (arg1 == NULL) SWIG_fail;
9188 temp1 = true;
9189 }
9190 {
9191 PyThreadState* __tstate = wxPyBeginAllowThreads();
9192 wxLog::RemoveTraceMask((wxString const &)*arg1);
9193
9194 wxPyEndAllowThreads(__tstate);
9195 if (PyErr_Occurred()) SWIG_fail;
9196 }
9197 Py_INCREF(Py_None); resultobj = Py_None;
9198 {
9199 if (temp1)
9200 delete arg1;
9201 }
9202 return resultobj;
9203 fail:
9204 {
9205 if (temp1)
9206 delete arg1;
9207 }
9208 return NULL;
9209 }
9210
9211
9212 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9213 PyObject *resultobj;
9214 char *kwnames[] = {
9215 NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 wxLog::ClearTraceMasks();
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 Py_INCREF(Py_None); resultobj = Py_None;
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9234 PyObject *resultobj;
9235 wxArrayString *result;
9236 char *kwnames[] = {
9237 NULL
9238 };
9239
9240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 {
9244 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9245 result = (wxArrayString *) &_result_ref;
9246 }
9247
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 {
9252 resultobj = wxArrayString2PyList_helper(*result);
9253 }
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj;
9262 wxChar *arg1 = (wxChar *) 0 ;
9263 PyObject * obj0 = 0 ;
9264 char *kwnames[] = {
9265 (char *) "ts", NULL
9266 };
9267
9268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9270 if (SWIG_arg_fail(1)) SWIG_fail;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 wxLog::SetTimestamp((wxChar const *)arg1);
9274
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 Py_INCREF(Py_None); resultobj = Py_None;
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9286 PyObject *resultobj;
9287 bool result;
9288 char *kwnames[] = {
9289 NULL
9290 };
9291
9292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9293 {
9294 PyThreadState* __tstate = wxPyBeginAllowThreads();
9295 result = (bool)wxLog::GetVerbose();
9296
9297 wxPyEndAllowThreads(__tstate);
9298 if (PyErr_Occurred()) SWIG_fail;
9299 }
9300 {
9301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9302 }
9303 return resultobj;
9304 fail:
9305 return NULL;
9306 }
9307
9308
9309 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9310 PyObject *resultobj;
9311 wxTraceMask result;
9312 char *kwnames[] = {
9313 NULL
9314 };
9315
9316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 result = (wxTraceMask)wxLog::GetTraceMask();
9320
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 {
9325 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9326 }
9327 return resultobj;
9328 fail:
9329 return NULL;
9330 }
9331
9332
9333 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj;
9335 wxChar *arg1 = (wxChar *) 0 ;
9336 bool result;
9337 PyObject * obj0 = 0 ;
9338 char *kwnames[] = {
9339 (char *) "mask", NULL
9340 };
9341
9342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9344 if (SWIG_arg_fail(1)) SWIG_fail;
9345 {
9346 PyThreadState* __tstate = wxPyBeginAllowThreads();
9347 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9348
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 {
9353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9354 }
9355 return resultobj;
9356 fail:
9357 return NULL;
9358 }
9359
9360
9361 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9362 PyObject *resultobj;
9363 wxLogLevel result;
9364 char *kwnames[] = {
9365 NULL
9366 };
9367
9368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9369 {
9370 PyThreadState* __tstate = wxPyBeginAllowThreads();
9371 result = (wxLogLevel)wxLog::GetLogLevel();
9372
9373 wxPyEndAllowThreads(__tstate);
9374 if (PyErr_Occurred()) SWIG_fail;
9375 }
9376 {
9377 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9378 }
9379 return resultobj;
9380 fail:
9381 return NULL;
9382 }
9383
9384
9385 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9386 PyObject *resultobj;
9387 wxChar *result;
9388 char *kwnames[] = {
9389 NULL
9390 };
9391
9392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9393 {
9394 PyThreadState* __tstate = wxPyBeginAllowThreads();
9395 result = (wxChar *)wxLog::GetTimestamp();
9396
9397 wxPyEndAllowThreads(__tstate);
9398 if (PyErr_Occurred()) SWIG_fail;
9399 }
9400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9401 return resultobj;
9402 fail:
9403 return NULL;
9404 }
9405
9406
9407 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9408 PyObject *resultobj;
9409 wxString result;
9410 char *kwnames[] = {
9411 NULL
9412 };
9413
9414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = Log_TimeStamp();
9418
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 {
9423 #if wxUSE_UNICODE
9424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9425 #else
9426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9427 #endif
9428 }
9429 return resultobj;
9430 fail:
9431 return NULL;
9432 }
9433
9434
9435 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9436 PyObject *resultobj;
9437 wxLog *arg1 = (wxLog *) 0 ;
9438 PyObject * obj0 = 0 ;
9439 char *kwnames[] = {
9440 (char *) "self", NULL
9441 };
9442
9443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9445 if (SWIG_arg_fail(1)) SWIG_fail;
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 wxLog_Destroy(arg1);
9449
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 Py_INCREF(Py_None); resultobj = Py_None;
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9461 PyObject *obj;
9462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9463 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9464 Py_INCREF(obj);
9465 return Py_BuildValue((char *)"");
9466 }
9467 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9468 PyObject *resultobj;
9469 wxLogStderr *result;
9470 char *kwnames[] = {
9471 NULL
9472 };
9473
9474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (wxLogStderr *)new wxLogStderr();
9478
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9490 PyObject *obj;
9491 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9492 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9493 Py_INCREF(obj);
9494 return Py_BuildValue((char *)"");
9495 }
9496 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9497 PyObject *resultobj;
9498 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9499 wxLogTextCtrl *result;
9500 PyObject * obj0 = 0 ;
9501 char *kwnames[] = {
9502 (char *) "pTextCtrl", NULL
9503 };
9504
9505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9507 if (SWIG_arg_fail(1)) SWIG_fail;
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9511
9512 wxPyEndAllowThreads(__tstate);
9513 if (PyErr_Occurred()) SWIG_fail;
9514 }
9515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9516 return resultobj;
9517 fail:
9518 return NULL;
9519 }
9520
9521
9522 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9523 PyObject *obj;
9524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9525 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9526 Py_INCREF(obj);
9527 return Py_BuildValue((char *)"");
9528 }
9529 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj;
9531 wxLogGui *result;
9532 char *kwnames[] = {
9533 NULL
9534 };
9535
9536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 result = (wxLogGui *)new wxLogGui();
9540
9541 wxPyEndAllowThreads(__tstate);
9542 if (PyErr_Occurred()) SWIG_fail;
9543 }
9544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9545 return resultobj;
9546 fail:
9547 return NULL;
9548 }
9549
9550
9551 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9552 PyObject *obj;
9553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9554 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9555 Py_INCREF(obj);
9556 return Py_BuildValue((char *)"");
9557 }
9558 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj;
9560 wxFrame *arg1 = (wxFrame *) 0 ;
9561 wxString *arg2 = 0 ;
9562 bool arg3 = (bool) true ;
9563 bool arg4 = (bool) true ;
9564 wxLogWindow *result;
9565 bool temp2 = false ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 PyObject * obj2 = 0 ;
9569 PyObject * obj3 = 0 ;
9570 char *kwnames[] = {
9571 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9572 };
9573
9574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9576 if (SWIG_arg_fail(1)) SWIG_fail;
9577 {
9578 arg2 = wxString_in_helper(obj1);
9579 if (arg2 == NULL) SWIG_fail;
9580 temp2 = true;
9581 }
9582 if (obj2) {
9583 {
9584 arg3 = (bool)(SWIG_As_bool(obj2));
9585 if (SWIG_arg_fail(3)) SWIG_fail;
9586 }
9587 }
9588 if (obj3) {
9589 {
9590 arg4 = (bool)(SWIG_As_bool(obj3));
9591 if (SWIG_arg_fail(4)) SWIG_fail;
9592 }
9593 }
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9597
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9602 {
9603 if (temp2)
9604 delete arg2;
9605 }
9606 return resultobj;
9607 fail:
9608 {
9609 if (temp2)
9610 delete arg2;
9611 }
9612 return NULL;
9613 }
9614
9615
9616 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9617 PyObject *resultobj;
9618 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9619 bool arg2 = (bool) true ;
9620 PyObject * obj0 = 0 ;
9621 PyObject * obj1 = 0 ;
9622 char *kwnames[] = {
9623 (char *) "self",(char *) "bShow", NULL
9624 };
9625
9626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9628 if (SWIG_arg_fail(1)) SWIG_fail;
9629 if (obj1) {
9630 {
9631 arg2 = (bool)(SWIG_As_bool(obj1));
9632 if (SWIG_arg_fail(2)) SWIG_fail;
9633 }
9634 }
9635 {
9636 PyThreadState* __tstate = wxPyBeginAllowThreads();
9637 (arg1)->Show(arg2);
9638
9639 wxPyEndAllowThreads(__tstate);
9640 if (PyErr_Occurred()) SWIG_fail;
9641 }
9642 Py_INCREF(Py_None); resultobj = Py_None;
9643 return resultobj;
9644 fail:
9645 return NULL;
9646 }
9647
9648
9649 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9650 PyObject *resultobj;
9651 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9652 wxFrame *result;
9653 PyObject * obj0 = 0 ;
9654 char *kwnames[] = {
9655 (char *) "self", NULL
9656 };
9657
9658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9660 if (SWIG_arg_fail(1)) SWIG_fail;
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9664
9665 wxPyEndAllowThreads(__tstate);
9666 if (PyErr_Occurred()) SWIG_fail;
9667 }
9668 {
9669 resultobj = wxPyMake_wxObject(result, 0);
9670 }
9671 return resultobj;
9672 fail:
9673 return NULL;
9674 }
9675
9676
9677 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9678 PyObject *resultobj;
9679 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9680 wxLog *result;
9681 PyObject * obj0 = 0 ;
9682 char *kwnames[] = {
9683 (char *) "self", NULL
9684 };
9685
9686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9688 if (SWIG_arg_fail(1)) SWIG_fail;
9689 {
9690 PyThreadState* __tstate = wxPyBeginAllowThreads();
9691 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9692
9693 wxPyEndAllowThreads(__tstate);
9694 if (PyErr_Occurred()) SWIG_fail;
9695 }
9696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9697 return resultobj;
9698 fail:
9699 return NULL;
9700 }
9701
9702
9703 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9704 PyObject *resultobj;
9705 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9706 bool result;
9707 PyObject * obj0 = 0 ;
9708 char *kwnames[] = {
9709 (char *) "self", NULL
9710 };
9711
9712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9714 if (SWIG_arg_fail(1)) SWIG_fail;
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9718
9719 wxPyEndAllowThreads(__tstate);
9720 if (PyErr_Occurred()) SWIG_fail;
9721 }
9722 {
9723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9724 }
9725 return resultobj;
9726 fail:
9727 return NULL;
9728 }
9729
9730
9731 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj;
9733 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9734 bool arg2 ;
9735 PyObject * obj0 = 0 ;
9736 PyObject * obj1 = 0 ;
9737 char *kwnames[] = {
9738 (char *) "self",(char *) "bDoPass", NULL
9739 };
9740
9741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9743 if (SWIG_arg_fail(1)) SWIG_fail;
9744 {
9745 arg2 = (bool)(SWIG_As_bool(obj1));
9746 if (SWIG_arg_fail(2)) SWIG_fail;
9747 }
9748 {
9749 PyThreadState* __tstate = wxPyBeginAllowThreads();
9750 (arg1)->PassMessages(arg2);
9751
9752 wxPyEndAllowThreads(__tstate);
9753 if (PyErr_Occurred()) SWIG_fail;
9754 }
9755 Py_INCREF(Py_None); resultobj = Py_None;
9756 return resultobj;
9757 fail:
9758 return NULL;
9759 }
9760
9761
9762 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9763 PyObject *obj;
9764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9765 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9766 Py_INCREF(obj);
9767 return Py_BuildValue((char *)"");
9768 }
9769 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9770 PyObject *resultobj;
9771 wxLog *arg1 = (wxLog *) 0 ;
9772 wxLogChain *result;
9773 PyObject * obj0 = 0 ;
9774 char *kwnames[] = {
9775 (char *) "logger", NULL
9776 };
9777
9778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9780 if (SWIG_arg_fail(1)) SWIG_fail;
9781 {
9782 PyThreadState* __tstate = wxPyBeginAllowThreads();
9783 result = (wxLogChain *)new wxLogChain(arg1);
9784
9785 wxPyEndAllowThreads(__tstate);
9786 if (PyErr_Occurred()) SWIG_fail;
9787 }
9788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9789 return resultobj;
9790 fail:
9791 return NULL;
9792 }
9793
9794
9795 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9796 PyObject *resultobj;
9797 wxLogChain *arg1 = (wxLogChain *) 0 ;
9798 wxLog *arg2 = (wxLog *) 0 ;
9799 PyObject * obj0 = 0 ;
9800 PyObject * obj1 = 0 ;
9801 char *kwnames[] = {
9802 (char *) "self",(char *) "logger", NULL
9803 };
9804
9805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9807 if (SWIG_arg_fail(1)) SWIG_fail;
9808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9809 if (SWIG_arg_fail(2)) SWIG_fail;
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 (arg1)->SetLog(arg2);
9813
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 Py_INCREF(Py_None); resultobj = Py_None;
9818 return resultobj;
9819 fail:
9820 return NULL;
9821 }
9822
9823
9824 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj;
9826 wxLogChain *arg1 = (wxLogChain *) 0 ;
9827 bool arg2 ;
9828 PyObject * obj0 = 0 ;
9829 PyObject * obj1 = 0 ;
9830 char *kwnames[] = {
9831 (char *) "self",(char *) "bDoPass", NULL
9832 };
9833
9834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9836 if (SWIG_arg_fail(1)) SWIG_fail;
9837 {
9838 arg2 = (bool)(SWIG_As_bool(obj1));
9839 if (SWIG_arg_fail(2)) SWIG_fail;
9840 }
9841 {
9842 PyThreadState* __tstate = wxPyBeginAllowThreads();
9843 (arg1)->PassMessages(arg2);
9844
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 Py_INCREF(Py_None); resultobj = Py_None;
9849 return resultobj;
9850 fail:
9851 return NULL;
9852 }
9853
9854
9855 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9856 PyObject *resultobj;
9857 wxLogChain *arg1 = (wxLogChain *) 0 ;
9858 bool result;
9859 PyObject * obj0 = 0 ;
9860 char *kwnames[] = {
9861 (char *) "self", NULL
9862 };
9863
9864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9866 if (SWIG_arg_fail(1)) SWIG_fail;
9867 {
9868 PyThreadState* __tstate = wxPyBeginAllowThreads();
9869 result = (bool)(arg1)->IsPassingMessages();
9870
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 {
9875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9876 }
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9884 PyObject *resultobj;
9885 wxLogChain *arg1 = (wxLogChain *) 0 ;
9886 wxLog *result;
9887 PyObject * obj0 = 0 ;
9888 char *kwnames[] = {
9889 (char *) "self", NULL
9890 };
9891
9892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9894 if (SWIG_arg_fail(1)) SWIG_fail;
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 result = (wxLog *)(arg1)->GetOldLog();
9898
9899 wxPyEndAllowThreads(__tstate);
9900 if (PyErr_Occurred()) SWIG_fail;
9901 }
9902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9903 return resultobj;
9904 fail:
9905 return NULL;
9906 }
9907
9908
9909 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9910 PyObject *obj;
9911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9912 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9913 Py_INCREF(obj);
9914 return Py_BuildValue((char *)"");
9915 }
9916 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9917 PyObject *resultobj;
9918 unsigned long result;
9919 char *kwnames[] = {
9920 NULL
9921 };
9922
9923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9924 {
9925 PyThreadState* __tstate = wxPyBeginAllowThreads();
9926 result = (unsigned long)wxSysErrorCode();
9927
9928 wxPyEndAllowThreads(__tstate);
9929 if (PyErr_Occurred()) SWIG_fail;
9930 }
9931 {
9932 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9933 }
9934 return resultobj;
9935 fail:
9936 return NULL;
9937 }
9938
9939
9940 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9941 PyObject *resultobj;
9942 unsigned long arg1 = (unsigned long) 0 ;
9943 wxString result;
9944 PyObject * obj0 = 0 ;
9945 char *kwnames[] = {
9946 (char *) "nErrCode", NULL
9947 };
9948
9949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9950 if (obj0) {
9951 {
9952 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9953 if (SWIG_arg_fail(1)) SWIG_fail;
9954 }
9955 }
9956 {
9957 PyThreadState* __tstate = wxPyBeginAllowThreads();
9958 result = wxSysErrorMsg(arg1);
9959
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 {
9964 #if wxUSE_UNICODE
9965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9966 #else
9967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9968 #endif
9969 }
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9977 PyObject *resultobj;
9978 wxString *arg1 = 0 ;
9979 bool temp1 = false ;
9980 PyObject * obj0 = 0 ;
9981 char *kwnames[] = {
9982 (char *) "msg", NULL
9983 };
9984
9985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9986 {
9987 arg1 = wxString_in_helper(obj0);
9988 if (arg1 == NULL) SWIG_fail;
9989 temp1 = true;
9990 }
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 wxPyLogFatalError((wxString const &)*arg1);
9994
9995 wxPyEndAllowThreads(__tstate);
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 Py_INCREF(Py_None); resultobj = Py_None;
9999 {
10000 if (temp1)
10001 delete arg1;
10002 }
10003 return resultobj;
10004 fail:
10005 {
10006 if (temp1)
10007 delete arg1;
10008 }
10009 return NULL;
10010 }
10011
10012
10013 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10014 PyObject *resultobj;
10015 wxString *arg1 = 0 ;
10016 bool temp1 = false ;
10017 PyObject * obj0 = 0 ;
10018 char *kwnames[] = {
10019 (char *) "msg", NULL
10020 };
10021
10022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10023 {
10024 arg1 = wxString_in_helper(obj0);
10025 if (arg1 == NULL) SWIG_fail;
10026 temp1 = true;
10027 }
10028 {
10029 PyThreadState* __tstate = wxPyBeginAllowThreads();
10030 wxPyLogError((wxString const &)*arg1);
10031
10032 wxPyEndAllowThreads(__tstate);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 Py_INCREF(Py_None); resultobj = Py_None;
10036 {
10037 if (temp1)
10038 delete arg1;
10039 }
10040 return resultobj;
10041 fail:
10042 {
10043 if (temp1)
10044 delete arg1;
10045 }
10046 return NULL;
10047 }
10048
10049
10050 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10051 PyObject *resultobj;
10052 wxString *arg1 = 0 ;
10053 bool temp1 = false ;
10054 PyObject * obj0 = 0 ;
10055 char *kwnames[] = {
10056 (char *) "msg", NULL
10057 };
10058
10059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10060 {
10061 arg1 = wxString_in_helper(obj0);
10062 if (arg1 == NULL) SWIG_fail;
10063 temp1 = true;
10064 }
10065 {
10066 PyThreadState* __tstate = wxPyBeginAllowThreads();
10067 wxPyLogWarning((wxString const &)*arg1);
10068
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 Py_INCREF(Py_None); resultobj = Py_None;
10073 {
10074 if (temp1)
10075 delete arg1;
10076 }
10077 return resultobj;
10078 fail:
10079 {
10080 if (temp1)
10081 delete arg1;
10082 }
10083 return NULL;
10084 }
10085
10086
10087 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj;
10089 wxString *arg1 = 0 ;
10090 bool temp1 = false ;
10091 PyObject * obj0 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "msg", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10097 {
10098 arg1 = wxString_in_helper(obj0);
10099 if (arg1 == NULL) SWIG_fail;
10100 temp1 = true;
10101 }
10102 {
10103 PyThreadState* __tstate = wxPyBeginAllowThreads();
10104 wxPyLogMessage((wxString const &)*arg1);
10105
10106 wxPyEndAllowThreads(__tstate);
10107 if (PyErr_Occurred()) SWIG_fail;
10108 }
10109 Py_INCREF(Py_None); resultobj = Py_None;
10110 {
10111 if (temp1)
10112 delete arg1;
10113 }
10114 return resultobj;
10115 fail:
10116 {
10117 if (temp1)
10118 delete arg1;
10119 }
10120 return NULL;
10121 }
10122
10123
10124 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10125 PyObject *resultobj;
10126 wxString *arg1 = 0 ;
10127 bool temp1 = false ;
10128 PyObject * obj0 = 0 ;
10129 char *kwnames[] = {
10130 (char *) "msg", NULL
10131 };
10132
10133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10134 {
10135 arg1 = wxString_in_helper(obj0);
10136 if (arg1 == NULL) SWIG_fail;
10137 temp1 = true;
10138 }
10139 {
10140 PyThreadState* __tstate = wxPyBeginAllowThreads();
10141 wxPyLogInfo((wxString const &)*arg1);
10142
10143 wxPyEndAllowThreads(__tstate);
10144 if (PyErr_Occurred()) SWIG_fail;
10145 }
10146 Py_INCREF(Py_None); resultobj = Py_None;
10147 {
10148 if (temp1)
10149 delete arg1;
10150 }
10151 return resultobj;
10152 fail:
10153 {
10154 if (temp1)
10155 delete arg1;
10156 }
10157 return NULL;
10158 }
10159
10160
10161 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10162 PyObject *resultobj;
10163 wxString *arg1 = 0 ;
10164 bool temp1 = false ;
10165 PyObject * obj0 = 0 ;
10166 char *kwnames[] = {
10167 (char *) "msg", NULL
10168 };
10169
10170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10171 {
10172 arg1 = wxString_in_helper(obj0);
10173 if (arg1 == NULL) SWIG_fail;
10174 temp1 = true;
10175 }
10176 {
10177 PyThreadState* __tstate = wxPyBeginAllowThreads();
10178 wxPyLogDebug((wxString const &)*arg1);
10179
10180 wxPyEndAllowThreads(__tstate);
10181 if (PyErr_Occurred()) SWIG_fail;
10182 }
10183 Py_INCREF(Py_None); resultobj = Py_None;
10184 {
10185 if (temp1)
10186 delete arg1;
10187 }
10188 return resultobj;
10189 fail:
10190 {
10191 if (temp1)
10192 delete arg1;
10193 }
10194 return NULL;
10195 }
10196
10197
10198 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10199 PyObject *resultobj;
10200 wxString *arg1 = 0 ;
10201 bool temp1 = false ;
10202 PyObject * obj0 = 0 ;
10203 char *kwnames[] = {
10204 (char *) "msg", NULL
10205 };
10206
10207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10208 {
10209 arg1 = wxString_in_helper(obj0);
10210 if (arg1 == NULL) SWIG_fail;
10211 temp1 = true;
10212 }
10213 {
10214 PyThreadState* __tstate = wxPyBeginAllowThreads();
10215 wxPyLogVerbose((wxString const &)*arg1);
10216
10217 wxPyEndAllowThreads(__tstate);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 Py_INCREF(Py_None); resultobj = Py_None;
10221 {
10222 if (temp1)
10223 delete arg1;
10224 }
10225 return resultobj;
10226 fail:
10227 {
10228 if (temp1)
10229 delete arg1;
10230 }
10231 return NULL;
10232 }
10233
10234
10235 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10236 PyObject *resultobj;
10237 wxString *arg1 = 0 ;
10238 bool temp1 = false ;
10239 PyObject * obj0 = 0 ;
10240 char *kwnames[] = {
10241 (char *) "msg", NULL
10242 };
10243
10244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10245 {
10246 arg1 = wxString_in_helper(obj0);
10247 if (arg1 == NULL) SWIG_fail;
10248 temp1 = true;
10249 }
10250 {
10251 PyThreadState* __tstate = wxPyBeginAllowThreads();
10252 wxPyLogStatus((wxString const &)*arg1);
10253
10254 wxPyEndAllowThreads(__tstate);
10255 if (PyErr_Occurred()) SWIG_fail;
10256 }
10257 Py_INCREF(Py_None); resultobj = Py_None;
10258 {
10259 if (temp1)
10260 delete arg1;
10261 }
10262 return resultobj;
10263 fail:
10264 {
10265 if (temp1)
10266 delete arg1;
10267 }
10268 return NULL;
10269 }
10270
10271
10272 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10273 PyObject *resultobj;
10274 wxFrame *arg1 = (wxFrame *) 0 ;
10275 wxString *arg2 = 0 ;
10276 bool temp2 = false ;
10277 PyObject * obj0 = 0 ;
10278 PyObject * obj1 = 0 ;
10279 char *kwnames[] = {
10280 (char *) "pFrame",(char *) "msg", NULL
10281 };
10282
10283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10285 if (SWIG_arg_fail(1)) SWIG_fail;
10286 {
10287 arg2 = wxString_in_helper(obj1);
10288 if (arg2 == NULL) SWIG_fail;
10289 temp2 = true;
10290 }
10291 {
10292 PyThreadState* __tstate = wxPyBeginAllowThreads();
10293 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10294
10295 wxPyEndAllowThreads(__tstate);
10296 if (PyErr_Occurred()) SWIG_fail;
10297 }
10298 Py_INCREF(Py_None); resultobj = Py_None;
10299 {
10300 if (temp2)
10301 delete arg2;
10302 }
10303 return resultobj;
10304 fail:
10305 {
10306 if (temp2)
10307 delete arg2;
10308 }
10309 return NULL;
10310 }
10311
10312
10313 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10314 PyObject *resultobj;
10315 wxString *arg1 = 0 ;
10316 bool temp1 = false ;
10317 PyObject * obj0 = 0 ;
10318 char *kwnames[] = {
10319 (char *) "msg", NULL
10320 };
10321
10322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10323 {
10324 arg1 = wxString_in_helper(obj0);
10325 if (arg1 == NULL) SWIG_fail;
10326 temp1 = true;
10327 }
10328 {
10329 PyThreadState* __tstate = wxPyBeginAllowThreads();
10330 wxPyLogSysError((wxString const &)*arg1);
10331
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 Py_INCREF(Py_None); resultobj = Py_None;
10336 {
10337 if (temp1)
10338 delete arg1;
10339 }
10340 return resultobj;
10341 fail:
10342 {
10343 if (temp1)
10344 delete arg1;
10345 }
10346 return NULL;
10347 }
10348
10349
10350 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj;
10352 unsigned long arg1 ;
10353 wxString *arg2 = 0 ;
10354 bool temp2 = false ;
10355 PyObject * obj0 = 0 ;
10356 PyObject * obj1 = 0 ;
10357 char *kwnames[] = {
10358 (char *) "level",(char *) "msg", NULL
10359 };
10360
10361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10362 {
10363 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10364 if (SWIG_arg_fail(1)) SWIG_fail;
10365 }
10366 {
10367 arg2 = wxString_in_helper(obj1);
10368 if (arg2 == NULL) SWIG_fail;
10369 temp2 = true;
10370 }
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10374
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 Py_INCREF(Py_None); resultobj = Py_None;
10379 {
10380 if (temp2)
10381 delete arg2;
10382 }
10383 return resultobj;
10384 fail:
10385 {
10386 if (temp2)
10387 delete arg2;
10388 }
10389 return NULL;
10390 }
10391
10392
10393 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10394 PyObject *resultobj;
10395 unsigned long arg1 ;
10396 wxString *arg2 = 0 ;
10397 bool temp2 = false ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400
10401 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10402 {
10403 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10404 if (SWIG_arg_fail(1)) SWIG_fail;
10405 }
10406 {
10407 arg2 = wxString_in_helper(obj1);
10408 if (arg2 == NULL) SWIG_fail;
10409 temp2 = true;
10410 }
10411 {
10412 PyThreadState* __tstate = wxPyBeginAllowThreads();
10413 wxPyLogTrace(arg1,(wxString const &)*arg2);
10414
10415 wxPyEndAllowThreads(__tstate);
10416 if (PyErr_Occurred()) SWIG_fail;
10417 }
10418 Py_INCREF(Py_None); resultobj = Py_None;
10419 {
10420 if (temp2)
10421 delete arg2;
10422 }
10423 return resultobj;
10424 fail:
10425 {
10426 if (temp2)
10427 delete arg2;
10428 }
10429 return NULL;
10430 }
10431
10432
10433 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10434 PyObject *resultobj;
10435 wxString *arg1 = 0 ;
10436 wxString *arg2 = 0 ;
10437 bool temp1 = false ;
10438 bool temp2 = false ;
10439 PyObject * obj0 = 0 ;
10440 PyObject * obj1 = 0 ;
10441
10442 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10443 {
10444 arg1 = wxString_in_helper(obj0);
10445 if (arg1 == NULL) SWIG_fail;
10446 temp1 = true;
10447 }
10448 {
10449 arg2 = wxString_in_helper(obj1);
10450 if (arg2 == NULL) SWIG_fail;
10451 temp2 = true;
10452 }
10453 {
10454 PyThreadState* __tstate = wxPyBeginAllowThreads();
10455 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10456
10457 wxPyEndAllowThreads(__tstate);
10458 if (PyErr_Occurred()) SWIG_fail;
10459 }
10460 Py_INCREF(Py_None); resultobj = Py_None;
10461 {
10462 if (temp1)
10463 delete arg1;
10464 }
10465 {
10466 if (temp2)
10467 delete arg2;
10468 }
10469 return resultobj;
10470 fail:
10471 {
10472 if (temp1)
10473 delete arg1;
10474 }
10475 {
10476 if (temp2)
10477 delete arg2;
10478 }
10479 return NULL;
10480 }
10481
10482
10483 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10484 int argc;
10485 PyObject *argv[3];
10486 int ii;
10487
10488 argc = PyObject_Length(args);
10489 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10490 argv[ii] = PyTuple_GetItem(args,ii);
10491 }
10492 if (argc == 2) {
10493 int _v;
10494 {
10495 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10496 }
10497 if (_v) {
10498 {
10499 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10500 }
10501 if (_v) {
10502 return _wrap_LogTrace__SWIG_1(self,args);
10503 }
10504 }
10505 }
10506 if (argc == 2) {
10507 int _v;
10508 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10509 if (_v) {
10510 {
10511 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10512 }
10513 if (_v) {
10514 return _wrap_LogTrace__SWIG_0(self,args);
10515 }
10516 }
10517 }
10518
10519 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10520 return NULL;
10521 }
10522
10523
10524 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10525 PyObject *resultobj;
10526 wxString *arg1 = 0 ;
10527 wxString *arg2 = 0 ;
10528 bool temp1 = false ;
10529 bool temp2 = false ;
10530 PyObject * obj0 = 0 ;
10531 PyObject * obj1 = 0 ;
10532 char *kwnames[] = {
10533 (char *) "title",(char *) "text", NULL
10534 };
10535
10536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10537 {
10538 arg1 = wxString_in_helper(obj0);
10539 if (arg1 == NULL) SWIG_fail;
10540 temp1 = true;
10541 }
10542 {
10543 arg2 = wxString_in_helper(obj1);
10544 if (arg2 == NULL) SWIG_fail;
10545 temp2 = true;
10546 }
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10550
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 Py_INCREF(Py_None); resultobj = Py_None;
10555 {
10556 if (temp1)
10557 delete arg1;
10558 }
10559 {
10560 if (temp2)
10561 delete arg2;
10562 }
10563 return resultobj;
10564 fail:
10565 {
10566 if (temp1)
10567 delete arg1;
10568 }
10569 {
10570 if (temp2)
10571 delete arg2;
10572 }
10573 return NULL;
10574 }
10575
10576
10577 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10578 PyObject *resultobj;
10579 wxLogNull *result;
10580 char *kwnames[] = {
10581 NULL
10582 };
10583
10584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10585 {
10586 PyThreadState* __tstate = wxPyBeginAllowThreads();
10587 result = (wxLogNull *)new wxLogNull();
10588
10589 wxPyEndAllowThreads(__tstate);
10590 if (PyErr_Occurred()) SWIG_fail;
10591 }
10592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10600 PyObject *resultobj;
10601 wxLogNull *arg1 = (wxLogNull *) 0 ;
10602 PyObject * obj0 = 0 ;
10603 char *kwnames[] = {
10604 (char *) "self", NULL
10605 };
10606
10607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10609 if (SWIG_arg_fail(1)) SWIG_fail;
10610 {
10611 PyThreadState* __tstate = wxPyBeginAllowThreads();
10612 delete arg1;
10613
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 Py_INCREF(Py_None); resultobj = Py_None;
10618 return resultobj;
10619 fail:
10620 return NULL;
10621 }
10622
10623
10624 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10625 PyObject *obj;
10626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10627 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10628 Py_INCREF(obj);
10629 return Py_BuildValue((char *)"");
10630 }
10631 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10632 PyObject *resultobj;
10633 wxPyLog *result;
10634 char *kwnames[] = {
10635 NULL
10636 };
10637
10638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (wxPyLog *)new wxPyLog();
10642
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10647 return resultobj;
10648 fail:
10649 return NULL;
10650 }
10651
10652
10653 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10654 PyObject *resultobj;
10655 wxPyLog *arg1 = (wxPyLog *) 0 ;
10656 PyObject *arg2 = (PyObject *) 0 ;
10657 PyObject *arg3 = (PyObject *) 0 ;
10658 PyObject * obj0 = 0 ;
10659 PyObject * obj1 = 0 ;
10660 PyObject * obj2 = 0 ;
10661 char *kwnames[] = {
10662 (char *) "self",(char *) "self",(char *) "_class", NULL
10663 };
10664
10665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10667 if (SWIG_arg_fail(1)) SWIG_fail;
10668 arg2 = obj1;
10669 arg3 = obj2;
10670 {
10671 PyThreadState* __tstate = wxPyBeginAllowThreads();
10672 (arg1)->_setCallbackInfo(arg2,arg3);
10673
10674 wxPyEndAllowThreads(__tstate);
10675 if (PyErr_Occurred()) SWIG_fail;
10676 }
10677 Py_INCREF(Py_None); resultobj = Py_None;
10678 return resultobj;
10679 fail:
10680 return NULL;
10681 }
10682
10683
10684 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10685 PyObject *obj;
10686 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10687 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10688 Py_INCREF(obj);
10689 return Py_BuildValue((char *)"");
10690 }
10691 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj;
10693 int arg1 ;
10694 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10695 int arg3 = (int) wxKILL_NOCHILDREN ;
10696 wxKillError result;
10697 PyObject * obj0 = 0 ;
10698 PyObject * obj1 = 0 ;
10699 PyObject * obj2 = 0 ;
10700 char *kwnames[] = {
10701 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10702 };
10703
10704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10705 {
10706 arg1 = (int)(SWIG_As_int(obj0));
10707 if (SWIG_arg_fail(1)) SWIG_fail;
10708 }
10709 if (obj1) {
10710 {
10711 arg2 = (wxSignal)(SWIG_As_int(obj1));
10712 if (SWIG_arg_fail(2)) SWIG_fail;
10713 }
10714 }
10715 if (obj2) {
10716 {
10717 arg3 = (int)(SWIG_As_int(obj2));
10718 if (SWIG_arg_fail(3)) SWIG_fail;
10719 }
10720 }
10721 {
10722 PyThreadState* __tstate = wxPyBeginAllowThreads();
10723 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10724
10725 wxPyEndAllowThreads(__tstate);
10726 if (PyErr_Occurred()) SWIG_fail;
10727 }
10728 resultobj = SWIG_From_int((result));
10729 return resultobj;
10730 fail:
10731 return NULL;
10732 }
10733
10734
10735 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10736 PyObject *resultobj;
10737 int arg1 ;
10738 bool result;
10739 PyObject * obj0 = 0 ;
10740 char *kwnames[] = {
10741 (char *) "pid", NULL
10742 };
10743
10744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10745 {
10746 arg1 = (int)(SWIG_As_int(obj0));
10747 if (SWIG_arg_fail(1)) SWIG_fail;
10748 }
10749 {
10750 PyThreadState* __tstate = wxPyBeginAllowThreads();
10751 result = (bool)wxPyProcess::Exists(arg1);
10752
10753 wxPyEndAllowThreads(__tstate);
10754 if (PyErr_Occurred()) SWIG_fail;
10755 }
10756 {
10757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10758 }
10759 return resultobj;
10760 fail:
10761 return NULL;
10762 }
10763
10764
10765 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj;
10767 wxString *arg1 = 0 ;
10768 int arg2 = (int) wxEXEC_ASYNC ;
10769 wxPyProcess *result;
10770 bool temp1 = false ;
10771 PyObject * obj0 = 0 ;
10772 PyObject * obj1 = 0 ;
10773 char *kwnames[] = {
10774 (char *) "cmd",(char *) "flags", NULL
10775 };
10776
10777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10778 {
10779 arg1 = wxString_in_helper(obj0);
10780 if (arg1 == NULL) SWIG_fail;
10781 temp1 = true;
10782 }
10783 if (obj1) {
10784 {
10785 arg2 = (int)(SWIG_As_int(obj1));
10786 if (SWIG_arg_fail(2)) SWIG_fail;
10787 }
10788 }
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10792
10793 wxPyEndAllowThreads(__tstate);
10794 if (PyErr_Occurred()) SWIG_fail;
10795 }
10796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10797 {
10798 if (temp1)
10799 delete arg1;
10800 }
10801 return resultobj;
10802 fail:
10803 {
10804 if (temp1)
10805 delete arg1;
10806 }
10807 return NULL;
10808 }
10809
10810
10811 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj;
10813 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10814 int arg2 = (int) -1 ;
10815 wxPyProcess *result;
10816 PyObject * obj0 = 0 ;
10817 PyObject * obj1 = 0 ;
10818 char *kwnames[] = {
10819 (char *) "parent",(char *) "id", NULL
10820 };
10821
10822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10823 if (obj0) {
10824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10825 if (SWIG_arg_fail(1)) SWIG_fail;
10826 }
10827 if (obj1) {
10828 {
10829 arg2 = (int)(SWIG_As_int(obj1));
10830 if (SWIG_arg_fail(2)) SWIG_fail;
10831 }
10832 }
10833 {
10834 PyThreadState* __tstate = wxPyBeginAllowThreads();
10835 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10836
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj;
10849 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10850 PyObject *arg2 = (PyObject *) 0 ;
10851 PyObject *arg3 = (PyObject *) 0 ;
10852 PyObject * obj0 = 0 ;
10853 PyObject * obj1 = 0 ;
10854 PyObject * obj2 = 0 ;
10855 char *kwnames[] = {
10856 (char *) "self",(char *) "self",(char *) "_class", NULL
10857 };
10858
10859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10861 if (SWIG_arg_fail(1)) SWIG_fail;
10862 arg2 = obj1;
10863 arg3 = obj2;
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 (arg1)->_setCallbackInfo(arg2,arg3);
10867
10868 wxPyEndAllowThreads(__tstate);
10869 if (PyErr_Occurred()) SWIG_fail;
10870 }
10871 Py_INCREF(Py_None); resultobj = Py_None;
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10879 PyObject *resultobj;
10880 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10881 int arg2 ;
10882 int arg3 ;
10883 PyObject * obj0 = 0 ;
10884 PyObject * obj1 = 0 ;
10885 PyObject * obj2 = 0 ;
10886 char *kwnames[] = {
10887 (char *) "self",(char *) "pid",(char *) "status", NULL
10888 };
10889
10890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10892 if (SWIG_arg_fail(1)) SWIG_fail;
10893 {
10894 arg2 = (int)(SWIG_As_int(obj1));
10895 if (SWIG_arg_fail(2)) SWIG_fail;
10896 }
10897 {
10898 arg3 = (int)(SWIG_As_int(obj2));
10899 if (SWIG_arg_fail(3)) SWIG_fail;
10900 }
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 (arg1)->base_OnTerminate(arg2,arg3);
10904
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 Py_INCREF(Py_None); resultobj = Py_None;
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10916 PyObject *resultobj;
10917 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10918 PyObject * obj0 = 0 ;
10919 char *kwnames[] = {
10920 (char *) "self", NULL
10921 };
10922
10923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10925 if (SWIG_arg_fail(1)) SWIG_fail;
10926 {
10927 PyThreadState* __tstate = wxPyBeginAllowThreads();
10928 (arg1)->Redirect();
10929
10930 wxPyEndAllowThreads(__tstate);
10931 if (PyErr_Occurred()) SWIG_fail;
10932 }
10933 Py_INCREF(Py_None); resultobj = Py_None;
10934 return resultobj;
10935 fail:
10936 return NULL;
10937 }
10938
10939
10940 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10941 PyObject *resultobj;
10942 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10943 bool result;
10944 PyObject * obj0 = 0 ;
10945 char *kwnames[] = {
10946 (char *) "self", NULL
10947 };
10948
10949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10951 if (SWIG_arg_fail(1)) SWIG_fail;
10952 {
10953 PyThreadState* __tstate = wxPyBeginAllowThreads();
10954 result = (bool)(arg1)->IsRedirected();
10955
10956 wxPyEndAllowThreads(__tstate);
10957 if (PyErr_Occurred()) SWIG_fail;
10958 }
10959 {
10960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10961 }
10962 return resultobj;
10963 fail:
10964 return NULL;
10965 }
10966
10967
10968 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10969 PyObject *resultobj;
10970 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10971 PyObject * obj0 = 0 ;
10972 char *kwnames[] = {
10973 (char *) "self", NULL
10974 };
10975
10976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10978 if (SWIG_arg_fail(1)) SWIG_fail;
10979 {
10980 PyThreadState* __tstate = wxPyBeginAllowThreads();
10981 (arg1)->Detach();
10982
10983 wxPyEndAllowThreads(__tstate);
10984 if (PyErr_Occurred()) SWIG_fail;
10985 }
10986 Py_INCREF(Py_None); resultobj = Py_None;
10987 return resultobj;
10988 fail:
10989 return NULL;
10990 }
10991
10992
10993 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10994 PyObject *resultobj;
10995 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10996 wxInputStream *result;
10997 PyObject * obj0 = 0 ;
10998 char *kwnames[] = {
10999 (char *) "self", NULL
11000 };
11001
11002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11004 if (SWIG_arg_fail(1)) SWIG_fail;
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 result = (wxInputStream *)(arg1)->GetInputStream();
11008
11009 wxPyEndAllowThreads(__tstate);
11010 if (PyErr_Occurred()) SWIG_fail;
11011 }
11012 {
11013 wxPyInputStream * _ptr = NULL;
11014
11015 if (result) {
11016 _ptr = new wxPyInputStream(result);
11017 }
11018 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11019 }
11020 return resultobj;
11021 fail:
11022 return NULL;
11023 }
11024
11025
11026 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11027 PyObject *resultobj;
11028 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11029 wxInputStream *result;
11030 PyObject * obj0 = 0 ;
11031 char *kwnames[] = {
11032 (char *) "self", NULL
11033 };
11034
11035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11037 if (SWIG_arg_fail(1)) SWIG_fail;
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = (wxInputStream *)(arg1)->GetErrorStream();
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 wxPyInputStream * _ptr = NULL;
11047
11048 if (result) {
11049 _ptr = new wxPyInputStream(result);
11050 }
11051 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11052 }
11053 return resultobj;
11054 fail:
11055 return NULL;
11056 }
11057
11058
11059 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11060 PyObject *resultobj;
11061 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11062 wxOutputStream *result;
11063 PyObject * obj0 = 0 ;
11064 char *kwnames[] = {
11065 (char *) "self", NULL
11066 };
11067
11068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11070 if (SWIG_arg_fail(1)) SWIG_fail;
11071 {
11072 PyThreadState* __tstate = wxPyBeginAllowThreads();
11073 result = (wxOutputStream *)(arg1)->GetOutputStream();
11074
11075 wxPyEndAllowThreads(__tstate);
11076 if (PyErr_Occurred()) SWIG_fail;
11077 }
11078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11079 return resultobj;
11080 fail:
11081 return NULL;
11082 }
11083
11084
11085 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11086 PyObject *resultobj;
11087 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11088 PyObject * obj0 = 0 ;
11089 char *kwnames[] = {
11090 (char *) "self", NULL
11091 };
11092
11093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11095 if (SWIG_arg_fail(1)) SWIG_fail;
11096 {
11097 PyThreadState* __tstate = wxPyBeginAllowThreads();
11098 (arg1)->CloseOutput();
11099
11100 wxPyEndAllowThreads(__tstate);
11101 if (PyErr_Occurred()) SWIG_fail;
11102 }
11103 Py_INCREF(Py_None); resultobj = Py_None;
11104 return resultobj;
11105 fail:
11106 return NULL;
11107 }
11108
11109
11110 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11111 PyObject *resultobj;
11112 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11113 bool result;
11114 PyObject * obj0 = 0 ;
11115 char *kwnames[] = {
11116 (char *) "self", NULL
11117 };
11118
11119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11121 if (SWIG_arg_fail(1)) SWIG_fail;
11122 {
11123 PyThreadState* __tstate = wxPyBeginAllowThreads();
11124 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11125
11126 wxPyEndAllowThreads(__tstate);
11127 if (PyErr_Occurred()) SWIG_fail;
11128 }
11129 {
11130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11131 }
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11139 PyObject *resultobj;
11140 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11141 bool result;
11142 PyObject * obj0 = 0 ;
11143 char *kwnames[] = {
11144 (char *) "self", NULL
11145 };
11146
11147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11149 if (SWIG_arg_fail(1)) SWIG_fail;
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 {
11158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11159 }
11160 return resultobj;
11161 fail:
11162 return NULL;
11163 }
11164
11165
11166 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11167 PyObject *resultobj;
11168 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11169 bool result;
11170 PyObject * obj0 = 0 ;
11171 char *kwnames[] = {
11172 (char *) "self", NULL
11173 };
11174
11175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11177 if (SWIG_arg_fail(1)) SWIG_fail;
11178 {
11179 PyThreadState* __tstate = wxPyBeginAllowThreads();
11180 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11181
11182 wxPyEndAllowThreads(__tstate);
11183 if (PyErr_Occurred()) SWIG_fail;
11184 }
11185 {
11186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11187 }
11188 return resultobj;
11189 fail:
11190 return NULL;
11191 }
11192
11193
11194 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11195 PyObject *obj;
11196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11197 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11198 Py_INCREF(obj);
11199 return Py_BuildValue((char *)"");
11200 }
11201 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11202 PyObject *resultobj;
11203 int arg1 = (int) 0 ;
11204 int arg2 = (int) 0 ;
11205 int arg3 = (int) 0 ;
11206 wxProcessEvent *result;
11207 PyObject * obj0 = 0 ;
11208 PyObject * obj1 = 0 ;
11209 PyObject * obj2 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11215 if (obj0) {
11216 {
11217 arg1 = (int)(SWIG_As_int(obj0));
11218 if (SWIG_arg_fail(1)) SWIG_fail;
11219 }
11220 }
11221 if (obj1) {
11222 {
11223 arg2 = (int)(SWIG_As_int(obj1));
11224 if (SWIG_arg_fail(2)) SWIG_fail;
11225 }
11226 }
11227 if (obj2) {
11228 {
11229 arg3 = (int)(SWIG_As_int(obj2));
11230 if (SWIG_arg_fail(3)) SWIG_fail;
11231 }
11232 }
11233 {
11234 PyThreadState* __tstate = wxPyBeginAllowThreads();
11235 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11236
11237 wxPyEndAllowThreads(__tstate);
11238 if (PyErr_Occurred()) SWIG_fail;
11239 }
11240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11241 return resultobj;
11242 fail:
11243 return NULL;
11244 }
11245
11246
11247 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11248 PyObject *resultobj;
11249 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11250 int result;
11251 PyObject * obj0 = 0 ;
11252 char *kwnames[] = {
11253 (char *) "self", NULL
11254 };
11255
11256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11258 if (SWIG_arg_fail(1)) SWIG_fail;
11259 {
11260 PyThreadState* __tstate = wxPyBeginAllowThreads();
11261 result = (int)(arg1)->GetPid();
11262
11263 wxPyEndAllowThreads(__tstate);
11264 if (PyErr_Occurred()) SWIG_fail;
11265 }
11266 {
11267 resultobj = SWIG_From_int((int)(result));
11268 }
11269 return resultobj;
11270 fail:
11271 return NULL;
11272 }
11273
11274
11275 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11276 PyObject *resultobj;
11277 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11278 int result;
11279 PyObject * obj0 = 0 ;
11280 char *kwnames[] = {
11281 (char *) "self", NULL
11282 };
11283
11284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11286 if (SWIG_arg_fail(1)) SWIG_fail;
11287 {
11288 PyThreadState* __tstate = wxPyBeginAllowThreads();
11289 result = (int)(arg1)->GetExitCode();
11290
11291 wxPyEndAllowThreads(__tstate);
11292 if (PyErr_Occurred()) SWIG_fail;
11293 }
11294 {
11295 resultobj = SWIG_From_int((int)(result));
11296 }
11297 return resultobj;
11298 fail:
11299 return NULL;
11300 }
11301
11302
11303 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11304 PyObject *resultobj;
11305 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11306 int arg2 ;
11307 PyObject * obj0 = 0 ;
11308 PyObject * obj1 = 0 ;
11309 char *kwnames[] = {
11310 (char *) "self",(char *) "m_pid", NULL
11311 };
11312
11313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11315 if (SWIG_arg_fail(1)) SWIG_fail;
11316 {
11317 arg2 = (int)(SWIG_As_int(obj1));
11318 if (SWIG_arg_fail(2)) SWIG_fail;
11319 }
11320 if (arg1) (arg1)->m_pid = arg2;
11321
11322 Py_INCREF(Py_None); resultobj = Py_None;
11323 return resultobj;
11324 fail:
11325 return NULL;
11326 }
11327
11328
11329 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11330 PyObject *resultobj;
11331 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11332 int result;
11333 PyObject * obj0 = 0 ;
11334 char *kwnames[] = {
11335 (char *) "self", NULL
11336 };
11337
11338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11340 if (SWIG_arg_fail(1)) SWIG_fail;
11341 result = (int) ((arg1)->m_pid);
11342
11343 {
11344 resultobj = SWIG_From_int((int)(result));
11345 }
11346 return resultobj;
11347 fail:
11348 return NULL;
11349 }
11350
11351
11352 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11353 PyObject *resultobj;
11354 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11355 int arg2 ;
11356 PyObject * obj0 = 0 ;
11357 PyObject * obj1 = 0 ;
11358 char *kwnames[] = {
11359 (char *) "self",(char *) "m_exitcode", NULL
11360 };
11361
11362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11364 if (SWIG_arg_fail(1)) SWIG_fail;
11365 {
11366 arg2 = (int)(SWIG_As_int(obj1));
11367 if (SWIG_arg_fail(2)) SWIG_fail;
11368 }
11369 if (arg1) (arg1)->m_exitcode = arg2;
11370
11371 Py_INCREF(Py_None); resultobj = Py_None;
11372 return resultobj;
11373 fail:
11374 return NULL;
11375 }
11376
11377
11378 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj;
11380 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11381 int result;
11382 PyObject * obj0 = 0 ;
11383 char *kwnames[] = {
11384 (char *) "self", NULL
11385 };
11386
11387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11389 if (SWIG_arg_fail(1)) SWIG_fail;
11390 result = (int) ((arg1)->m_exitcode);
11391
11392 {
11393 resultobj = SWIG_From_int((int)(result));
11394 }
11395 return resultobj;
11396 fail:
11397 return NULL;
11398 }
11399
11400
11401 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11402 PyObject *obj;
11403 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11404 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11405 Py_INCREF(obj);
11406 return Py_BuildValue((char *)"");
11407 }
11408 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11409 PyObject *resultobj;
11410 wxString *arg1 = 0 ;
11411 int arg2 = (int) wxEXEC_ASYNC ;
11412 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11413 long result;
11414 bool temp1 = false ;
11415 PyObject * obj0 = 0 ;
11416 PyObject * obj1 = 0 ;
11417 PyObject * obj2 = 0 ;
11418 char *kwnames[] = {
11419 (char *) "command",(char *) "flags",(char *) "process", NULL
11420 };
11421
11422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11423 {
11424 arg1 = wxString_in_helper(obj0);
11425 if (arg1 == NULL) SWIG_fail;
11426 temp1 = true;
11427 }
11428 if (obj1) {
11429 {
11430 arg2 = (int)(SWIG_As_int(obj1));
11431 if (SWIG_arg_fail(2)) SWIG_fail;
11432 }
11433 }
11434 if (obj2) {
11435 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11436 if (SWIG_arg_fail(3)) SWIG_fail;
11437 }
11438 {
11439 if (!wxPyCheckForApp()) SWIG_fail;
11440 PyThreadState* __tstate = wxPyBeginAllowThreads();
11441 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11442
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 {
11447 resultobj = SWIG_From_long((long)(result));
11448 }
11449 {
11450 if (temp1)
11451 delete arg1;
11452 }
11453 return resultobj;
11454 fail:
11455 {
11456 if (temp1)
11457 delete arg1;
11458 }
11459 return NULL;
11460 }
11461
11462
11463 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj;
11465 long arg1 ;
11466 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11467 wxKillError *arg3 = (wxKillError *) 0 ;
11468 int arg4 = (int) wxKILL_NOCHILDREN ;
11469 int result;
11470 wxKillError temp3 ;
11471 PyObject * obj0 = 0 ;
11472 PyObject * obj1 = 0 ;
11473 PyObject * obj2 = 0 ;
11474 char *kwnames[] = {
11475 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11476 };
11477
11478 {
11479 arg3 = &temp3;
11480 }
11481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11482 {
11483 arg1 = (long)(SWIG_As_long(obj0));
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 }
11486 if (obj1) {
11487 {
11488 arg2 = (wxSignal)(SWIG_As_int(obj1));
11489 if (SWIG_arg_fail(2)) SWIG_fail;
11490 }
11491 }
11492 if (obj2) {
11493 {
11494 arg4 = (int)(SWIG_As_int(obj2));
11495 if (SWIG_arg_fail(4)) SWIG_fail;
11496 }
11497 }
11498 {
11499 PyThreadState* __tstate = wxPyBeginAllowThreads();
11500 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11501
11502 wxPyEndAllowThreads(__tstate);
11503 if (PyErr_Occurred()) SWIG_fail;
11504 }
11505 {
11506 resultobj = SWIG_From_int((int)(result));
11507 }
11508 {
11509 PyObject* o;
11510 o = PyInt_FromLong((long) (*arg3));
11511 resultobj = t_output_helper(resultobj, o);
11512 }
11513 return resultobj;
11514 fail:
11515 return NULL;
11516 }
11517
11518
11519 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11520 PyObject *resultobj;
11521 int arg1 = (int) wxJOYSTICK1 ;
11522 wxJoystick *result;
11523 PyObject * obj0 = 0 ;
11524 char *kwnames[] = {
11525 (char *) "joystick", NULL
11526 };
11527
11528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11529 if (obj0) {
11530 {
11531 arg1 = (int)(SWIG_As_int(obj0));
11532 if (SWIG_arg_fail(1)) SWIG_fail;
11533 }
11534 }
11535 {
11536 if (!wxPyCheckForApp()) SWIG_fail;
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 result = (wxJoystick *)new wxJoystick(arg1);
11539
11540 wxPyEndAllowThreads(__tstate);
11541 if (PyErr_Occurred()) SWIG_fail;
11542 }
11543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11544 return resultobj;
11545 fail:
11546 return NULL;
11547 }
11548
11549
11550 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj;
11552 wxJoystick *arg1 = (wxJoystick *) 0 ;
11553 PyObject * obj0 = 0 ;
11554 char *kwnames[] = {
11555 (char *) "self", NULL
11556 };
11557
11558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11560 if (SWIG_arg_fail(1)) SWIG_fail;
11561 {
11562 PyThreadState* __tstate = wxPyBeginAllowThreads();
11563 delete arg1;
11564
11565 wxPyEndAllowThreads(__tstate);
11566 if (PyErr_Occurred()) SWIG_fail;
11567 }
11568 Py_INCREF(Py_None); resultobj = Py_None;
11569 return resultobj;
11570 fail:
11571 return NULL;
11572 }
11573
11574
11575 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11576 PyObject *resultobj;
11577 wxJoystick *arg1 = (wxJoystick *) 0 ;
11578 wxPoint result;
11579 PyObject * obj0 = 0 ;
11580 char *kwnames[] = {
11581 (char *) "self", NULL
11582 };
11583
11584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11586 if (SWIG_arg_fail(1)) SWIG_fail;
11587 {
11588 PyThreadState* __tstate = wxPyBeginAllowThreads();
11589 result = (arg1)->GetPosition();
11590
11591 wxPyEndAllowThreads(__tstate);
11592 if (PyErr_Occurred()) SWIG_fail;
11593 }
11594 {
11595 wxPoint * resultptr;
11596 resultptr = new wxPoint((wxPoint &)(result));
11597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11598 }
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11606 PyObject *resultobj;
11607 wxJoystick *arg1 = (wxJoystick *) 0 ;
11608 int result;
11609 PyObject * obj0 = 0 ;
11610 char *kwnames[] = {
11611 (char *) "self", NULL
11612 };
11613
11614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11616 if (SWIG_arg_fail(1)) SWIG_fail;
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 result = (int)(arg1)->GetZPosition();
11620
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 {
11625 resultobj = SWIG_From_int((int)(result));
11626 }
11627 return resultobj;
11628 fail:
11629 return NULL;
11630 }
11631
11632
11633 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11634 PyObject *resultobj;
11635 wxJoystick *arg1 = (wxJoystick *) 0 ;
11636 int result;
11637 PyObject * obj0 = 0 ;
11638 char *kwnames[] = {
11639 (char *) "self", NULL
11640 };
11641
11642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11644 if (SWIG_arg_fail(1)) SWIG_fail;
11645 {
11646 PyThreadState* __tstate = wxPyBeginAllowThreads();
11647 result = (int)(arg1)->GetButtonState();
11648
11649 wxPyEndAllowThreads(__tstate);
11650 if (PyErr_Occurred()) SWIG_fail;
11651 }
11652 {
11653 resultobj = SWIG_From_int((int)(result));
11654 }
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj;
11663 wxJoystick *arg1 = (wxJoystick *) 0 ;
11664 int result;
11665 PyObject * obj0 = 0 ;
11666 char *kwnames[] = {
11667 (char *) "self", NULL
11668 };
11669
11670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11672 if (SWIG_arg_fail(1)) SWIG_fail;
11673 {
11674 PyThreadState* __tstate = wxPyBeginAllowThreads();
11675 result = (int)(arg1)->GetPOVPosition();
11676
11677 wxPyEndAllowThreads(__tstate);
11678 if (PyErr_Occurred()) SWIG_fail;
11679 }
11680 {
11681 resultobj = SWIG_From_int((int)(result));
11682 }
11683 return resultobj;
11684 fail:
11685 return NULL;
11686 }
11687
11688
11689 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj;
11691 wxJoystick *arg1 = (wxJoystick *) 0 ;
11692 int result;
11693 PyObject * obj0 = 0 ;
11694 char *kwnames[] = {
11695 (char *) "self", NULL
11696 };
11697
11698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11700 if (SWIG_arg_fail(1)) SWIG_fail;
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (int)(arg1)->GetPOVCTSPosition();
11704
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 {
11709 resultobj = SWIG_From_int((int)(result));
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11718 PyObject *resultobj;
11719 wxJoystick *arg1 = (wxJoystick *) 0 ;
11720 int result;
11721 PyObject * obj0 = 0 ;
11722 char *kwnames[] = {
11723 (char *) "self", NULL
11724 };
11725
11726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11728 if (SWIG_arg_fail(1)) SWIG_fail;
11729 {
11730 PyThreadState* __tstate = wxPyBeginAllowThreads();
11731 result = (int)(arg1)->GetRudderPosition();
11732
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 {
11737 resultobj = SWIG_From_int((int)(result));
11738 }
11739 return resultobj;
11740 fail:
11741 return NULL;
11742 }
11743
11744
11745 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11746 PyObject *resultobj;
11747 wxJoystick *arg1 = (wxJoystick *) 0 ;
11748 int result;
11749 PyObject * obj0 = 0 ;
11750 char *kwnames[] = {
11751 (char *) "self", NULL
11752 };
11753
11754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11756 if (SWIG_arg_fail(1)) SWIG_fail;
11757 {
11758 PyThreadState* __tstate = wxPyBeginAllowThreads();
11759 result = (int)(arg1)->GetUPosition();
11760
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 {
11765 resultobj = SWIG_From_int((int)(result));
11766 }
11767 return resultobj;
11768 fail:
11769 return NULL;
11770 }
11771
11772
11773 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11774 PyObject *resultobj;
11775 wxJoystick *arg1 = (wxJoystick *) 0 ;
11776 int result;
11777 PyObject * obj0 = 0 ;
11778 char *kwnames[] = {
11779 (char *) "self", NULL
11780 };
11781
11782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11784 if (SWIG_arg_fail(1)) SWIG_fail;
11785 {
11786 PyThreadState* __tstate = wxPyBeginAllowThreads();
11787 result = (int)(arg1)->GetVPosition();
11788
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 {
11793 resultobj = SWIG_From_int((int)(result));
11794 }
11795 return resultobj;
11796 fail:
11797 return NULL;
11798 }
11799
11800
11801 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11802 PyObject *resultobj;
11803 wxJoystick *arg1 = (wxJoystick *) 0 ;
11804 int result;
11805 PyObject * obj0 = 0 ;
11806 char *kwnames[] = {
11807 (char *) "self", NULL
11808 };
11809
11810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11812 if (SWIG_arg_fail(1)) SWIG_fail;
11813 {
11814 PyThreadState* __tstate = wxPyBeginAllowThreads();
11815 result = (int)(arg1)->GetMovementThreshold();
11816
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 {
11821 resultobj = SWIG_From_int((int)(result));
11822 }
11823 return resultobj;
11824 fail:
11825 return NULL;
11826 }
11827
11828
11829 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11830 PyObject *resultobj;
11831 wxJoystick *arg1 = (wxJoystick *) 0 ;
11832 int arg2 ;
11833 PyObject * obj0 = 0 ;
11834 PyObject * obj1 = 0 ;
11835 char *kwnames[] = {
11836 (char *) "self",(char *) "threshold", NULL
11837 };
11838
11839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11841 if (SWIG_arg_fail(1)) SWIG_fail;
11842 {
11843 arg2 = (int)(SWIG_As_int(obj1));
11844 if (SWIG_arg_fail(2)) SWIG_fail;
11845 }
11846 {
11847 PyThreadState* __tstate = wxPyBeginAllowThreads();
11848 (arg1)->SetMovementThreshold(arg2);
11849
11850 wxPyEndAllowThreads(__tstate);
11851 if (PyErr_Occurred()) SWIG_fail;
11852 }
11853 Py_INCREF(Py_None); resultobj = Py_None;
11854 return resultobj;
11855 fail:
11856 return NULL;
11857 }
11858
11859
11860 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11861 PyObject *resultobj;
11862 wxJoystick *arg1 = (wxJoystick *) 0 ;
11863 bool result;
11864 PyObject * obj0 = 0 ;
11865 char *kwnames[] = {
11866 (char *) "self", NULL
11867 };
11868
11869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11871 if (SWIG_arg_fail(1)) SWIG_fail;
11872 {
11873 PyThreadState* __tstate = wxPyBeginAllowThreads();
11874 result = (bool)(arg1)->IsOk();
11875
11876 wxPyEndAllowThreads(__tstate);
11877 if (PyErr_Occurred()) SWIG_fail;
11878 }
11879 {
11880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11881 }
11882 return resultobj;
11883 fail:
11884 return NULL;
11885 }
11886
11887
11888 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj;
11890 wxJoystick *arg1 = (wxJoystick *) 0 ;
11891 int result;
11892 PyObject * obj0 = 0 ;
11893 char *kwnames[] = {
11894 (char *) "self", NULL
11895 };
11896
11897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11899 if (SWIG_arg_fail(1)) SWIG_fail;
11900 {
11901 PyThreadState* __tstate = wxPyBeginAllowThreads();
11902 result = (int)(arg1)->GetNumberJoysticks();
11903
11904 wxPyEndAllowThreads(__tstate);
11905 if (PyErr_Occurred()) SWIG_fail;
11906 }
11907 {
11908 resultobj = SWIG_From_int((int)(result));
11909 }
11910 return resultobj;
11911 fail:
11912 return NULL;
11913 }
11914
11915
11916 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11917 PyObject *resultobj;
11918 wxJoystick *arg1 = (wxJoystick *) 0 ;
11919 int result;
11920 PyObject * obj0 = 0 ;
11921 char *kwnames[] = {
11922 (char *) "self", NULL
11923 };
11924
11925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11927 if (SWIG_arg_fail(1)) SWIG_fail;
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 result = (int)(arg1)->GetManufacturerId();
11931
11932 wxPyEndAllowThreads(__tstate);
11933 if (PyErr_Occurred()) SWIG_fail;
11934 }
11935 {
11936 resultobj = SWIG_From_int((int)(result));
11937 }
11938 return resultobj;
11939 fail:
11940 return NULL;
11941 }
11942
11943
11944 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11945 PyObject *resultobj;
11946 wxJoystick *arg1 = (wxJoystick *) 0 ;
11947 int result;
11948 PyObject * obj0 = 0 ;
11949 char *kwnames[] = {
11950 (char *) "self", NULL
11951 };
11952
11953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11955 if (SWIG_arg_fail(1)) SWIG_fail;
11956 {
11957 PyThreadState* __tstate = wxPyBeginAllowThreads();
11958 result = (int)(arg1)->GetProductId();
11959
11960 wxPyEndAllowThreads(__tstate);
11961 if (PyErr_Occurred()) SWIG_fail;
11962 }
11963 {
11964 resultobj = SWIG_From_int((int)(result));
11965 }
11966 return resultobj;
11967 fail:
11968 return NULL;
11969 }
11970
11971
11972 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11973 PyObject *resultobj;
11974 wxJoystick *arg1 = (wxJoystick *) 0 ;
11975 wxString result;
11976 PyObject * obj0 = 0 ;
11977 char *kwnames[] = {
11978 (char *) "self", NULL
11979 };
11980
11981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11983 if (SWIG_arg_fail(1)) SWIG_fail;
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 result = (arg1)->GetProductName();
11987
11988 wxPyEndAllowThreads(__tstate);
11989 if (PyErr_Occurred()) SWIG_fail;
11990 }
11991 {
11992 #if wxUSE_UNICODE
11993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11994 #else
11995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11996 #endif
11997 }
11998 return resultobj;
11999 fail:
12000 return NULL;
12001 }
12002
12003
12004 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12005 PyObject *resultobj;
12006 wxJoystick *arg1 = (wxJoystick *) 0 ;
12007 int result;
12008 PyObject * obj0 = 0 ;
12009 char *kwnames[] = {
12010 (char *) "self", NULL
12011 };
12012
12013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12015 if (SWIG_arg_fail(1)) SWIG_fail;
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 result = (int)(arg1)->GetXMin();
12019
12020 wxPyEndAllowThreads(__tstate);
12021 if (PyErr_Occurred()) SWIG_fail;
12022 }
12023 {
12024 resultobj = SWIG_From_int((int)(result));
12025 }
12026 return resultobj;
12027 fail:
12028 return NULL;
12029 }
12030
12031
12032 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12033 PyObject *resultobj;
12034 wxJoystick *arg1 = (wxJoystick *) 0 ;
12035 int result;
12036 PyObject * obj0 = 0 ;
12037 char *kwnames[] = {
12038 (char *) "self", NULL
12039 };
12040
12041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12043 if (SWIG_arg_fail(1)) SWIG_fail;
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (int)(arg1)->GetYMin();
12047
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 {
12052 resultobj = SWIG_From_int((int)(result));
12053 }
12054 return resultobj;
12055 fail:
12056 return NULL;
12057 }
12058
12059
12060 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12061 PyObject *resultobj;
12062 wxJoystick *arg1 = (wxJoystick *) 0 ;
12063 int result;
12064 PyObject * obj0 = 0 ;
12065 char *kwnames[] = {
12066 (char *) "self", NULL
12067 };
12068
12069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12071 if (SWIG_arg_fail(1)) SWIG_fail;
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 result = (int)(arg1)->GetZMin();
12075
12076 wxPyEndAllowThreads(__tstate);
12077 if (PyErr_Occurred()) SWIG_fail;
12078 }
12079 {
12080 resultobj = SWIG_From_int((int)(result));
12081 }
12082 return resultobj;
12083 fail:
12084 return NULL;
12085 }
12086
12087
12088 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12089 PyObject *resultobj;
12090 wxJoystick *arg1 = (wxJoystick *) 0 ;
12091 int result;
12092 PyObject * obj0 = 0 ;
12093 char *kwnames[] = {
12094 (char *) "self", NULL
12095 };
12096
12097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12099 if (SWIG_arg_fail(1)) SWIG_fail;
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 result = (int)(arg1)->GetXMax();
12103
12104 wxPyEndAllowThreads(__tstate);
12105 if (PyErr_Occurred()) SWIG_fail;
12106 }
12107 {
12108 resultobj = SWIG_From_int((int)(result));
12109 }
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12117 PyObject *resultobj;
12118 wxJoystick *arg1 = (wxJoystick *) 0 ;
12119 int result;
12120 PyObject * obj0 = 0 ;
12121 char *kwnames[] = {
12122 (char *) "self", NULL
12123 };
12124
12125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12127 if (SWIG_arg_fail(1)) SWIG_fail;
12128 {
12129 PyThreadState* __tstate = wxPyBeginAllowThreads();
12130 result = (int)(arg1)->GetYMax();
12131
12132 wxPyEndAllowThreads(__tstate);
12133 if (PyErr_Occurred()) SWIG_fail;
12134 }
12135 {
12136 resultobj = SWIG_From_int((int)(result));
12137 }
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12145 PyObject *resultobj;
12146 wxJoystick *arg1 = (wxJoystick *) 0 ;
12147 int result;
12148 PyObject * obj0 = 0 ;
12149 char *kwnames[] = {
12150 (char *) "self", NULL
12151 };
12152
12153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12155 if (SWIG_arg_fail(1)) SWIG_fail;
12156 {
12157 PyThreadState* __tstate = wxPyBeginAllowThreads();
12158 result = (int)(arg1)->GetZMax();
12159
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 {
12164 resultobj = SWIG_From_int((int)(result));
12165 }
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12173 PyObject *resultobj;
12174 wxJoystick *arg1 = (wxJoystick *) 0 ;
12175 int result;
12176 PyObject * obj0 = 0 ;
12177 char *kwnames[] = {
12178 (char *) "self", NULL
12179 };
12180
12181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12183 if (SWIG_arg_fail(1)) SWIG_fail;
12184 {
12185 PyThreadState* __tstate = wxPyBeginAllowThreads();
12186 result = (int)(arg1)->GetNumberButtons();
12187
12188 wxPyEndAllowThreads(__tstate);
12189 if (PyErr_Occurred()) SWIG_fail;
12190 }
12191 {
12192 resultobj = SWIG_From_int((int)(result));
12193 }
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12201 PyObject *resultobj;
12202 wxJoystick *arg1 = (wxJoystick *) 0 ;
12203 int result;
12204 PyObject * obj0 = 0 ;
12205 char *kwnames[] = {
12206 (char *) "self", NULL
12207 };
12208
12209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12211 if (SWIG_arg_fail(1)) SWIG_fail;
12212 {
12213 PyThreadState* __tstate = wxPyBeginAllowThreads();
12214 result = (int)(arg1)->GetNumberAxes();
12215
12216 wxPyEndAllowThreads(__tstate);
12217 if (PyErr_Occurred()) SWIG_fail;
12218 }
12219 {
12220 resultobj = SWIG_From_int((int)(result));
12221 }
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj;
12230 wxJoystick *arg1 = (wxJoystick *) 0 ;
12231 int result;
12232 PyObject * obj0 = 0 ;
12233 char *kwnames[] = {
12234 (char *) "self", NULL
12235 };
12236
12237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12239 if (SWIG_arg_fail(1)) SWIG_fail;
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 result = (int)(arg1)->GetMaxButtons();
12243
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 {
12248 resultobj = SWIG_From_int((int)(result));
12249 }
12250 return resultobj;
12251 fail:
12252 return NULL;
12253 }
12254
12255
12256 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12257 PyObject *resultobj;
12258 wxJoystick *arg1 = (wxJoystick *) 0 ;
12259 int result;
12260 PyObject * obj0 = 0 ;
12261 char *kwnames[] = {
12262 (char *) "self", NULL
12263 };
12264
12265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12267 if (SWIG_arg_fail(1)) SWIG_fail;
12268 {
12269 PyThreadState* __tstate = wxPyBeginAllowThreads();
12270 result = (int)(arg1)->GetMaxAxes();
12271
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 {
12276 resultobj = SWIG_From_int((int)(result));
12277 }
12278 return resultobj;
12279 fail:
12280 return NULL;
12281 }
12282
12283
12284 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12285 PyObject *resultobj;
12286 wxJoystick *arg1 = (wxJoystick *) 0 ;
12287 int result;
12288 PyObject * obj0 = 0 ;
12289 char *kwnames[] = {
12290 (char *) "self", NULL
12291 };
12292
12293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12295 if (SWIG_arg_fail(1)) SWIG_fail;
12296 {
12297 PyThreadState* __tstate = wxPyBeginAllowThreads();
12298 result = (int)(arg1)->GetPollingMin();
12299
12300 wxPyEndAllowThreads(__tstate);
12301 if (PyErr_Occurred()) SWIG_fail;
12302 }
12303 {
12304 resultobj = SWIG_From_int((int)(result));
12305 }
12306 return resultobj;
12307 fail:
12308 return NULL;
12309 }
12310
12311
12312 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12313 PyObject *resultobj;
12314 wxJoystick *arg1 = (wxJoystick *) 0 ;
12315 int result;
12316 PyObject * obj0 = 0 ;
12317 char *kwnames[] = {
12318 (char *) "self", NULL
12319 };
12320
12321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12323 if (SWIG_arg_fail(1)) SWIG_fail;
12324 {
12325 PyThreadState* __tstate = wxPyBeginAllowThreads();
12326 result = (int)(arg1)->GetPollingMax();
12327
12328 wxPyEndAllowThreads(__tstate);
12329 if (PyErr_Occurred()) SWIG_fail;
12330 }
12331 {
12332 resultobj = SWIG_From_int((int)(result));
12333 }
12334 return resultobj;
12335 fail:
12336 return NULL;
12337 }
12338
12339
12340 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12341 PyObject *resultobj;
12342 wxJoystick *arg1 = (wxJoystick *) 0 ;
12343 int result;
12344 PyObject * obj0 = 0 ;
12345 char *kwnames[] = {
12346 (char *) "self", NULL
12347 };
12348
12349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12351 if (SWIG_arg_fail(1)) SWIG_fail;
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 result = (int)(arg1)->GetRudderMin();
12355
12356 wxPyEndAllowThreads(__tstate);
12357 if (PyErr_Occurred()) SWIG_fail;
12358 }
12359 {
12360 resultobj = SWIG_From_int((int)(result));
12361 }
12362 return resultobj;
12363 fail:
12364 return NULL;
12365 }
12366
12367
12368 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12369 PyObject *resultobj;
12370 wxJoystick *arg1 = (wxJoystick *) 0 ;
12371 int result;
12372 PyObject * obj0 = 0 ;
12373 char *kwnames[] = {
12374 (char *) "self", NULL
12375 };
12376
12377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12379 if (SWIG_arg_fail(1)) SWIG_fail;
12380 {
12381 PyThreadState* __tstate = wxPyBeginAllowThreads();
12382 result = (int)(arg1)->GetRudderMax();
12383
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 {
12388 resultobj = SWIG_From_int((int)(result));
12389 }
12390 return resultobj;
12391 fail:
12392 return NULL;
12393 }
12394
12395
12396 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12397 PyObject *resultobj;
12398 wxJoystick *arg1 = (wxJoystick *) 0 ;
12399 int result;
12400 PyObject * obj0 = 0 ;
12401 char *kwnames[] = {
12402 (char *) "self", NULL
12403 };
12404
12405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12407 if (SWIG_arg_fail(1)) SWIG_fail;
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 result = (int)(arg1)->GetUMin();
12411
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 {
12416 resultobj = SWIG_From_int((int)(result));
12417 }
12418 return resultobj;
12419 fail:
12420 return NULL;
12421 }
12422
12423
12424 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12425 PyObject *resultobj;
12426 wxJoystick *arg1 = (wxJoystick *) 0 ;
12427 int result;
12428 PyObject * obj0 = 0 ;
12429 char *kwnames[] = {
12430 (char *) "self", NULL
12431 };
12432
12433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12435 if (SWIG_arg_fail(1)) SWIG_fail;
12436 {
12437 PyThreadState* __tstate = wxPyBeginAllowThreads();
12438 result = (int)(arg1)->GetUMax();
12439
12440 wxPyEndAllowThreads(__tstate);
12441 if (PyErr_Occurred()) SWIG_fail;
12442 }
12443 {
12444 resultobj = SWIG_From_int((int)(result));
12445 }
12446 return resultobj;
12447 fail:
12448 return NULL;
12449 }
12450
12451
12452 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12453 PyObject *resultobj;
12454 wxJoystick *arg1 = (wxJoystick *) 0 ;
12455 int result;
12456 PyObject * obj0 = 0 ;
12457 char *kwnames[] = {
12458 (char *) "self", NULL
12459 };
12460
12461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12463 if (SWIG_arg_fail(1)) SWIG_fail;
12464 {
12465 PyThreadState* __tstate = wxPyBeginAllowThreads();
12466 result = (int)(arg1)->GetVMin();
12467
12468 wxPyEndAllowThreads(__tstate);
12469 if (PyErr_Occurred()) SWIG_fail;
12470 }
12471 {
12472 resultobj = SWIG_From_int((int)(result));
12473 }
12474 return resultobj;
12475 fail:
12476 return NULL;
12477 }
12478
12479
12480 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12481 PyObject *resultobj;
12482 wxJoystick *arg1 = (wxJoystick *) 0 ;
12483 int result;
12484 PyObject * obj0 = 0 ;
12485 char *kwnames[] = {
12486 (char *) "self", NULL
12487 };
12488
12489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12491 if (SWIG_arg_fail(1)) SWIG_fail;
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 result = (int)(arg1)->GetVMax();
12495
12496 wxPyEndAllowThreads(__tstate);
12497 if (PyErr_Occurred()) SWIG_fail;
12498 }
12499 {
12500 resultobj = SWIG_From_int((int)(result));
12501 }
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12509 PyObject *resultobj;
12510 wxJoystick *arg1 = (wxJoystick *) 0 ;
12511 bool result;
12512 PyObject * obj0 = 0 ;
12513 char *kwnames[] = {
12514 (char *) "self", NULL
12515 };
12516
12517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12519 if (SWIG_arg_fail(1)) SWIG_fail;
12520 {
12521 PyThreadState* __tstate = wxPyBeginAllowThreads();
12522 result = (bool)(arg1)->HasRudder();
12523
12524 wxPyEndAllowThreads(__tstate);
12525 if (PyErr_Occurred()) SWIG_fail;
12526 }
12527 {
12528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12529 }
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj;
12538 wxJoystick *arg1 = (wxJoystick *) 0 ;
12539 bool result;
12540 PyObject * obj0 = 0 ;
12541 char *kwnames[] = {
12542 (char *) "self", NULL
12543 };
12544
12545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12547 if (SWIG_arg_fail(1)) SWIG_fail;
12548 {
12549 PyThreadState* __tstate = wxPyBeginAllowThreads();
12550 result = (bool)(arg1)->HasZ();
12551
12552 wxPyEndAllowThreads(__tstate);
12553 if (PyErr_Occurred()) SWIG_fail;
12554 }
12555 {
12556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12557 }
12558 return resultobj;
12559 fail:
12560 return NULL;
12561 }
12562
12563
12564 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12565 PyObject *resultobj;
12566 wxJoystick *arg1 = (wxJoystick *) 0 ;
12567 bool result;
12568 PyObject * obj0 = 0 ;
12569 char *kwnames[] = {
12570 (char *) "self", NULL
12571 };
12572
12573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12575 if (SWIG_arg_fail(1)) SWIG_fail;
12576 {
12577 PyThreadState* __tstate = wxPyBeginAllowThreads();
12578 result = (bool)(arg1)->HasU();
12579
12580 wxPyEndAllowThreads(__tstate);
12581 if (PyErr_Occurred()) SWIG_fail;
12582 }
12583 {
12584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12585 }
12586 return resultobj;
12587 fail:
12588 return NULL;
12589 }
12590
12591
12592 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12593 PyObject *resultobj;
12594 wxJoystick *arg1 = (wxJoystick *) 0 ;
12595 bool result;
12596 PyObject * obj0 = 0 ;
12597 char *kwnames[] = {
12598 (char *) "self", NULL
12599 };
12600
12601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12603 if (SWIG_arg_fail(1)) SWIG_fail;
12604 {
12605 PyThreadState* __tstate = wxPyBeginAllowThreads();
12606 result = (bool)(arg1)->HasV();
12607
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 {
12612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12613 }
12614 return resultobj;
12615 fail:
12616 return NULL;
12617 }
12618
12619
12620 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12621 PyObject *resultobj;
12622 wxJoystick *arg1 = (wxJoystick *) 0 ;
12623 bool result;
12624 PyObject * obj0 = 0 ;
12625 char *kwnames[] = {
12626 (char *) "self", NULL
12627 };
12628
12629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12631 if (SWIG_arg_fail(1)) SWIG_fail;
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 result = (bool)(arg1)->HasPOV();
12635
12636 wxPyEndAllowThreads(__tstate);
12637 if (PyErr_Occurred()) SWIG_fail;
12638 }
12639 {
12640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12641 }
12642 return resultobj;
12643 fail:
12644 return NULL;
12645 }
12646
12647
12648 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12649 PyObject *resultobj;
12650 wxJoystick *arg1 = (wxJoystick *) 0 ;
12651 bool result;
12652 PyObject * obj0 = 0 ;
12653 char *kwnames[] = {
12654 (char *) "self", NULL
12655 };
12656
12657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12659 if (SWIG_arg_fail(1)) SWIG_fail;
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 result = (bool)(arg1)->HasPOV4Dir();
12663
12664 wxPyEndAllowThreads(__tstate);
12665 if (PyErr_Occurred()) SWIG_fail;
12666 }
12667 {
12668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12669 }
12670 return resultobj;
12671 fail:
12672 return NULL;
12673 }
12674
12675
12676 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12677 PyObject *resultobj;
12678 wxJoystick *arg1 = (wxJoystick *) 0 ;
12679 bool result;
12680 PyObject * obj0 = 0 ;
12681 char *kwnames[] = {
12682 (char *) "self", NULL
12683 };
12684
12685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12687 if (SWIG_arg_fail(1)) SWIG_fail;
12688 {
12689 PyThreadState* __tstate = wxPyBeginAllowThreads();
12690 result = (bool)(arg1)->HasPOVCTS();
12691
12692 wxPyEndAllowThreads(__tstate);
12693 if (PyErr_Occurred()) SWIG_fail;
12694 }
12695 {
12696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12697 }
12698 return resultobj;
12699 fail:
12700 return NULL;
12701 }
12702
12703
12704 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12705 PyObject *resultobj;
12706 wxJoystick *arg1 = (wxJoystick *) 0 ;
12707 wxWindow *arg2 = (wxWindow *) 0 ;
12708 int arg3 = (int) 0 ;
12709 bool result;
12710 PyObject * obj0 = 0 ;
12711 PyObject * obj1 = 0 ;
12712 PyObject * obj2 = 0 ;
12713 char *kwnames[] = {
12714 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12715 };
12716
12717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12719 if (SWIG_arg_fail(1)) SWIG_fail;
12720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12721 if (SWIG_arg_fail(2)) SWIG_fail;
12722 if (obj2) {
12723 {
12724 arg3 = (int)(SWIG_As_int(obj2));
12725 if (SWIG_arg_fail(3)) SWIG_fail;
12726 }
12727 }
12728 {
12729 PyThreadState* __tstate = wxPyBeginAllowThreads();
12730 result = (bool)(arg1)->SetCapture(arg2,arg3);
12731
12732 wxPyEndAllowThreads(__tstate);
12733 if (PyErr_Occurred()) SWIG_fail;
12734 }
12735 {
12736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12737 }
12738 return resultobj;
12739 fail:
12740 return NULL;
12741 }
12742
12743
12744 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12745 PyObject *resultobj;
12746 wxJoystick *arg1 = (wxJoystick *) 0 ;
12747 bool result;
12748 PyObject * obj0 = 0 ;
12749 char *kwnames[] = {
12750 (char *) "self", NULL
12751 };
12752
12753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12755 if (SWIG_arg_fail(1)) SWIG_fail;
12756 {
12757 PyThreadState* __tstate = wxPyBeginAllowThreads();
12758 result = (bool)(arg1)->ReleaseCapture();
12759
12760 wxPyEndAllowThreads(__tstate);
12761 if (PyErr_Occurred()) SWIG_fail;
12762 }
12763 {
12764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12765 }
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12773 PyObject *obj;
12774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12775 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12776 Py_INCREF(obj);
12777 return Py_BuildValue((char *)"");
12778 }
12779 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12780 PyObject *resultobj;
12781 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12782 int arg2 = (int) 0 ;
12783 int arg3 = (int) wxJOYSTICK1 ;
12784 int arg4 = (int) 0 ;
12785 wxJoystickEvent *result;
12786 PyObject * obj0 = 0 ;
12787 PyObject * obj1 = 0 ;
12788 PyObject * obj2 = 0 ;
12789 PyObject * obj3 = 0 ;
12790 char *kwnames[] = {
12791 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12792 };
12793
12794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12795 if (obj0) {
12796 {
12797 arg1 = (wxEventType)(SWIG_As_int(obj0));
12798 if (SWIG_arg_fail(1)) SWIG_fail;
12799 }
12800 }
12801 if (obj1) {
12802 {
12803 arg2 = (int)(SWIG_As_int(obj1));
12804 if (SWIG_arg_fail(2)) SWIG_fail;
12805 }
12806 }
12807 if (obj2) {
12808 {
12809 arg3 = (int)(SWIG_As_int(obj2));
12810 if (SWIG_arg_fail(3)) SWIG_fail;
12811 }
12812 }
12813 if (obj3) {
12814 {
12815 arg4 = (int)(SWIG_As_int(obj3));
12816 if (SWIG_arg_fail(4)) SWIG_fail;
12817 }
12818 }
12819 {
12820 PyThreadState* __tstate = wxPyBeginAllowThreads();
12821 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12822
12823 wxPyEndAllowThreads(__tstate);
12824 if (PyErr_Occurred()) SWIG_fail;
12825 }
12826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12827 return resultobj;
12828 fail:
12829 return NULL;
12830 }
12831
12832
12833 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12834 PyObject *resultobj;
12835 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12836 wxPoint result;
12837 PyObject * obj0 = 0 ;
12838 char *kwnames[] = {
12839 (char *) "self", NULL
12840 };
12841
12842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12844 if (SWIG_arg_fail(1)) SWIG_fail;
12845 {
12846 PyThreadState* __tstate = wxPyBeginAllowThreads();
12847 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12848
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 {
12853 wxPoint * resultptr;
12854 resultptr = new wxPoint((wxPoint &)(result));
12855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12856 }
12857 return resultobj;
12858 fail:
12859 return NULL;
12860 }
12861
12862
12863 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12864 PyObject *resultobj;
12865 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12866 int result;
12867 PyObject * obj0 = 0 ;
12868 char *kwnames[] = {
12869 (char *) "self", NULL
12870 };
12871
12872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12874 if (SWIG_arg_fail(1)) SWIG_fail;
12875 {
12876 PyThreadState* __tstate = wxPyBeginAllowThreads();
12877 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12878
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 {
12883 resultobj = SWIG_From_int((int)(result));
12884 }
12885 return resultobj;
12886 fail:
12887 return NULL;
12888 }
12889
12890
12891 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12892 PyObject *resultobj;
12893 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12894 int result;
12895 PyObject * obj0 = 0 ;
12896 char *kwnames[] = {
12897 (char *) "self", NULL
12898 };
12899
12900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12902 if (SWIG_arg_fail(1)) SWIG_fail;
12903 {
12904 PyThreadState* __tstate = wxPyBeginAllowThreads();
12905 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12906
12907 wxPyEndAllowThreads(__tstate);
12908 if (PyErr_Occurred()) SWIG_fail;
12909 }
12910 {
12911 resultobj = SWIG_From_int((int)(result));
12912 }
12913 return resultobj;
12914 fail:
12915 return NULL;
12916 }
12917
12918
12919 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12920 PyObject *resultobj;
12921 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12922 int result;
12923 PyObject * obj0 = 0 ;
12924 char *kwnames[] = {
12925 (char *) "self", NULL
12926 };
12927
12928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12930 if (SWIG_arg_fail(1)) SWIG_fail;
12931 {
12932 PyThreadState* __tstate = wxPyBeginAllowThreads();
12933 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12934
12935 wxPyEndAllowThreads(__tstate);
12936 if (PyErr_Occurred()) SWIG_fail;
12937 }
12938 {
12939 resultobj = SWIG_From_int((int)(result));
12940 }
12941 return resultobj;
12942 fail:
12943 return NULL;
12944 }
12945
12946
12947 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12948 PyObject *resultobj;
12949 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12950 int result;
12951 PyObject * obj0 = 0 ;
12952 char *kwnames[] = {
12953 (char *) "self", NULL
12954 };
12955
12956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12958 if (SWIG_arg_fail(1)) SWIG_fail;
12959 {
12960 PyThreadState* __tstate = wxPyBeginAllowThreads();
12961 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12962
12963 wxPyEndAllowThreads(__tstate);
12964 if (PyErr_Occurred()) SWIG_fail;
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_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12976 PyObject *resultobj;
12977 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12978 int arg2 ;
12979 PyObject * obj0 = 0 ;
12980 PyObject * obj1 = 0 ;
12981 char *kwnames[] = {
12982 (char *) "self",(char *) "stick", NULL
12983 };
12984
12985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12987 if (SWIG_arg_fail(1)) SWIG_fail;
12988 {
12989 arg2 = (int)(SWIG_As_int(obj1));
12990 if (SWIG_arg_fail(2)) SWIG_fail;
12991 }
12992 {
12993 PyThreadState* __tstate = wxPyBeginAllowThreads();
12994 (arg1)->SetJoystick(arg2);
12995
12996 wxPyEndAllowThreads(__tstate);
12997 if (PyErr_Occurred()) SWIG_fail;
12998 }
12999 Py_INCREF(Py_None); resultobj = Py_None;
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj;
13008 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13009 int arg2 ;
13010 PyObject * obj0 = 0 ;
13011 PyObject * obj1 = 0 ;
13012 char *kwnames[] = {
13013 (char *) "self",(char *) "state", NULL
13014 };
13015
13016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13018 if (SWIG_arg_fail(1)) SWIG_fail;
13019 {
13020 arg2 = (int)(SWIG_As_int(obj1));
13021 if (SWIG_arg_fail(2)) SWIG_fail;
13022 }
13023 {
13024 PyThreadState* __tstate = wxPyBeginAllowThreads();
13025 (arg1)->SetButtonState(arg2);
13026
13027 wxPyEndAllowThreads(__tstate);
13028 if (PyErr_Occurred()) SWIG_fail;
13029 }
13030 Py_INCREF(Py_None); resultobj = Py_None;
13031 return resultobj;
13032 fail:
13033 return NULL;
13034 }
13035
13036
13037 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13038 PyObject *resultobj;
13039 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13040 int arg2 ;
13041 PyObject * obj0 = 0 ;
13042 PyObject * obj1 = 0 ;
13043 char *kwnames[] = {
13044 (char *) "self",(char *) "change", NULL
13045 };
13046
13047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13049 if (SWIG_arg_fail(1)) SWIG_fail;
13050 {
13051 arg2 = (int)(SWIG_As_int(obj1));
13052 if (SWIG_arg_fail(2)) SWIG_fail;
13053 }
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 (arg1)->SetButtonChange(arg2);
13057
13058 wxPyEndAllowThreads(__tstate);
13059 if (PyErr_Occurred()) SWIG_fail;
13060 }
13061 Py_INCREF(Py_None); resultobj = Py_None;
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13069 PyObject *resultobj;
13070 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13071 wxPoint *arg2 = 0 ;
13072 wxPoint temp2 ;
13073 PyObject * obj0 = 0 ;
13074 PyObject * obj1 = 0 ;
13075 char *kwnames[] = {
13076 (char *) "self",(char *) "pos", NULL
13077 };
13078
13079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13081 if (SWIG_arg_fail(1)) SWIG_fail;
13082 {
13083 arg2 = &temp2;
13084 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13085 }
13086 {
13087 PyThreadState* __tstate = wxPyBeginAllowThreads();
13088 (arg1)->SetPosition((wxPoint const &)*arg2);
13089
13090 wxPyEndAllowThreads(__tstate);
13091 if (PyErr_Occurred()) SWIG_fail;
13092 }
13093 Py_INCREF(Py_None); resultobj = Py_None;
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13101 PyObject *resultobj;
13102 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13103 int arg2 ;
13104 PyObject * obj0 = 0 ;
13105 PyObject * obj1 = 0 ;
13106 char *kwnames[] = {
13107 (char *) "self",(char *) "zPos", NULL
13108 };
13109
13110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13112 if (SWIG_arg_fail(1)) SWIG_fail;
13113 {
13114 arg2 = (int)(SWIG_As_int(obj1));
13115 if (SWIG_arg_fail(2)) SWIG_fail;
13116 }
13117 {
13118 PyThreadState* __tstate = wxPyBeginAllowThreads();
13119 (arg1)->SetZPosition(arg2);
13120
13121 wxPyEndAllowThreads(__tstate);
13122 if (PyErr_Occurred()) SWIG_fail;
13123 }
13124 Py_INCREF(Py_None); resultobj = Py_None;
13125 return resultobj;
13126 fail:
13127 return NULL;
13128 }
13129
13130
13131 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13132 PyObject *resultobj;
13133 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13134 bool result;
13135 PyObject * obj0 = 0 ;
13136 char *kwnames[] = {
13137 (char *) "self", NULL
13138 };
13139
13140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13142 if (SWIG_arg_fail(1)) SWIG_fail;
13143 {
13144 PyThreadState* __tstate = wxPyBeginAllowThreads();
13145 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13146
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 {
13151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13152 }
13153 return resultobj;
13154 fail:
13155 return NULL;
13156 }
13157
13158
13159 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13160 PyObject *resultobj;
13161 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13162 bool result;
13163 PyObject * obj0 = 0 ;
13164 char *kwnames[] = {
13165 (char *) "self", NULL
13166 };
13167
13168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13170 if (SWIG_arg_fail(1)) SWIG_fail;
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13174
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 {
13179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13180 }
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj;
13189 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13190 bool result;
13191 PyObject * obj0 = 0 ;
13192 char *kwnames[] = {
13193 (char *) "self", NULL
13194 };
13195
13196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13198 if (SWIG_arg_fail(1)) SWIG_fail;
13199 {
13200 PyThreadState* __tstate = wxPyBeginAllowThreads();
13201 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13202
13203 wxPyEndAllowThreads(__tstate);
13204 if (PyErr_Occurred()) SWIG_fail;
13205 }
13206 {
13207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13208 }
13209 return resultobj;
13210 fail:
13211 return NULL;
13212 }
13213
13214
13215 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13216 PyObject *resultobj;
13217 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13218 int arg2 = (int) wxJOY_BUTTON_ANY ;
13219 bool result;
13220 PyObject * obj0 = 0 ;
13221 PyObject * obj1 = 0 ;
13222 char *kwnames[] = {
13223 (char *) "self",(char *) "but", NULL
13224 };
13225
13226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13228 if (SWIG_arg_fail(1)) SWIG_fail;
13229 if (obj1) {
13230 {
13231 arg2 = (int)(SWIG_As_int(obj1));
13232 if (SWIG_arg_fail(2)) SWIG_fail;
13233 }
13234 }
13235 {
13236 PyThreadState* __tstate = wxPyBeginAllowThreads();
13237 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13238
13239 wxPyEndAllowThreads(__tstate);
13240 if (PyErr_Occurred()) SWIG_fail;
13241 }
13242 {
13243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13244 }
13245 return resultobj;
13246 fail:
13247 return NULL;
13248 }
13249
13250
13251 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj;
13253 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13254 int arg2 = (int) wxJOY_BUTTON_ANY ;
13255 bool result;
13256 PyObject * obj0 = 0 ;
13257 PyObject * obj1 = 0 ;
13258 char *kwnames[] = {
13259 (char *) "self",(char *) "but", NULL
13260 };
13261
13262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13264 if (SWIG_arg_fail(1)) SWIG_fail;
13265 if (obj1) {
13266 {
13267 arg2 = (int)(SWIG_As_int(obj1));
13268 if (SWIG_arg_fail(2)) SWIG_fail;
13269 }
13270 }
13271 {
13272 PyThreadState* __tstate = wxPyBeginAllowThreads();
13273 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13274
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 {
13279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13280 }
13281 return resultobj;
13282 fail:
13283 return NULL;
13284 }
13285
13286
13287 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13288 PyObject *resultobj;
13289 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13290 int arg2 = (int) wxJOY_BUTTON_ANY ;
13291 bool result;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 char *kwnames[] = {
13295 (char *) "self",(char *) "but", NULL
13296 };
13297
13298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13300 if (SWIG_arg_fail(1)) SWIG_fail;
13301 if (obj1) {
13302 {
13303 arg2 = (int)(SWIG_As_int(obj1));
13304 if (SWIG_arg_fail(2)) SWIG_fail;
13305 }
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13310
13311 wxPyEndAllowThreads(__tstate);
13312 if (PyErr_Occurred()) SWIG_fail;
13313 }
13314 {
13315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13316 }
13317 return resultobj;
13318 fail:
13319 return NULL;
13320 }
13321
13322
13323 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13324 PyObject *obj;
13325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13326 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13327 Py_INCREF(obj);
13328 return Py_BuildValue((char *)"");
13329 }
13330 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13331 PyObject *resultobj;
13332 wxString const &arg1_defvalue = wxPyEmptyString ;
13333 wxString *arg1 = (wxString *) &arg1_defvalue ;
13334 wxSound *result;
13335 bool temp1 = false ;
13336 PyObject * obj0 = 0 ;
13337 char *kwnames[] = {
13338 (char *) "fileName", NULL
13339 };
13340
13341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13342 if (obj0) {
13343 {
13344 arg1 = wxString_in_helper(obj0);
13345 if (arg1 == NULL) SWIG_fail;
13346 temp1 = true;
13347 }
13348 }
13349 {
13350 if (!wxPyCheckForApp()) SWIG_fail;
13351 PyThreadState* __tstate = wxPyBeginAllowThreads();
13352 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13353
13354 wxPyEndAllowThreads(__tstate);
13355 if (PyErr_Occurred()) SWIG_fail;
13356 }
13357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13358 {
13359 if (temp1)
13360 delete arg1;
13361 }
13362 return resultobj;
13363 fail:
13364 {
13365 if (temp1)
13366 delete arg1;
13367 }
13368 return NULL;
13369 }
13370
13371
13372 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj;
13374 PyObject *arg1 = (PyObject *) 0 ;
13375 wxSound *result;
13376 PyObject * obj0 = 0 ;
13377 char *kwnames[] = {
13378 (char *) "data", NULL
13379 };
13380
13381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13382 arg1 = obj0;
13383 {
13384 if (!wxPyCheckForApp()) SWIG_fail;
13385 PyThreadState* __tstate = wxPyBeginAllowThreads();
13386 result = (wxSound *)new_wxSound(arg1);
13387
13388 wxPyEndAllowThreads(__tstate);
13389 if (PyErr_Occurred()) SWIG_fail;
13390 }
13391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13392 return resultobj;
13393 fail:
13394 return NULL;
13395 }
13396
13397
13398 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13399 PyObject *resultobj;
13400 wxSound *arg1 = (wxSound *) 0 ;
13401 PyObject * obj0 = 0 ;
13402 char *kwnames[] = {
13403 (char *) "self", NULL
13404 };
13405
13406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13408 if (SWIG_arg_fail(1)) SWIG_fail;
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 delete arg1;
13412
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 Py_INCREF(Py_None); resultobj = Py_None;
13417 return resultobj;
13418 fail:
13419 return NULL;
13420 }
13421
13422
13423 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13424 PyObject *resultobj;
13425 wxSound *arg1 = (wxSound *) 0 ;
13426 wxString *arg2 = 0 ;
13427 bool result;
13428 bool temp2 = false ;
13429 PyObject * obj0 = 0 ;
13430 PyObject * obj1 = 0 ;
13431 char *kwnames[] = {
13432 (char *) "self",(char *) "fileName", NULL
13433 };
13434
13435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13437 if (SWIG_arg_fail(1)) SWIG_fail;
13438 {
13439 arg2 = wxString_in_helper(obj1);
13440 if (arg2 == NULL) SWIG_fail;
13441 temp2 = true;
13442 }
13443 {
13444 PyThreadState* __tstate = wxPyBeginAllowThreads();
13445 result = (bool)(arg1)->Create((wxString const &)*arg2);
13446
13447 wxPyEndAllowThreads(__tstate);
13448 if (PyErr_Occurred()) SWIG_fail;
13449 }
13450 {
13451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13452 }
13453 {
13454 if (temp2)
13455 delete arg2;
13456 }
13457 return resultobj;
13458 fail:
13459 {
13460 if (temp2)
13461 delete arg2;
13462 }
13463 return NULL;
13464 }
13465
13466
13467 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13468 PyObject *resultobj;
13469 wxSound *arg1 = (wxSound *) 0 ;
13470 PyObject *arg2 = (PyObject *) 0 ;
13471 bool result;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 char *kwnames[] = {
13475 (char *) "self",(char *) "data", NULL
13476 };
13477
13478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13480 if (SWIG_arg_fail(1)) SWIG_fail;
13481 arg2 = obj1;
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = (bool)wxSound_CreateFromData(arg1,arg2);
13485
13486 wxPyEndAllowThreads(__tstate);
13487 if (PyErr_Occurred()) SWIG_fail;
13488 }
13489 {
13490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13491 }
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13499 PyObject *resultobj;
13500 wxSound *arg1 = (wxSound *) 0 ;
13501 bool result;
13502 PyObject * obj0 = 0 ;
13503 char *kwnames[] = {
13504 (char *) "self", NULL
13505 };
13506
13507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13509 if (SWIG_arg_fail(1)) SWIG_fail;
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 result = (bool)(arg1)->IsOk();
13513
13514 wxPyEndAllowThreads(__tstate);
13515 if (PyErr_Occurred()) SWIG_fail;
13516 }
13517 {
13518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13519 }
13520 return resultobj;
13521 fail:
13522 return NULL;
13523 }
13524
13525
13526 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj;
13528 wxSound *arg1 = (wxSound *) 0 ;
13529 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13530 bool result;
13531 PyObject * obj0 = 0 ;
13532 PyObject * obj1 = 0 ;
13533 char *kwnames[] = {
13534 (char *) "self",(char *) "flags", NULL
13535 };
13536
13537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13539 if (SWIG_arg_fail(1)) SWIG_fail;
13540 if (obj1) {
13541 {
13542 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13543 if (SWIG_arg_fail(2)) SWIG_fail;
13544 }
13545 }
13546 {
13547 if (!wxPyCheckForApp()) SWIG_fail;
13548 PyThreadState* __tstate = wxPyBeginAllowThreads();
13549 result = (bool)((wxSound const *)arg1)->Play(arg2);
13550
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 {
13555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13556 }
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13564 PyObject *resultobj;
13565 wxString *arg1 = 0 ;
13566 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13567 bool result;
13568 bool temp1 = false ;
13569 PyObject * obj0 = 0 ;
13570 PyObject * obj1 = 0 ;
13571 char *kwnames[] = {
13572 (char *) "filename",(char *) "flags", NULL
13573 };
13574
13575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13576 {
13577 arg1 = wxString_in_helper(obj0);
13578 if (arg1 == NULL) SWIG_fail;
13579 temp1 = true;
13580 }
13581 if (obj1) {
13582 {
13583 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13584 if (SWIG_arg_fail(2)) SWIG_fail;
13585 }
13586 }
13587 {
13588 if (!wxPyCheckForApp()) SWIG_fail;
13589 PyThreadState* __tstate = wxPyBeginAllowThreads();
13590 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13591
13592 wxPyEndAllowThreads(__tstate);
13593 if (PyErr_Occurred()) SWIG_fail;
13594 }
13595 {
13596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13597 }
13598 {
13599 if (temp1)
13600 delete arg1;
13601 }
13602 return resultobj;
13603 fail:
13604 {
13605 if (temp1)
13606 delete arg1;
13607 }
13608 return NULL;
13609 }
13610
13611
13612 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj;
13614 char *kwnames[] = {
13615 NULL
13616 };
13617
13618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13619 {
13620 if (!wxPyCheckForApp()) SWIG_fail;
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 wxSound::Stop();
13623
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 Py_INCREF(Py_None); resultobj = Py_None;
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13635 PyObject *obj;
13636 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13637 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13638 Py_INCREF(obj);
13639 return Py_BuildValue((char *)"");
13640 }
13641 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13642 PyObject *resultobj;
13643 wxString *arg1 = 0 ;
13644 wxString *arg2 = 0 ;
13645 wxString *arg3 = 0 ;
13646 wxString *arg4 = 0 ;
13647 wxFileTypeInfo *result;
13648 bool temp1 = false ;
13649 bool temp2 = false ;
13650 bool temp3 = false ;
13651 bool temp4 = false ;
13652 PyObject * obj0 = 0 ;
13653 PyObject * obj1 = 0 ;
13654 PyObject * obj2 = 0 ;
13655 PyObject * obj3 = 0 ;
13656 char *kwnames[] = {
13657 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13658 };
13659
13660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13661 {
13662 arg1 = wxString_in_helper(obj0);
13663 if (arg1 == NULL) SWIG_fail;
13664 temp1 = true;
13665 }
13666 {
13667 arg2 = wxString_in_helper(obj1);
13668 if (arg2 == NULL) SWIG_fail;
13669 temp2 = true;
13670 }
13671 {
13672 arg3 = wxString_in_helper(obj2);
13673 if (arg3 == NULL) SWIG_fail;
13674 temp3 = true;
13675 }
13676 {
13677 arg4 = wxString_in_helper(obj3);
13678 if (arg4 == NULL) SWIG_fail;
13679 temp4 = true;
13680 }
13681 {
13682 PyThreadState* __tstate = wxPyBeginAllowThreads();
13683 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13684
13685 wxPyEndAllowThreads(__tstate);
13686 if (PyErr_Occurred()) SWIG_fail;
13687 }
13688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13689 {
13690 if (temp1)
13691 delete arg1;
13692 }
13693 {
13694 if (temp2)
13695 delete arg2;
13696 }
13697 {
13698 if (temp3)
13699 delete arg3;
13700 }
13701 {
13702 if (temp4)
13703 delete arg4;
13704 }
13705 return resultobj;
13706 fail:
13707 {
13708 if (temp1)
13709 delete arg1;
13710 }
13711 {
13712 if (temp2)
13713 delete arg2;
13714 }
13715 {
13716 if (temp3)
13717 delete arg3;
13718 }
13719 {
13720 if (temp4)
13721 delete arg4;
13722 }
13723 return NULL;
13724 }
13725
13726
13727 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13728 PyObject *resultobj;
13729 wxArrayString *arg1 = 0 ;
13730 wxFileTypeInfo *result;
13731 bool temp1 = false ;
13732 PyObject * obj0 = 0 ;
13733 char *kwnames[] = {
13734 (char *) "sArray", NULL
13735 };
13736
13737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13738 {
13739 if (! PySequence_Check(obj0)) {
13740 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13741 SWIG_fail;
13742 }
13743 arg1 = new wxArrayString;
13744 temp1 = true;
13745 int i, len=PySequence_Length(obj0);
13746 for (i=0; i<len; i++) {
13747 PyObject* item = PySequence_GetItem(obj0, i);
13748 #if wxUSE_UNICODE
13749 PyObject* str = PyObject_Unicode(item);
13750 #else
13751 PyObject* str = PyObject_Str(item);
13752 #endif
13753 if (PyErr_Occurred()) SWIG_fail;
13754 arg1->Add(Py2wxString(str));
13755 Py_DECREF(item);
13756 Py_DECREF(str);
13757 }
13758 }
13759 {
13760 PyThreadState* __tstate = wxPyBeginAllowThreads();
13761 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13762
13763 wxPyEndAllowThreads(__tstate);
13764 if (PyErr_Occurred()) SWIG_fail;
13765 }
13766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13767 {
13768 if (temp1) delete arg1;
13769 }
13770 return resultobj;
13771 fail:
13772 {
13773 if (temp1) delete arg1;
13774 }
13775 return NULL;
13776 }
13777
13778
13779 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13780 PyObject *resultobj;
13781 wxFileTypeInfo *result;
13782 char *kwnames[] = {
13783 NULL
13784 };
13785
13786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13787 {
13788 PyThreadState* __tstate = wxPyBeginAllowThreads();
13789 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13790
13791 wxPyEndAllowThreads(__tstate);
13792 if (PyErr_Occurred()) SWIG_fail;
13793 }
13794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13795 return resultobj;
13796 fail:
13797 return NULL;
13798 }
13799
13800
13801 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13802 PyObject *resultobj;
13803 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13804 bool result;
13805 PyObject * obj0 = 0 ;
13806 char *kwnames[] = {
13807 (char *) "self", NULL
13808 };
13809
13810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13812 if (SWIG_arg_fail(1)) SWIG_fail;
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13816
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 {
13821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13822 }
13823 return resultobj;
13824 fail:
13825 return NULL;
13826 }
13827
13828
13829 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13830 PyObject *resultobj;
13831 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13832 wxString *arg2 = 0 ;
13833 int arg3 = (int) 0 ;
13834 bool temp2 = false ;
13835 PyObject * obj0 = 0 ;
13836 PyObject * obj1 = 0 ;
13837 PyObject * obj2 = 0 ;
13838 char *kwnames[] = {
13839 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13840 };
13841
13842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13844 if (SWIG_arg_fail(1)) SWIG_fail;
13845 {
13846 arg2 = wxString_in_helper(obj1);
13847 if (arg2 == NULL) SWIG_fail;
13848 temp2 = true;
13849 }
13850 if (obj2) {
13851 {
13852 arg3 = (int)(SWIG_As_int(obj2));
13853 if (SWIG_arg_fail(3)) SWIG_fail;
13854 }
13855 }
13856 {
13857 PyThreadState* __tstate = wxPyBeginAllowThreads();
13858 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13859
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 Py_INCREF(Py_None); resultobj = Py_None;
13864 {
13865 if (temp2)
13866 delete arg2;
13867 }
13868 return resultobj;
13869 fail:
13870 {
13871 if (temp2)
13872 delete arg2;
13873 }
13874 return NULL;
13875 }
13876
13877
13878 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13879 PyObject *resultobj;
13880 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13881 wxString *arg2 = 0 ;
13882 bool temp2 = false ;
13883 PyObject * obj0 = 0 ;
13884 PyObject * obj1 = 0 ;
13885 char *kwnames[] = {
13886 (char *) "self",(char *) "shortDesc", NULL
13887 };
13888
13889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13891 if (SWIG_arg_fail(1)) SWIG_fail;
13892 {
13893 arg2 = wxString_in_helper(obj1);
13894 if (arg2 == NULL) SWIG_fail;
13895 temp2 = true;
13896 }
13897 {
13898 PyThreadState* __tstate = wxPyBeginAllowThreads();
13899 (arg1)->SetShortDesc((wxString const &)*arg2);
13900
13901 wxPyEndAllowThreads(__tstate);
13902 if (PyErr_Occurred()) SWIG_fail;
13903 }
13904 Py_INCREF(Py_None); resultobj = Py_None;
13905 {
13906 if (temp2)
13907 delete arg2;
13908 }
13909 return resultobj;
13910 fail:
13911 {
13912 if (temp2)
13913 delete arg2;
13914 }
13915 return NULL;
13916 }
13917
13918
13919 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13920 PyObject *resultobj;
13921 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13922 wxString *result;
13923 PyObject * obj0 = 0 ;
13924 char *kwnames[] = {
13925 (char *) "self", NULL
13926 };
13927
13928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13930 if (SWIG_arg_fail(1)) SWIG_fail;
13931 {
13932 PyThreadState* __tstate = wxPyBeginAllowThreads();
13933 {
13934 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13935 result = (wxString *) &_result_ref;
13936 }
13937
13938 wxPyEndAllowThreads(__tstate);
13939 if (PyErr_Occurred()) SWIG_fail;
13940 }
13941 {
13942 #if wxUSE_UNICODE
13943 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13944 #else
13945 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13946 #endif
13947 }
13948 return resultobj;
13949 fail:
13950 return NULL;
13951 }
13952
13953
13954 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13955 PyObject *resultobj;
13956 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13957 wxString *result;
13958 PyObject * obj0 = 0 ;
13959 char *kwnames[] = {
13960 (char *) "self", NULL
13961 };
13962
13963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13965 if (SWIG_arg_fail(1)) SWIG_fail;
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 {
13969 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13970 result = (wxString *) &_result_ref;
13971 }
13972
13973 wxPyEndAllowThreads(__tstate);
13974 if (PyErr_Occurred()) SWIG_fail;
13975 }
13976 {
13977 #if wxUSE_UNICODE
13978 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13979 #else
13980 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13981 #endif
13982 }
13983 return resultobj;
13984 fail:
13985 return NULL;
13986 }
13987
13988
13989 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13990 PyObject *resultobj;
13991 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13992 wxString *result;
13993 PyObject * obj0 = 0 ;
13994 char *kwnames[] = {
13995 (char *) "self", NULL
13996 };
13997
13998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14000 if (SWIG_arg_fail(1)) SWIG_fail;
14001 {
14002 PyThreadState* __tstate = wxPyBeginAllowThreads();
14003 {
14004 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14005 result = (wxString *) &_result_ref;
14006 }
14007
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 {
14012 #if wxUSE_UNICODE
14013 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14014 #else
14015 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14016 #endif
14017 }
14018 return resultobj;
14019 fail:
14020 return NULL;
14021 }
14022
14023
14024 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14025 PyObject *resultobj;
14026 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14027 wxString *result;
14028 PyObject * obj0 = 0 ;
14029 char *kwnames[] = {
14030 (char *) "self", NULL
14031 };
14032
14033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14035 if (SWIG_arg_fail(1)) SWIG_fail;
14036 {
14037 PyThreadState* __tstate = wxPyBeginAllowThreads();
14038 {
14039 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14040 result = (wxString *) &_result_ref;
14041 }
14042
14043 wxPyEndAllowThreads(__tstate);
14044 if (PyErr_Occurred()) SWIG_fail;
14045 }
14046 {
14047 #if wxUSE_UNICODE
14048 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14049 #else
14050 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14051 #endif
14052 }
14053 return resultobj;
14054 fail:
14055 return NULL;
14056 }
14057
14058
14059 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14060 PyObject *resultobj;
14061 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14062 wxString *result;
14063 PyObject * obj0 = 0 ;
14064 char *kwnames[] = {
14065 (char *) "self", NULL
14066 };
14067
14068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14070 if (SWIG_arg_fail(1)) SWIG_fail;
14071 {
14072 PyThreadState* __tstate = wxPyBeginAllowThreads();
14073 {
14074 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14075 result = (wxString *) &_result_ref;
14076 }
14077
14078 wxPyEndAllowThreads(__tstate);
14079 if (PyErr_Occurred()) SWIG_fail;
14080 }
14081 {
14082 #if wxUSE_UNICODE
14083 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14084 #else
14085 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14086 #endif
14087 }
14088 return resultobj;
14089 fail:
14090 return NULL;
14091 }
14092
14093
14094 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14095 PyObject *resultobj;
14096 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14097 wxArrayString *result;
14098 PyObject * obj0 = 0 ;
14099 char *kwnames[] = {
14100 (char *) "self", NULL
14101 };
14102
14103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14105 if (SWIG_arg_fail(1)) SWIG_fail;
14106 {
14107 PyThreadState* __tstate = wxPyBeginAllowThreads();
14108 {
14109 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14110 result = (wxArrayString *) &_result_ref;
14111 }
14112
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 {
14117 resultobj = wxArrayString2PyList_helper(*result);
14118 }
14119 return resultobj;
14120 fail:
14121 return NULL;
14122 }
14123
14124
14125 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14126 PyObject *resultobj;
14127 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14128 int result;
14129 PyObject * obj0 = 0 ;
14130 char *kwnames[] = {
14131 (char *) "self", NULL
14132 };
14133
14134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14136 if (SWIG_arg_fail(1)) SWIG_fail;
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14140
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 {
14145 resultobj = SWIG_From_int((int)(result));
14146 }
14147 return resultobj;
14148 fail:
14149 return NULL;
14150 }
14151
14152
14153 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14154 PyObject *resultobj;
14155 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14156 wxString *result;
14157 PyObject * obj0 = 0 ;
14158 char *kwnames[] = {
14159 (char *) "self", NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14164 if (SWIG_arg_fail(1)) SWIG_fail;
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 {
14168 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14169 result = (wxString *) &_result_ref;
14170 }
14171
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 {
14176 #if wxUSE_UNICODE
14177 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14178 #else
14179 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14180 #endif
14181 }
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14189 PyObject *resultobj;
14190 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14191 int result;
14192 PyObject * obj0 = 0 ;
14193 char *kwnames[] = {
14194 (char *) "self", NULL
14195 };
14196
14197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14199 if (SWIG_arg_fail(1)) SWIG_fail;
14200 {
14201 PyThreadState* __tstate = wxPyBeginAllowThreads();
14202 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14203
14204 wxPyEndAllowThreads(__tstate);
14205 if (PyErr_Occurred()) SWIG_fail;
14206 }
14207 {
14208 resultobj = SWIG_From_int((int)(result));
14209 }
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14217 PyObject *obj;
14218 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14219 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14220 Py_INCREF(obj);
14221 return Py_BuildValue((char *)"");
14222 }
14223 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14224 PyObject *resultobj;
14225 wxFileTypeInfo *arg1 = 0 ;
14226 wxFileType *result;
14227 PyObject * obj0 = 0 ;
14228 char *kwnames[] = {
14229 (char *) "ftInfo", NULL
14230 };
14231
14232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14233 {
14234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14235 if (SWIG_arg_fail(1)) SWIG_fail;
14236 if (arg1 == NULL) {
14237 SWIG_null_ref("wxFileTypeInfo");
14238 }
14239 if (SWIG_arg_fail(1)) SWIG_fail;
14240 }
14241 {
14242 PyThreadState* __tstate = wxPyBeginAllowThreads();
14243 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14244
14245 wxPyEndAllowThreads(__tstate);
14246 if (PyErr_Occurred()) SWIG_fail;
14247 }
14248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14249 return resultobj;
14250 fail:
14251 return NULL;
14252 }
14253
14254
14255 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj;
14257 wxFileType *arg1 = (wxFileType *) 0 ;
14258 PyObject * obj0 = 0 ;
14259 char *kwnames[] = {
14260 (char *) "self", NULL
14261 };
14262
14263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14265 if (SWIG_arg_fail(1)) SWIG_fail;
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 delete arg1;
14269
14270 wxPyEndAllowThreads(__tstate);
14271 if (PyErr_Occurred()) SWIG_fail;
14272 }
14273 Py_INCREF(Py_None); resultobj = Py_None;
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14281 PyObject *resultobj;
14282 wxFileType *arg1 = (wxFileType *) 0 ;
14283 PyObject *result;
14284 PyObject * obj0 = 0 ;
14285 char *kwnames[] = {
14286 (char *) "self", NULL
14287 };
14288
14289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14291 if (SWIG_arg_fail(1)) SWIG_fail;
14292 {
14293 PyThreadState* __tstate = wxPyBeginAllowThreads();
14294 result = (PyObject *)wxFileType_GetMimeType(arg1);
14295
14296 wxPyEndAllowThreads(__tstate);
14297 if (PyErr_Occurred()) SWIG_fail;
14298 }
14299 resultobj = result;
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14307 PyObject *resultobj;
14308 wxFileType *arg1 = (wxFileType *) 0 ;
14309 PyObject *result;
14310 PyObject * obj0 = 0 ;
14311 char *kwnames[] = {
14312 (char *) "self", NULL
14313 };
14314
14315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14317 if (SWIG_arg_fail(1)) SWIG_fail;
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14321
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 resultobj = result;
14326 return resultobj;
14327 fail:
14328 return NULL;
14329 }
14330
14331
14332 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14333 PyObject *resultobj;
14334 wxFileType *arg1 = (wxFileType *) 0 ;
14335 PyObject *result;
14336 PyObject * obj0 = 0 ;
14337 char *kwnames[] = {
14338 (char *) "self", NULL
14339 };
14340
14341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14343 if (SWIG_arg_fail(1)) SWIG_fail;
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 result = (PyObject *)wxFileType_GetExtensions(arg1);
14347
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 resultobj = result;
14352 return resultobj;
14353 fail:
14354 return NULL;
14355 }
14356
14357
14358 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj;
14360 wxFileType *arg1 = (wxFileType *) 0 ;
14361 wxIcon *result;
14362 PyObject * obj0 = 0 ;
14363 char *kwnames[] = {
14364 (char *) "self", NULL
14365 };
14366
14367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14369 if (SWIG_arg_fail(1)) SWIG_fail;
14370 {
14371 PyThreadState* __tstate = wxPyBeginAllowThreads();
14372 result = (wxIcon *)wxFileType_GetIcon(arg1);
14373
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14378 return resultobj;
14379 fail:
14380 return NULL;
14381 }
14382
14383
14384 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14385 PyObject *resultobj;
14386 wxFileType *arg1 = (wxFileType *) 0 ;
14387 PyObject *result;
14388 PyObject * obj0 = 0 ;
14389 char *kwnames[] = {
14390 (char *) "self", NULL
14391 };
14392
14393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14395 if (SWIG_arg_fail(1)) SWIG_fail;
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14399
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 resultobj = result;
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14411 PyObject *resultobj;
14412 wxFileType *arg1 = (wxFileType *) 0 ;
14413 PyObject *result;
14414 PyObject * obj0 = 0 ;
14415 char *kwnames[] = {
14416 (char *) "self", NULL
14417 };
14418
14419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14421 if (SWIG_arg_fail(1)) SWIG_fail;
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 result = (PyObject *)wxFileType_GetDescription(arg1);
14425
14426 wxPyEndAllowThreads(__tstate);
14427 if (PyErr_Occurred()) SWIG_fail;
14428 }
14429 resultobj = result;
14430 return resultobj;
14431 fail:
14432 return NULL;
14433 }
14434
14435
14436 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14437 PyObject *resultobj;
14438 wxFileType *arg1 = (wxFileType *) 0 ;
14439 wxString *arg2 = 0 ;
14440 wxString const &arg3_defvalue = wxPyEmptyString ;
14441 wxString *arg3 = (wxString *) &arg3_defvalue ;
14442 PyObject *result;
14443 bool temp2 = false ;
14444 bool temp3 = false ;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 PyObject * obj2 = 0 ;
14448 char *kwnames[] = {
14449 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14454 if (SWIG_arg_fail(1)) SWIG_fail;
14455 {
14456 arg2 = wxString_in_helper(obj1);
14457 if (arg2 == NULL) SWIG_fail;
14458 temp2 = true;
14459 }
14460 if (obj2) {
14461 {
14462 arg3 = wxString_in_helper(obj2);
14463 if (arg3 == NULL) SWIG_fail;
14464 temp3 = true;
14465 }
14466 }
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14470
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 resultobj = result;
14475 {
14476 if (temp2)
14477 delete arg2;
14478 }
14479 {
14480 if (temp3)
14481 delete arg3;
14482 }
14483 return resultobj;
14484 fail:
14485 {
14486 if (temp2)
14487 delete arg2;
14488 }
14489 {
14490 if (temp3)
14491 delete arg3;
14492 }
14493 return NULL;
14494 }
14495
14496
14497 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj;
14499 wxFileType *arg1 = (wxFileType *) 0 ;
14500 wxString *arg2 = 0 ;
14501 wxString const &arg3_defvalue = wxPyEmptyString ;
14502 wxString *arg3 = (wxString *) &arg3_defvalue ;
14503 PyObject *result;
14504 bool temp2 = false ;
14505 bool temp3 = false ;
14506 PyObject * obj0 = 0 ;
14507 PyObject * obj1 = 0 ;
14508 PyObject * obj2 = 0 ;
14509 char *kwnames[] = {
14510 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14511 };
14512
14513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14515 if (SWIG_arg_fail(1)) SWIG_fail;
14516 {
14517 arg2 = wxString_in_helper(obj1);
14518 if (arg2 == NULL) SWIG_fail;
14519 temp2 = true;
14520 }
14521 if (obj2) {
14522 {
14523 arg3 = wxString_in_helper(obj2);
14524 if (arg3 == NULL) SWIG_fail;
14525 temp3 = true;
14526 }
14527 }
14528 {
14529 PyThreadState* __tstate = wxPyBeginAllowThreads();
14530 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14531
14532 wxPyEndAllowThreads(__tstate);
14533 if (PyErr_Occurred()) SWIG_fail;
14534 }
14535 resultobj = result;
14536 {
14537 if (temp2)
14538 delete arg2;
14539 }
14540 {
14541 if (temp3)
14542 delete arg3;
14543 }
14544 return resultobj;
14545 fail:
14546 {
14547 if (temp2)
14548 delete arg2;
14549 }
14550 {
14551 if (temp3)
14552 delete arg3;
14553 }
14554 return NULL;
14555 }
14556
14557
14558 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14559 PyObject *resultobj;
14560 wxFileType *arg1 = (wxFileType *) 0 ;
14561 wxString *arg2 = 0 ;
14562 wxString const &arg3_defvalue = wxPyEmptyString ;
14563 wxString *arg3 = (wxString *) &arg3_defvalue ;
14564 PyObject *result;
14565 bool temp2 = false ;
14566 bool temp3 = false ;
14567 PyObject * obj0 = 0 ;
14568 PyObject * obj1 = 0 ;
14569 PyObject * obj2 = 0 ;
14570 char *kwnames[] = {
14571 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14572 };
14573
14574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14576 if (SWIG_arg_fail(1)) SWIG_fail;
14577 {
14578 arg2 = wxString_in_helper(obj1);
14579 if (arg2 == NULL) SWIG_fail;
14580 temp2 = true;
14581 }
14582 if (obj2) {
14583 {
14584 arg3 = wxString_in_helper(obj2);
14585 if (arg3 == NULL) SWIG_fail;
14586 temp3 = true;
14587 }
14588 }
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14592
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 resultobj = result;
14597 {
14598 if (temp2)
14599 delete arg2;
14600 }
14601 {
14602 if (temp3)
14603 delete arg3;
14604 }
14605 return resultobj;
14606 fail:
14607 {
14608 if (temp2)
14609 delete arg2;
14610 }
14611 {
14612 if (temp3)
14613 delete arg3;
14614 }
14615 return NULL;
14616 }
14617
14618
14619 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj;
14621 wxFileType *arg1 = (wxFileType *) 0 ;
14622 wxString *arg2 = 0 ;
14623 wxString *arg3 = 0 ;
14624 bool arg4 = (bool) true ;
14625 bool result;
14626 bool temp2 = false ;
14627 bool temp3 = false ;
14628 PyObject * obj0 = 0 ;
14629 PyObject * obj1 = 0 ;
14630 PyObject * obj2 = 0 ;
14631 PyObject * obj3 = 0 ;
14632 char *kwnames[] = {
14633 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14634 };
14635
14636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14638 if (SWIG_arg_fail(1)) SWIG_fail;
14639 {
14640 arg2 = wxString_in_helper(obj1);
14641 if (arg2 == NULL) SWIG_fail;
14642 temp2 = true;
14643 }
14644 {
14645 arg3 = wxString_in_helper(obj2);
14646 if (arg3 == NULL) SWIG_fail;
14647 temp3 = true;
14648 }
14649 if (obj3) {
14650 {
14651 arg4 = (bool)(SWIG_As_bool(obj3));
14652 if (SWIG_arg_fail(4)) SWIG_fail;
14653 }
14654 }
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14658
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 {
14663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14664 }
14665 {
14666 if (temp2)
14667 delete arg2;
14668 }
14669 {
14670 if (temp3)
14671 delete arg3;
14672 }
14673 return resultobj;
14674 fail:
14675 {
14676 if (temp2)
14677 delete arg2;
14678 }
14679 {
14680 if (temp3)
14681 delete arg3;
14682 }
14683 return NULL;
14684 }
14685
14686
14687 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14688 PyObject *resultobj;
14689 wxFileType *arg1 = (wxFileType *) 0 ;
14690 wxString const &arg2_defvalue = wxPyEmptyString ;
14691 wxString *arg2 = (wxString *) &arg2_defvalue ;
14692 int arg3 = (int) 0 ;
14693 bool result;
14694 bool temp2 = false ;
14695 PyObject * obj0 = 0 ;
14696 PyObject * obj1 = 0 ;
14697 PyObject * obj2 = 0 ;
14698 char *kwnames[] = {
14699 (char *) "self",(char *) "cmd",(char *) "index", NULL
14700 };
14701
14702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14704 if (SWIG_arg_fail(1)) SWIG_fail;
14705 if (obj1) {
14706 {
14707 arg2 = wxString_in_helper(obj1);
14708 if (arg2 == NULL) SWIG_fail;
14709 temp2 = true;
14710 }
14711 }
14712 if (obj2) {
14713 {
14714 arg3 = (int)(SWIG_As_int(obj2));
14715 if (SWIG_arg_fail(3)) SWIG_fail;
14716 }
14717 }
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14721
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 {
14726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14727 }
14728 {
14729 if (temp2)
14730 delete arg2;
14731 }
14732 return resultobj;
14733 fail:
14734 {
14735 if (temp2)
14736 delete arg2;
14737 }
14738 return NULL;
14739 }
14740
14741
14742 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14743 PyObject *resultobj;
14744 wxFileType *arg1 = (wxFileType *) 0 ;
14745 bool result;
14746 PyObject * obj0 = 0 ;
14747 char *kwnames[] = {
14748 (char *) "self", NULL
14749 };
14750
14751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14753 if (SWIG_arg_fail(1)) SWIG_fail;
14754 {
14755 PyThreadState* __tstate = wxPyBeginAllowThreads();
14756 result = (bool)(arg1)->Unassociate();
14757
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 {
14762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14763 }
14764 return resultobj;
14765 fail:
14766 return NULL;
14767 }
14768
14769
14770 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14771 PyObject *resultobj;
14772 wxString *arg1 = 0 ;
14773 wxString *arg2 = 0 ;
14774 wxString const &arg3_defvalue = wxPyEmptyString ;
14775 wxString *arg3 = (wxString *) &arg3_defvalue ;
14776 wxString result;
14777 bool temp1 = false ;
14778 bool temp2 = false ;
14779 bool temp3 = false ;
14780 PyObject * obj0 = 0 ;
14781 PyObject * obj1 = 0 ;
14782 PyObject * obj2 = 0 ;
14783 char *kwnames[] = {
14784 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14785 };
14786
14787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14788 {
14789 arg1 = wxString_in_helper(obj0);
14790 if (arg1 == NULL) SWIG_fail;
14791 temp1 = true;
14792 }
14793 {
14794 arg2 = wxString_in_helper(obj1);
14795 if (arg2 == NULL) SWIG_fail;
14796 temp2 = true;
14797 }
14798 if (obj2) {
14799 {
14800 arg3 = wxString_in_helper(obj2);
14801 if (arg3 == NULL) SWIG_fail;
14802 temp3 = true;
14803 }
14804 }
14805 {
14806 PyThreadState* __tstate = wxPyBeginAllowThreads();
14807 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14808
14809 wxPyEndAllowThreads(__tstate);
14810 if (PyErr_Occurred()) SWIG_fail;
14811 }
14812 {
14813 #if wxUSE_UNICODE
14814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14815 #else
14816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14817 #endif
14818 }
14819 {
14820 if (temp1)
14821 delete arg1;
14822 }
14823 {
14824 if (temp2)
14825 delete arg2;
14826 }
14827 {
14828 if (temp3)
14829 delete arg3;
14830 }
14831 return resultobj;
14832 fail:
14833 {
14834 if (temp1)
14835 delete arg1;
14836 }
14837 {
14838 if (temp2)
14839 delete arg2;
14840 }
14841 {
14842 if (temp3)
14843 delete arg3;
14844 }
14845 return NULL;
14846 }
14847
14848
14849 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14850 PyObject *obj;
14851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14852 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14853 Py_INCREF(obj);
14854 return Py_BuildValue((char *)"");
14855 }
14856 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14857 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14858 return 1;
14859 }
14860
14861
14862 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14863 PyObject *pyobj;
14864
14865 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14866 return pyobj;
14867 }
14868
14869
14870 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14871 PyObject *resultobj;
14872 wxString *arg1 = 0 ;
14873 wxString *arg2 = 0 ;
14874 bool result;
14875 bool temp1 = false ;
14876 bool temp2 = false ;
14877 PyObject * obj0 = 0 ;
14878 PyObject * obj1 = 0 ;
14879 char *kwnames[] = {
14880 (char *) "mimeType",(char *) "wildcard", NULL
14881 };
14882
14883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14884 {
14885 arg1 = wxString_in_helper(obj0);
14886 if (arg1 == NULL) SWIG_fail;
14887 temp1 = true;
14888 }
14889 {
14890 arg2 = wxString_in_helper(obj1);
14891 if (arg2 == NULL) SWIG_fail;
14892 temp2 = true;
14893 }
14894 {
14895 PyThreadState* __tstate = wxPyBeginAllowThreads();
14896 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14897
14898 wxPyEndAllowThreads(__tstate);
14899 if (PyErr_Occurred()) SWIG_fail;
14900 }
14901 {
14902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14903 }
14904 {
14905 if (temp1)
14906 delete arg1;
14907 }
14908 {
14909 if (temp2)
14910 delete arg2;
14911 }
14912 return resultobj;
14913 fail:
14914 {
14915 if (temp1)
14916 delete arg1;
14917 }
14918 {
14919 if (temp2)
14920 delete arg2;
14921 }
14922 return NULL;
14923 }
14924
14925
14926 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14927 PyObject *resultobj;
14928 wxMimeTypesManager *result;
14929 char *kwnames[] = {
14930 NULL
14931 };
14932
14933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14934 {
14935 PyThreadState* __tstate = wxPyBeginAllowThreads();
14936 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14937
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14942 return resultobj;
14943 fail:
14944 return NULL;
14945 }
14946
14947
14948 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14949 PyObject *resultobj;
14950 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14951 int arg2 = (int) wxMAILCAP_ALL ;
14952 wxString const &arg3_defvalue = wxPyEmptyString ;
14953 wxString *arg3 = (wxString *) &arg3_defvalue ;
14954 bool temp3 = false ;
14955 PyObject * obj0 = 0 ;
14956 PyObject * obj1 = 0 ;
14957 PyObject * obj2 = 0 ;
14958 char *kwnames[] = {
14959 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14960 };
14961
14962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14964 if (SWIG_arg_fail(1)) SWIG_fail;
14965 if (obj1) {
14966 {
14967 arg2 = (int)(SWIG_As_int(obj1));
14968 if (SWIG_arg_fail(2)) SWIG_fail;
14969 }
14970 }
14971 if (obj2) {
14972 {
14973 arg3 = wxString_in_helper(obj2);
14974 if (arg3 == NULL) SWIG_fail;
14975 temp3 = true;
14976 }
14977 }
14978 {
14979 PyThreadState* __tstate = wxPyBeginAllowThreads();
14980 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14981
14982 wxPyEndAllowThreads(__tstate);
14983 if (PyErr_Occurred()) SWIG_fail;
14984 }
14985 Py_INCREF(Py_None); resultobj = Py_None;
14986 {
14987 if (temp3)
14988 delete arg3;
14989 }
14990 return resultobj;
14991 fail:
14992 {
14993 if (temp3)
14994 delete arg3;
14995 }
14996 return NULL;
14997 }
14998
14999
15000 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15001 PyObject *resultobj;
15002 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15003 PyObject * obj0 = 0 ;
15004 char *kwnames[] = {
15005 (char *) "self", NULL
15006 };
15007
15008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15010 if (SWIG_arg_fail(1)) SWIG_fail;
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 (arg1)->ClearData();
15014
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 Py_INCREF(Py_None); resultobj = Py_None;
15019 return resultobj;
15020 fail:
15021 return NULL;
15022 }
15023
15024
15025 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15026 PyObject *resultobj;
15027 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15028 wxString *arg2 = 0 ;
15029 wxFileType *result;
15030 bool temp2 = false ;
15031 PyObject * obj0 = 0 ;
15032 PyObject * obj1 = 0 ;
15033 char *kwnames[] = {
15034 (char *) "self",(char *) "ext", NULL
15035 };
15036
15037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15039 if (SWIG_arg_fail(1)) SWIG_fail;
15040 {
15041 arg2 = wxString_in_helper(obj1);
15042 if (arg2 == NULL) SWIG_fail;
15043 temp2 = true;
15044 }
15045 {
15046 PyThreadState* __tstate = wxPyBeginAllowThreads();
15047 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15048
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15053 {
15054 if (temp2)
15055 delete arg2;
15056 }
15057 return resultobj;
15058 fail:
15059 {
15060 if (temp2)
15061 delete arg2;
15062 }
15063 return NULL;
15064 }
15065
15066
15067 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15068 PyObject *resultobj;
15069 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15070 wxString *arg2 = 0 ;
15071 wxFileType *result;
15072 bool temp2 = false ;
15073 PyObject * obj0 = 0 ;
15074 PyObject * obj1 = 0 ;
15075 char *kwnames[] = {
15076 (char *) "self",(char *) "mimeType", NULL
15077 };
15078
15079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15081 if (SWIG_arg_fail(1)) SWIG_fail;
15082 {
15083 arg2 = wxString_in_helper(obj1);
15084 if (arg2 == NULL) SWIG_fail;
15085 temp2 = true;
15086 }
15087 {
15088 PyThreadState* __tstate = wxPyBeginAllowThreads();
15089 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15090
15091 wxPyEndAllowThreads(__tstate);
15092 if (PyErr_Occurred()) SWIG_fail;
15093 }
15094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15095 {
15096 if (temp2)
15097 delete arg2;
15098 }
15099 return resultobj;
15100 fail:
15101 {
15102 if (temp2)
15103 delete arg2;
15104 }
15105 return NULL;
15106 }
15107
15108
15109 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj;
15111 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15112 wxString *arg2 = 0 ;
15113 bool arg3 = (bool) false ;
15114 bool result;
15115 bool temp2 = false ;
15116 PyObject * obj0 = 0 ;
15117 PyObject * obj1 = 0 ;
15118 PyObject * obj2 = 0 ;
15119 char *kwnames[] = {
15120 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15121 };
15122
15123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15125 if (SWIG_arg_fail(1)) SWIG_fail;
15126 {
15127 arg2 = wxString_in_helper(obj1);
15128 if (arg2 == NULL) SWIG_fail;
15129 temp2 = true;
15130 }
15131 if (obj2) {
15132 {
15133 arg3 = (bool)(SWIG_As_bool(obj2));
15134 if (SWIG_arg_fail(3)) SWIG_fail;
15135 }
15136 }
15137 {
15138 PyThreadState* __tstate = wxPyBeginAllowThreads();
15139 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15140
15141 wxPyEndAllowThreads(__tstate);
15142 if (PyErr_Occurred()) SWIG_fail;
15143 }
15144 {
15145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15146 }
15147 {
15148 if (temp2)
15149 delete arg2;
15150 }
15151 return resultobj;
15152 fail:
15153 {
15154 if (temp2)
15155 delete arg2;
15156 }
15157 return NULL;
15158 }
15159
15160
15161 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15162 PyObject *resultobj;
15163 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15164 wxString *arg2 = 0 ;
15165 bool result;
15166 bool temp2 = false ;
15167 PyObject * obj0 = 0 ;
15168 PyObject * obj1 = 0 ;
15169 char *kwnames[] = {
15170 (char *) "self",(char *) "filename", NULL
15171 };
15172
15173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15175 if (SWIG_arg_fail(1)) SWIG_fail;
15176 {
15177 arg2 = wxString_in_helper(obj1);
15178 if (arg2 == NULL) SWIG_fail;
15179 temp2 = true;
15180 }
15181 {
15182 PyThreadState* __tstate = wxPyBeginAllowThreads();
15183 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15184
15185 wxPyEndAllowThreads(__tstate);
15186 if (PyErr_Occurred()) SWIG_fail;
15187 }
15188 {
15189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15190 }
15191 {
15192 if (temp2)
15193 delete arg2;
15194 }
15195 return resultobj;
15196 fail:
15197 {
15198 if (temp2)
15199 delete arg2;
15200 }
15201 return NULL;
15202 }
15203
15204
15205 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15206 PyObject *resultobj;
15207 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15208 PyObject *result;
15209 PyObject * obj0 = 0 ;
15210 char *kwnames[] = {
15211 (char *) "self", NULL
15212 };
15213
15214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15216 if (SWIG_arg_fail(1)) SWIG_fail;
15217 {
15218 PyThreadState* __tstate = wxPyBeginAllowThreads();
15219 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15220
15221 wxPyEndAllowThreads(__tstate);
15222 if (PyErr_Occurred()) SWIG_fail;
15223 }
15224 resultobj = result;
15225 return resultobj;
15226 fail:
15227 return NULL;
15228 }
15229
15230
15231 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15232 PyObject *resultobj;
15233 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15234 wxFileTypeInfo *arg2 = 0 ;
15235 PyObject * obj0 = 0 ;
15236 PyObject * obj1 = 0 ;
15237 char *kwnames[] = {
15238 (char *) "self",(char *) "ft", NULL
15239 };
15240
15241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15243 if (SWIG_arg_fail(1)) SWIG_fail;
15244 {
15245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15246 if (SWIG_arg_fail(2)) SWIG_fail;
15247 if (arg2 == NULL) {
15248 SWIG_null_ref("wxFileTypeInfo");
15249 }
15250 if (SWIG_arg_fail(2)) SWIG_fail;
15251 }
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15255
15256 wxPyEndAllowThreads(__tstate);
15257 if (PyErr_Occurred()) SWIG_fail;
15258 }
15259 Py_INCREF(Py_None); resultobj = Py_None;
15260 return resultobj;
15261 fail:
15262 return NULL;
15263 }
15264
15265
15266 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15267 PyObject *resultobj;
15268 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15269 wxFileTypeInfo *arg2 = 0 ;
15270 wxFileType *result;
15271 PyObject * obj0 = 0 ;
15272 PyObject * obj1 = 0 ;
15273 char *kwnames[] = {
15274 (char *) "self",(char *) "ftInfo", NULL
15275 };
15276
15277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15279 if (SWIG_arg_fail(1)) SWIG_fail;
15280 {
15281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15282 if (SWIG_arg_fail(2)) SWIG_fail;
15283 if (arg2 == NULL) {
15284 SWIG_null_ref("wxFileTypeInfo");
15285 }
15286 if (SWIG_arg_fail(2)) SWIG_fail;
15287 }
15288 {
15289 PyThreadState* __tstate = wxPyBeginAllowThreads();
15290 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15291
15292 wxPyEndAllowThreads(__tstate);
15293 if (PyErr_Occurred()) SWIG_fail;
15294 }
15295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15303 PyObject *resultobj;
15304 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15305 wxFileType *arg2 = (wxFileType *) 0 ;
15306 bool result;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 char *kwnames[] = {
15310 (char *) "self",(char *) "ft", NULL
15311 };
15312
15313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15315 if (SWIG_arg_fail(1)) SWIG_fail;
15316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15317 if (SWIG_arg_fail(2)) SWIG_fail;
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (bool)(arg1)->Unassociate(arg2);
15321
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 {
15326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15327 }
15328 return resultobj;
15329 fail:
15330 return NULL;
15331 }
15332
15333
15334 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15335 PyObject *resultobj;
15336 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15337 PyObject * obj0 = 0 ;
15338 char *kwnames[] = {
15339 (char *) "self", NULL
15340 };
15341
15342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15344 if (SWIG_arg_fail(1)) SWIG_fail;
15345 {
15346 PyThreadState* __tstate = wxPyBeginAllowThreads();
15347 delete arg1;
15348
15349 wxPyEndAllowThreads(__tstate);
15350 if (PyErr_Occurred()) SWIG_fail;
15351 }
15352 Py_INCREF(Py_None); resultobj = Py_None;
15353 return resultobj;
15354 fail:
15355 return NULL;
15356 }
15357
15358
15359 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15360 PyObject *obj;
15361 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15362 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15363 Py_INCREF(obj);
15364 return Py_BuildValue((char *)"");
15365 }
15366 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15367 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15368 return 1;
15369 }
15370
15371
15372 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15373 PyObject *pyobj;
15374
15375 {
15376 #if wxUSE_UNICODE
15377 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15378 #else
15379 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15380 #endif
15381 }
15382 return pyobj;
15383 }
15384
15385
15386 static int _wrap_ART_MENU_set(PyObject *) {
15387 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15388 return 1;
15389 }
15390
15391
15392 static PyObject *_wrap_ART_MENU_get(void) {
15393 PyObject *pyobj;
15394
15395 {
15396 #if wxUSE_UNICODE
15397 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15398 #else
15399 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15400 #endif
15401 }
15402 return pyobj;
15403 }
15404
15405
15406 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15407 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15408 return 1;
15409 }
15410
15411
15412 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15413 PyObject *pyobj;
15414
15415 {
15416 #if wxUSE_UNICODE
15417 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15418 #else
15419 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15420 #endif
15421 }
15422 return pyobj;
15423 }
15424
15425
15426 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15427 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15428 return 1;
15429 }
15430
15431
15432 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15433 PyObject *pyobj;
15434
15435 {
15436 #if wxUSE_UNICODE
15437 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15438 #else
15439 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15440 #endif
15441 }
15442 return pyobj;
15443 }
15444
15445
15446 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15447 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15448 return 1;
15449 }
15450
15451
15452 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15453 PyObject *pyobj;
15454
15455 {
15456 #if wxUSE_UNICODE
15457 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15458 #else
15459 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15460 #endif
15461 }
15462 return pyobj;
15463 }
15464
15465
15466 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15467 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15468 return 1;
15469 }
15470
15471
15472 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15473 PyObject *pyobj;
15474
15475 {
15476 #if wxUSE_UNICODE
15477 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15478 #else
15479 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15480 #endif
15481 }
15482 return pyobj;
15483 }
15484
15485
15486 static int _wrap_ART_BUTTON_set(PyObject *) {
15487 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15488 return 1;
15489 }
15490
15491
15492 static PyObject *_wrap_ART_BUTTON_get(void) {
15493 PyObject *pyobj;
15494
15495 {
15496 #if wxUSE_UNICODE
15497 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15498 #else
15499 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15500 #endif
15501 }
15502 return pyobj;
15503 }
15504
15505
15506 static int _wrap_ART_OTHER_set(PyObject *) {
15507 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15508 return 1;
15509 }
15510
15511
15512 static PyObject *_wrap_ART_OTHER_get(void) {
15513 PyObject *pyobj;
15514
15515 {
15516 #if wxUSE_UNICODE
15517 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15518 #else
15519 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15520 #endif
15521 }
15522 return pyobj;
15523 }
15524
15525
15526 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15527 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15528 return 1;
15529 }
15530
15531
15532 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15533 PyObject *pyobj;
15534
15535 {
15536 #if wxUSE_UNICODE
15537 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15538 #else
15539 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15540 #endif
15541 }
15542 return pyobj;
15543 }
15544
15545
15546 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15547 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15548 return 1;
15549 }
15550
15551
15552 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15553 PyObject *pyobj;
15554
15555 {
15556 #if wxUSE_UNICODE
15557 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15558 #else
15559 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15560 #endif
15561 }
15562 return pyobj;
15563 }
15564
15565
15566 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15567 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15568 return 1;
15569 }
15570
15571
15572 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15573 PyObject *pyobj;
15574
15575 {
15576 #if wxUSE_UNICODE
15577 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15578 #else
15579 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15580 #endif
15581 }
15582 return pyobj;
15583 }
15584
15585
15586 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15587 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15588 return 1;
15589 }
15590
15591
15592 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15593 PyObject *pyobj;
15594
15595 {
15596 #if wxUSE_UNICODE
15597 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15598 #else
15599 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15600 #endif
15601 }
15602 return pyobj;
15603 }
15604
15605
15606 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15607 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15608 return 1;
15609 }
15610
15611
15612 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15613 PyObject *pyobj;
15614
15615 {
15616 #if wxUSE_UNICODE
15617 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15618 #else
15619 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15620 #endif
15621 }
15622 return pyobj;
15623 }
15624
15625
15626 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15627 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15628 return 1;
15629 }
15630
15631
15632 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15633 PyObject *pyobj;
15634
15635 {
15636 #if wxUSE_UNICODE
15637 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15638 #else
15639 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15640 #endif
15641 }
15642 return pyobj;
15643 }
15644
15645
15646 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15647 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15648 return 1;
15649 }
15650
15651
15652 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15653 PyObject *pyobj;
15654
15655 {
15656 #if wxUSE_UNICODE
15657 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15658 #else
15659 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15660 #endif
15661 }
15662 return pyobj;
15663 }
15664
15665
15666 static int _wrap_ART_GO_BACK_set(PyObject *) {
15667 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15668 return 1;
15669 }
15670
15671
15672 static PyObject *_wrap_ART_GO_BACK_get(void) {
15673 PyObject *pyobj;
15674
15675 {
15676 #if wxUSE_UNICODE
15677 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15678 #else
15679 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15680 #endif
15681 }
15682 return pyobj;
15683 }
15684
15685
15686 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15687 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15688 return 1;
15689 }
15690
15691
15692 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15693 PyObject *pyobj;
15694
15695 {
15696 #if wxUSE_UNICODE
15697 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15698 #else
15699 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15700 #endif
15701 }
15702 return pyobj;
15703 }
15704
15705
15706 static int _wrap_ART_GO_UP_set(PyObject *) {
15707 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15708 return 1;
15709 }
15710
15711
15712 static PyObject *_wrap_ART_GO_UP_get(void) {
15713 PyObject *pyobj;
15714
15715 {
15716 #if wxUSE_UNICODE
15717 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15718 #else
15719 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15720 #endif
15721 }
15722 return pyobj;
15723 }
15724
15725
15726 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15727 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15728 return 1;
15729 }
15730
15731
15732 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15733 PyObject *pyobj;
15734
15735 {
15736 #if wxUSE_UNICODE
15737 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15738 #else
15739 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15740 #endif
15741 }
15742 return pyobj;
15743 }
15744
15745
15746 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15747 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15748 return 1;
15749 }
15750
15751
15752 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15753 PyObject *pyobj;
15754
15755 {
15756 #if wxUSE_UNICODE
15757 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15758 #else
15759 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15760 #endif
15761 }
15762 return pyobj;
15763 }
15764
15765
15766 static int _wrap_ART_GO_HOME_set(PyObject *) {
15767 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15768 return 1;
15769 }
15770
15771
15772 static PyObject *_wrap_ART_GO_HOME_get(void) {
15773 PyObject *pyobj;
15774
15775 {
15776 #if wxUSE_UNICODE
15777 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15778 #else
15779 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15780 #endif
15781 }
15782 return pyobj;
15783 }
15784
15785
15786 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15787 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15788 return 1;
15789 }
15790
15791
15792 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15793 PyObject *pyobj;
15794
15795 {
15796 #if wxUSE_UNICODE
15797 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15798 #else
15799 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15800 #endif
15801 }
15802 return pyobj;
15803 }
15804
15805
15806 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15807 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15808 return 1;
15809 }
15810
15811
15812 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15813 PyObject *pyobj;
15814
15815 {
15816 #if wxUSE_UNICODE
15817 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15818 #else
15819 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15820 #endif
15821 }
15822 return pyobj;
15823 }
15824
15825
15826 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15827 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15828 return 1;
15829 }
15830
15831
15832 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15833 PyObject *pyobj;
15834
15835 {
15836 #if wxUSE_UNICODE
15837 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15838 #else
15839 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15840 #endif
15841 }
15842 return pyobj;
15843 }
15844
15845
15846 static int _wrap_ART_PRINT_set(PyObject *) {
15847 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15848 return 1;
15849 }
15850
15851
15852 static PyObject *_wrap_ART_PRINT_get(void) {
15853 PyObject *pyobj;
15854
15855 {
15856 #if wxUSE_UNICODE
15857 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15858 #else
15859 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15860 #endif
15861 }
15862 return pyobj;
15863 }
15864
15865
15866 static int _wrap_ART_HELP_set(PyObject *) {
15867 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15868 return 1;
15869 }
15870
15871
15872 static PyObject *_wrap_ART_HELP_get(void) {
15873 PyObject *pyobj;
15874
15875 {
15876 #if wxUSE_UNICODE
15877 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15878 #else
15879 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15880 #endif
15881 }
15882 return pyobj;
15883 }
15884
15885
15886 static int _wrap_ART_TIP_set(PyObject *) {
15887 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15888 return 1;
15889 }
15890
15891
15892 static PyObject *_wrap_ART_TIP_get(void) {
15893 PyObject *pyobj;
15894
15895 {
15896 #if wxUSE_UNICODE
15897 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15898 #else
15899 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15900 #endif
15901 }
15902 return pyobj;
15903 }
15904
15905
15906 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15907 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15908 return 1;
15909 }
15910
15911
15912 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15913 PyObject *pyobj;
15914
15915 {
15916 #if wxUSE_UNICODE
15917 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15918 #else
15919 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15920 #endif
15921 }
15922 return pyobj;
15923 }
15924
15925
15926 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15927 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15928 return 1;
15929 }
15930
15931
15932 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15933 PyObject *pyobj;
15934
15935 {
15936 #if wxUSE_UNICODE
15937 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15938 #else
15939 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15940 #endif
15941 }
15942 return pyobj;
15943 }
15944
15945
15946 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15947 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15948 return 1;
15949 }
15950
15951
15952 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15953 PyObject *pyobj;
15954
15955 {
15956 #if wxUSE_UNICODE
15957 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15958 #else
15959 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15960 #endif
15961 }
15962 return pyobj;
15963 }
15964
15965
15966 static int _wrap_ART_HARDDISK_set(PyObject *) {
15967 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15968 return 1;
15969 }
15970
15971
15972 static PyObject *_wrap_ART_HARDDISK_get(void) {
15973 PyObject *pyobj;
15974
15975 {
15976 #if wxUSE_UNICODE
15977 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15978 #else
15979 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15980 #endif
15981 }
15982 return pyobj;
15983 }
15984
15985
15986 static int _wrap_ART_FLOPPY_set(PyObject *) {
15987 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15988 return 1;
15989 }
15990
15991
15992 static PyObject *_wrap_ART_FLOPPY_get(void) {
15993 PyObject *pyobj;
15994
15995 {
15996 #if wxUSE_UNICODE
15997 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15998 #else
15999 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16000 #endif
16001 }
16002 return pyobj;
16003 }
16004
16005
16006 static int _wrap_ART_CDROM_set(PyObject *) {
16007 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16008 return 1;
16009 }
16010
16011
16012 static PyObject *_wrap_ART_CDROM_get(void) {
16013 PyObject *pyobj;
16014
16015 {
16016 #if wxUSE_UNICODE
16017 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16018 #else
16019 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16020 #endif
16021 }
16022 return pyobj;
16023 }
16024
16025
16026 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16027 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16028 return 1;
16029 }
16030
16031
16032 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16033 PyObject *pyobj;
16034
16035 {
16036 #if wxUSE_UNICODE
16037 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16038 #else
16039 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16040 #endif
16041 }
16042 return pyobj;
16043 }
16044
16045
16046 static int _wrap_ART_FOLDER_set(PyObject *) {
16047 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16048 return 1;
16049 }
16050
16051
16052 static PyObject *_wrap_ART_FOLDER_get(void) {
16053 PyObject *pyobj;
16054
16055 {
16056 #if wxUSE_UNICODE
16057 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16058 #else
16059 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16060 #endif
16061 }
16062 return pyobj;
16063 }
16064
16065
16066 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16067 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16068 return 1;
16069 }
16070
16071
16072 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16073 PyObject *pyobj;
16074
16075 {
16076 #if wxUSE_UNICODE
16077 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16078 #else
16079 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16080 #endif
16081 }
16082 return pyobj;
16083 }
16084
16085
16086 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16087 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16088 return 1;
16089 }
16090
16091
16092 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16093 PyObject *pyobj;
16094
16095 {
16096 #if wxUSE_UNICODE
16097 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16098 #else
16099 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16100 #endif
16101 }
16102 return pyobj;
16103 }
16104
16105
16106 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16107 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16108 return 1;
16109 }
16110
16111
16112 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16113 PyObject *pyobj;
16114
16115 {
16116 #if wxUSE_UNICODE
16117 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16118 #else
16119 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16120 #endif
16121 }
16122 return pyobj;
16123 }
16124
16125
16126 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16127 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16128 return 1;
16129 }
16130
16131
16132 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16133 PyObject *pyobj;
16134
16135 {
16136 #if wxUSE_UNICODE
16137 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16138 #else
16139 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16140 #endif
16141 }
16142 return pyobj;
16143 }
16144
16145
16146 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16147 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16148 return 1;
16149 }
16150
16151
16152 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16153 PyObject *pyobj;
16154
16155 {
16156 #if wxUSE_UNICODE
16157 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16158 #else
16159 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16160 #endif
16161 }
16162 return pyobj;
16163 }
16164
16165
16166 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16167 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16168 return 1;
16169 }
16170
16171
16172 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16173 PyObject *pyobj;
16174
16175 {
16176 #if wxUSE_UNICODE
16177 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16178 #else
16179 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16180 #endif
16181 }
16182 return pyobj;
16183 }
16184
16185
16186 static int _wrap_ART_ERROR_set(PyObject *) {
16187 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16188 return 1;
16189 }
16190
16191
16192 static PyObject *_wrap_ART_ERROR_get(void) {
16193 PyObject *pyobj;
16194
16195 {
16196 #if wxUSE_UNICODE
16197 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16198 #else
16199 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16200 #endif
16201 }
16202 return pyobj;
16203 }
16204
16205
16206 static int _wrap_ART_QUESTION_set(PyObject *) {
16207 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16208 return 1;
16209 }
16210
16211
16212 static PyObject *_wrap_ART_QUESTION_get(void) {
16213 PyObject *pyobj;
16214
16215 {
16216 #if wxUSE_UNICODE
16217 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16218 #else
16219 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16220 #endif
16221 }
16222 return pyobj;
16223 }
16224
16225
16226 static int _wrap_ART_WARNING_set(PyObject *) {
16227 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16228 return 1;
16229 }
16230
16231
16232 static PyObject *_wrap_ART_WARNING_get(void) {
16233 PyObject *pyobj;
16234
16235 {
16236 #if wxUSE_UNICODE
16237 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16238 #else
16239 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16240 #endif
16241 }
16242 return pyobj;
16243 }
16244
16245
16246 static int _wrap_ART_INFORMATION_set(PyObject *) {
16247 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16248 return 1;
16249 }
16250
16251
16252 static PyObject *_wrap_ART_INFORMATION_get(void) {
16253 PyObject *pyobj;
16254
16255 {
16256 #if wxUSE_UNICODE
16257 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16258 #else
16259 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16260 #endif
16261 }
16262 return pyobj;
16263 }
16264
16265
16266 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16267 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16268 return 1;
16269 }
16270
16271
16272 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16273 PyObject *pyobj;
16274
16275 {
16276 #if wxUSE_UNICODE
16277 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16278 #else
16279 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16280 #endif
16281 }
16282 return pyobj;
16283 }
16284
16285
16286 static int _wrap_ART_COPY_set(PyObject *) {
16287 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16288 return 1;
16289 }
16290
16291
16292 static PyObject *_wrap_ART_COPY_get(void) {
16293 PyObject *pyobj;
16294
16295 {
16296 #if wxUSE_UNICODE
16297 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16298 #else
16299 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16300 #endif
16301 }
16302 return pyobj;
16303 }
16304
16305
16306 static int _wrap_ART_CUT_set(PyObject *) {
16307 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16308 return 1;
16309 }
16310
16311
16312 static PyObject *_wrap_ART_CUT_get(void) {
16313 PyObject *pyobj;
16314
16315 {
16316 #if wxUSE_UNICODE
16317 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16318 #else
16319 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16320 #endif
16321 }
16322 return pyobj;
16323 }
16324
16325
16326 static int _wrap_ART_PASTE_set(PyObject *) {
16327 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16328 return 1;
16329 }
16330
16331
16332 static PyObject *_wrap_ART_PASTE_get(void) {
16333 PyObject *pyobj;
16334
16335 {
16336 #if wxUSE_UNICODE
16337 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16338 #else
16339 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16340 #endif
16341 }
16342 return pyobj;
16343 }
16344
16345
16346 static int _wrap_ART_DELETE_set(PyObject *) {
16347 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16348 return 1;
16349 }
16350
16351
16352 static PyObject *_wrap_ART_DELETE_get(void) {
16353 PyObject *pyobj;
16354
16355 {
16356 #if wxUSE_UNICODE
16357 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16358 #else
16359 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16360 #endif
16361 }
16362 return pyobj;
16363 }
16364
16365
16366 static int _wrap_ART_UNDO_set(PyObject *) {
16367 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16368 return 1;
16369 }
16370
16371
16372 static PyObject *_wrap_ART_UNDO_get(void) {
16373 PyObject *pyobj;
16374
16375 {
16376 #if wxUSE_UNICODE
16377 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16378 #else
16379 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16380 #endif
16381 }
16382 return pyobj;
16383 }
16384
16385
16386 static int _wrap_ART_REDO_set(PyObject *) {
16387 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16388 return 1;
16389 }
16390
16391
16392 static PyObject *_wrap_ART_REDO_get(void) {
16393 PyObject *pyobj;
16394
16395 {
16396 #if wxUSE_UNICODE
16397 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16398 #else
16399 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16400 #endif
16401 }
16402 return pyobj;
16403 }
16404
16405
16406 static int _wrap_ART_QUIT_set(PyObject *) {
16407 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16408 return 1;
16409 }
16410
16411
16412 static PyObject *_wrap_ART_QUIT_get(void) {
16413 PyObject *pyobj;
16414
16415 {
16416 #if wxUSE_UNICODE
16417 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16418 #else
16419 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16420 #endif
16421 }
16422 return pyobj;
16423 }
16424
16425
16426 static int _wrap_ART_FIND_set(PyObject *) {
16427 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16428 return 1;
16429 }
16430
16431
16432 static PyObject *_wrap_ART_FIND_get(void) {
16433 PyObject *pyobj;
16434
16435 {
16436 #if wxUSE_UNICODE
16437 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16438 #else
16439 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16440 #endif
16441 }
16442 return pyobj;
16443 }
16444
16445
16446 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16447 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16448 return 1;
16449 }
16450
16451
16452 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16453 PyObject *pyobj;
16454
16455 {
16456 #if wxUSE_UNICODE
16457 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16458 #else
16459 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16460 #endif
16461 }
16462 return pyobj;
16463 }
16464
16465
16466 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16467 PyObject *resultobj;
16468 wxPyArtProvider *result;
16469 char *kwnames[] = {
16470 NULL
16471 };
16472
16473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16474 {
16475 if (!wxPyCheckForApp()) SWIG_fail;
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 result = (wxPyArtProvider *)new wxPyArtProvider();
16478
16479 wxPyEndAllowThreads(__tstate);
16480 if (PyErr_Occurred()) SWIG_fail;
16481 }
16482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16483 return resultobj;
16484 fail:
16485 return NULL;
16486 }
16487
16488
16489 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16490 PyObject *resultobj;
16491 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16492 PyObject *arg2 = (PyObject *) 0 ;
16493 PyObject *arg3 = (PyObject *) 0 ;
16494 PyObject * obj0 = 0 ;
16495 PyObject * obj1 = 0 ;
16496 PyObject * obj2 = 0 ;
16497 char *kwnames[] = {
16498 (char *) "self",(char *) "self",(char *) "_class", NULL
16499 };
16500
16501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16503 if (SWIG_arg_fail(1)) SWIG_fail;
16504 arg2 = obj1;
16505 arg3 = obj2;
16506 {
16507 PyThreadState* __tstate = wxPyBeginAllowThreads();
16508 (arg1)->_setCallbackInfo(arg2,arg3);
16509
16510 wxPyEndAllowThreads(__tstate);
16511 if (PyErr_Occurred()) SWIG_fail;
16512 }
16513 Py_INCREF(Py_None); resultobj = Py_None;
16514 return resultobj;
16515 fail:
16516 return NULL;
16517 }
16518
16519
16520 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16521 PyObject *resultobj;
16522 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16523 PyObject * obj0 = 0 ;
16524 char *kwnames[] = {
16525 (char *) "provider", NULL
16526 };
16527
16528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16530 if (SWIG_arg_fail(1)) SWIG_fail;
16531 {
16532 PyThreadState* __tstate = wxPyBeginAllowThreads();
16533 wxPyArtProvider::PushProvider(arg1);
16534
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 Py_INCREF(Py_None); resultobj = Py_None;
16539 return resultobj;
16540 fail:
16541 return NULL;
16542 }
16543
16544
16545 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj;
16547 bool result;
16548 char *kwnames[] = {
16549 NULL
16550 };
16551
16552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16553 {
16554 PyThreadState* __tstate = wxPyBeginAllowThreads();
16555 result = (bool)wxPyArtProvider::PopProvider();
16556
16557 wxPyEndAllowThreads(__tstate);
16558 if (PyErr_Occurred()) SWIG_fail;
16559 }
16560 {
16561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16562 }
16563 return resultobj;
16564 fail:
16565 return NULL;
16566 }
16567
16568
16569 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16570 PyObject *resultobj;
16571 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16572 bool result;
16573 PyObject * obj0 = 0 ;
16574 char *kwnames[] = {
16575 (char *) "provider", NULL
16576 };
16577
16578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16580 if (SWIG_arg_fail(1)) SWIG_fail;
16581 {
16582 PyThreadState* __tstate = wxPyBeginAllowThreads();
16583 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16584
16585 wxPyEndAllowThreads(__tstate);
16586 if (PyErr_Occurred()) SWIG_fail;
16587 }
16588 {
16589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16590 }
16591 return resultobj;
16592 fail:
16593 return NULL;
16594 }
16595
16596
16597 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16598 PyObject *resultobj;
16599 wxString *arg1 = 0 ;
16600 wxString const &arg2_defvalue = wxPyART_OTHER ;
16601 wxString *arg2 = (wxString *) &arg2_defvalue ;
16602 wxSize const &arg3_defvalue = wxDefaultSize ;
16603 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16604 wxBitmap result;
16605 bool temp1 = false ;
16606 bool temp2 = false ;
16607 wxSize temp3 ;
16608 PyObject * obj0 = 0 ;
16609 PyObject * obj1 = 0 ;
16610 PyObject * obj2 = 0 ;
16611 char *kwnames[] = {
16612 (char *) "id",(char *) "client",(char *) "size", NULL
16613 };
16614
16615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16616 {
16617 arg1 = wxString_in_helper(obj0);
16618 if (arg1 == NULL) SWIG_fail;
16619 temp1 = true;
16620 }
16621 if (obj1) {
16622 {
16623 arg2 = wxString_in_helper(obj1);
16624 if (arg2 == NULL) SWIG_fail;
16625 temp2 = true;
16626 }
16627 }
16628 if (obj2) {
16629 {
16630 arg3 = &temp3;
16631 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16632 }
16633 }
16634 {
16635 if (!wxPyCheckForApp()) SWIG_fail;
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16638
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 {
16643 wxBitmap * resultptr;
16644 resultptr = new wxBitmap((wxBitmap &)(result));
16645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16646 }
16647 {
16648 if (temp1)
16649 delete arg1;
16650 }
16651 {
16652 if (temp2)
16653 delete arg2;
16654 }
16655 return resultobj;
16656 fail:
16657 {
16658 if (temp1)
16659 delete arg1;
16660 }
16661 {
16662 if (temp2)
16663 delete arg2;
16664 }
16665 return NULL;
16666 }
16667
16668
16669 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16670 PyObject *resultobj;
16671 wxString *arg1 = 0 ;
16672 wxString const &arg2_defvalue = wxPyART_OTHER ;
16673 wxString *arg2 = (wxString *) &arg2_defvalue ;
16674 wxSize const &arg3_defvalue = wxDefaultSize ;
16675 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16676 wxIcon result;
16677 bool temp1 = false ;
16678 bool temp2 = false ;
16679 wxSize temp3 ;
16680 PyObject * obj0 = 0 ;
16681 PyObject * obj1 = 0 ;
16682 PyObject * obj2 = 0 ;
16683 char *kwnames[] = {
16684 (char *) "id",(char *) "client",(char *) "size", NULL
16685 };
16686
16687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16688 {
16689 arg1 = wxString_in_helper(obj0);
16690 if (arg1 == NULL) SWIG_fail;
16691 temp1 = true;
16692 }
16693 if (obj1) {
16694 {
16695 arg2 = wxString_in_helper(obj1);
16696 if (arg2 == NULL) SWIG_fail;
16697 temp2 = true;
16698 }
16699 }
16700 if (obj2) {
16701 {
16702 arg3 = &temp3;
16703 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16704 }
16705 }
16706 {
16707 if (!wxPyCheckForApp()) SWIG_fail;
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16710
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 {
16715 wxIcon * resultptr;
16716 resultptr = new wxIcon((wxIcon &)(result));
16717 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16718 }
16719 {
16720 if (temp1)
16721 delete arg1;
16722 }
16723 {
16724 if (temp2)
16725 delete arg2;
16726 }
16727 return resultobj;
16728 fail:
16729 {
16730 if (temp1)
16731 delete arg1;
16732 }
16733 {
16734 if (temp2)
16735 delete arg2;
16736 }
16737 return NULL;
16738 }
16739
16740
16741 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16742 PyObject *resultobj;
16743 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16744 PyObject * obj0 = 0 ;
16745 char *kwnames[] = {
16746 (char *) "self", NULL
16747 };
16748
16749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16751 if (SWIG_arg_fail(1)) SWIG_fail;
16752 {
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 wxPyArtProvider_Destroy(arg1);
16755
16756 wxPyEndAllowThreads(__tstate);
16757 if (PyErr_Occurred()) SWIG_fail;
16758 }
16759 Py_INCREF(Py_None); resultobj = Py_None;
16760 return resultobj;
16761 fail:
16762 return NULL;
16763 }
16764
16765
16766 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16767 PyObject *obj;
16768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16769 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16770 Py_INCREF(obj);
16771 return Py_BuildValue((char *)"");
16772 }
16773 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16774 PyObject *resultobj;
16775 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16776 PyObject * obj0 = 0 ;
16777 char *kwnames[] = {
16778 (char *) "self", NULL
16779 };
16780
16781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16783 if (SWIG_arg_fail(1)) SWIG_fail;
16784 {
16785 PyThreadState* __tstate = wxPyBeginAllowThreads();
16786 delete arg1;
16787
16788 wxPyEndAllowThreads(__tstate);
16789 if (PyErr_Occurred()) SWIG_fail;
16790 }
16791 Py_INCREF(Py_None); resultobj = Py_None;
16792 return resultobj;
16793 fail:
16794 return NULL;
16795 }
16796
16797
16798 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16799 PyObject *resultobj;
16800 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16801 wxConfigBase *result;
16802 PyObject * obj0 = 0 ;
16803 char *kwnames[] = {
16804 (char *) "config", NULL
16805 };
16806
16807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16809 if (SWIG_arg_fail(1)) SWIG_fail;
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16813
16814 wxPyEndAllowThreads(__tstate);
16815 if (PyErr_Occurred()) SWIG_fail;
16816 }
16817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16818 return resultobj;
16819 fail:
16820 return NULL;
16821 }
16822
16823
16824 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16825 PyObject *resultobj;
16826 bool arg1 = (bool) true ;
16827 wxConfigBase *result;
16828 PyObject * obj0 = 0 ;
16829 char *kwnames[] = {
16830 (char *) "createOnDemand", NULL
16831 };
16832
16833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16834 if (obj0) {
16835 {
16836 arg1 = (bool)(SWIG_As_bool(obj0));
16837 if (SWIG_arg_fail(1)) SWIG_fail;
16838 }
16839 }
16840 {
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16843
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16848 return resultobj;
16849 fail:
16850 return NULL;
16851 }
16852
16853
16854 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16855 PyObject *resultobj;
16856 wxConfigBase *result;
16857 char *kwnames[] = {
16858 NULL
16859 };
16860
16861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16862 {
16863 PyThreadState* __tstate = wxPyBeginAllowThreads();
16864 result = (wxConfigBase *)wxConfigBase::Create();
16865
16866 wxPyEndAllowThreads(__tstate);
16867 if (PyErr_Occurred()) SWIG_fail;
16868 }
16869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16870 return resultobj;
16871 fail:
16872 return NULL;
16873 }
16874
16875
16876 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16877 PyObject *resultobj;
16878 char *kwnames[] = {
16879 NULL
16880 };
16881
16882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16883 {
16884 PyThreadState* __tstate = wxPyBeginAllowThreads();
16885 wxConfigBase::DontCreateOnDemand();
16886
16887 wxPyEndAllowThreads(__tstate);
16888 if (PyErr_Occurred()) SWIG_fail;
16889 }
16890 Py_INCREF(Py_None); resultobj = Py_None;
16891 return resultobj;
16892 fail:
16893 return NULL;
16894 }
16895
16896
16897 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16898 PyObject *resultobj;
16899 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16900 wxString *arg2 = 0 ;
16901 bool temp2 = false ;
16902 PyObject * obj0 = 0 ;
16903 PyObject * obj1 = 0 ;
16904 char *kwnames[] = {
16905 (char *) "self",(char *) "path", NULL
16906 };
16907
16908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16910 if (SWIG_arg_fail(1)) SWIG_fail;
16911 {
16912 arg2 = wxString_in_helper(obj1);
16913 if (arg2 == NULL) SWIG_fail;
16914 temp2 = true;
16915 }
16916 {
16917 PyThreadState* __tstate = wxPyBeginAllowThreads();
16918 (arg1)->SetPath((wxString const &)*arg2);
16919
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 Py_INCREF(Py_None); resultobj = Py_None;
16924 {
16925 if (temp2)
16926 delete arg2;
16927 }
16928 return resultobj;
16929 fail:
16930 {
16931 if (temp2)
16932 delete arg2;
16933 }
16934 return NULL;
16935 }
16936
16937
16938 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16939 PyObject *resultobj;
16940 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16941 wxString *result;
16942 PyObject * obj0 = 0 ;
16943 char *kwnames[] = {
16944 (char *) "self", NULL
16945 };
16946
16947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16949 if (SWIG_arg_fail(1)) SWIG_fail;
16950 {
16951 PyThreadState* __tstate = wxPyBeginAllowThreads();
16952 {
16953 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16954 result = (wxString *) &_result_ref;
16955 }
16956
16957 wxPyEndAllowThreads(__tstate);
16958 if (PyErr_Occurred()) SWIG_fail;
16959 }
16960 {
16961 #if wxUSE_UNICODE
16962 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16963 #else
16964 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16965 #endif
16966 }
16967 return resultobj;
16968 fail:
16969 return NULL;
16970 }
16971
16972
16973 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16974 PyObject *resultobj;
16975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16976 PyObject *result;
16977 PyObject * obj0 = 0 ;
16978 char *kwnames[] = {
16979 (char *) "self", NULL
16980 };
16981
16982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16984 if (SWIG_arg_fail(1)) SWIG_fail;
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16988
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 resultobj = result;
16993 return resultobj;
16994 fail:
16995 return NULL;
16996 }
16997
16998
16999 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17000 PyObject *resultobj;
17001 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17002 long arg2 ;
17003 PyObject *result;
17004 PyObject * obj0 = 0 ;
17005 PyObject * obj1 = 0 ;
17006 char *kwnames[] = {
17007 (char *) "self",(char *) "index", NULL
17008 };
17009
17010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17012 if (SWIG_arg_fail(1)) SWIG_fail;
17013 {
17014 arg2 = (long)(SWIG_As_long(obj1));
17015 if (SWIG_arg_fail(2)) SWIG_fail;
17016 }
17017 {
17018 PyThreadState* __tstate = wxPyBeginAllowThreads();
17019 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17020
17021 wxPyEndAllowThreads(__tstate);
17022 if (PyErr_Occurred()) SWIG_fail;
17023 }
17024 resultobj = result;
17025 return resultobj;
17026 fail:
17027 return NULL;
17028 }
17029
17030
17031 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17032 PyObject *resultobj;
17033 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17034 PyObject *result;
17035 PyObject * obj0 = 0 ;
17036 char *kwnames[] = {
17037 (char *) "self", NULL
17038 };
17039
17040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17042 if (SWIG_arg_fail(1)) SWIG_fail;
17043 {
17044 PyThreadState* __tstate = wxPyBeginAllowThreads();
17045 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17046
17047 wxPyEndAllowThreads(__tstate);
17048 if (PyErr_Occurred()) SWIG_fail;
17049 }
17050 resultobj = result;
17051 return resultobj;
17052 fail:
17053 return NULL;
17054 }
17055
17056
17057 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj;
17059 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17060 long arg2 ;
17061 PyObject *result;
17062 PyObject * obj0 = 0 ;
17063 PyObject * obj1 = 0 ;
17064 char *kwnames[] = {
17065 (char *) "self",(char *) "index", NULL
17066 };
17067
17068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17070 if (SWIG_arg_fail(1)) SWIG_fail;
17071 {
17072 arg2 = (long)(SWIG_As_long(obj1));
17073 if (SWIG_arg_fail(2)) SWIG_fail;
17074 }
17075 {
17076 PyThreadState* __tstate = wxPyBeginAllowThreads();
17077 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17078
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 resultobj = result;
17083 return resultobj;
17084 fail:
17085 return NULL;
17086 }
17087
17088
17089 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17090 PyObject *resultobj;
17091 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17092 bool arg2 = (bool) false ;
17093 size_t result;
17094 PyObject * obj0 = 0 ;
17095 PyObject * obj1 = 0 ;
17096 char *kwnames[] = {
17097 (char *) "self",(char *) "recursive", NULL
17098 };
17099
17100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17102 if (SWIG_arg_fail(1)) SWIG_fail;
17103 if (obj1) {
17104 {
17105 arg2 = (bool)(SWIG_As_bool(obj1));
17106 if (SWIG_arg_fail(2)) SWIG_fail;
17107 }
17108 }
17109 {
17110 PyThreadState* __tstate = wxPyBeginAllowThreads();
17111 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17112
17113 wxPyEndAllowThreads(__tstate);
17114 if (PyErr_Occurred()) SWIG_fail;
17115 }
17116 {
17117 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17118 }
17119 return resultobj;
17120 fail:
17121 return NULL;
17122 }
17123
17124
17125 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17126 PyObject *resultobj;
17127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17128 bool arg2 = (bool) false ;
17129 size_t result;
17130 PyObject * obj0 = 0 ;
17131 PyObject * obj1 = 0 ;
17132 char *kwnames[] = {
17133 (char *) "self",(char *) "recursive", NULL
17134 };
17135
17136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17138 if (SWIG_arg_fail(1)) SWIG_fail;
17139 if (obj1) {
17140 {
17141 arg2 = (bool)(SWIG_As_bool(obj1));
17142 if (SWIG_arg_fail(2)) SWIG_fail;
17143 }
17144 }
17145 {
17146 PyThreadState* __tstate = wxPyBeginAllowThreads();
17147 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17148
17149 wxPyEndAllowThreads(__tstate);
17150 if (PyErr_Occurred()) SWIG_fail;
17151 }
17152 {
17153 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17154 }
17155 return resultobj;
17156 fail:
17157 return NULL;
17158 }
17159
17160
17161 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17162 PyObject *resultobj;
17163 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17164 wxString *arg2 = 0 ;
17165 bool result;
17166 bool temp2 = false ;
17167 PyObject * obj0 = 0 ;
17168 PyObject * obj1 = 0 ;
17169 char *kwnames[] = {
17170 (char *) "self",(char *) "name", NULL
17171 };
17172
17173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17175 if (SWIG_arg_fail(1)) SWIG_fail;
17176 {
17177 arg2 = wxString_in_helper(obj1);
17178 if (arg2 == NULL) SWIG_fail;
17179 temp2 = true;
17180 }
17181 {
17182 PyThreadState* __tstate = wxPyBeginAllowThreads();
17183 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17184
17185 wxPyEndAllowThreads(__tstate);
17186 if (PyErr_Occurred()) SWIG_fail;
17187 }
17188 {
17189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17190 }
17191 {
17192 if (temp2)
17193 delete arg2;
17194 }
17195 return resultobj;
17196 fail:
17197 {
17198 if (temp2)
17199 delete arg2;
17200 }
17201 return NULL;
17202 }
17203
17204
17205 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17206 PyObject *resultobj;
17207 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17208 wxString *arg2 = 0 ;
17209 bool result;
17210 bool temp2 = false ;
17211 PyObject * obj0 = 0 ;
17212 PyObject * obj1 = 0 ;
17213 char *kwnames[] = {
17214 (char *) "self",(char *) "name", NULL
17215 };
17216
17217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17219 if (SWIG_arg_fail(1)) SWIG_fail;
17220 {
17221 arg2 = wxString_in_helper(obj1);
17222 if (arg2 == NULL) SWIG_fail;
17223 temp2 = true;
17224 }
17225 {
17226 PyThreadState* __tstate = wxPyBeginAllowThreads();
17227 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17228
17229 wxPyEndAllowThreads(__tstate);
17230 if (PyErr_Occurred()) SWIG_fail;
17231 }
17232 {
17233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17234 }
17235 {
17236 if (temp2)
17237 delete arg2;
17238 }
17239 return resultobj;
17240 fail:
17241 {
17242 if (temp2)
17243 delete arg2;
17244 }
17245 return NULL;
17246 }
17247
17248
17249 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17250 PyObject *resultobj;
17251 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17252 wxString *arg2 = 0 ;
17253 bool result;
17254 bool temp2 = false ;
17255 PyObject * obj0 = 0 ;
17256 PyObject * obj1 = 0 ;
17257 char *kwnames[] = {
17258 (char *) "self",(char *) "name", NULL
17259 };
17260
17261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17263 if (SWIG_arg_fail(1)) SWIG_fail;
17264 {
17265 arg2 = wxString_in_helper(obj1);
17266 if (arg2 == NULL) SWIG_fail;
17267 temp2 = true;
17268 }
17269 {
17270 PyThreadState* __tstate = wxPyBeginAllowThreads();
17271 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17272
17273 wxPyEndAllowThreads(__tstate);
17274 if (PyErr_Occurred()) SWIG_fail;
17275 }
17276 {
17277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17278 }
17279 {
17280 if (temp2)
17281 delete arg2;
17282 }
17283 return resultobj;
17284 fail:
17285 {
17286 if (temp2)
17287 delete arg2;
17288 }
17289 return NULL;
17290 }
17291
17292
17293 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17294 PyObject *resultobj;
17295 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17296 wxString *arg2 = 0 ;
17297 wxConfigBase::EntryType result;
17298 bool temp2 = false ;
17299 PyObject * obj0 = 0 ;
17300 PyObject * obj1 = 0 ;
17301 char *kwnames[] = {
17302 (char *) "self",(char *) "name", NULL
17303 };
17304
17305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17307 if (SWIG_arg_fail(1)) SWIG_fail;
17308 {
17309 arg2 = wxString_in_helper(obj1);
17310 if (arg2 == NULL) SWIG_fail;
17311 temp2 = true;
17312 }
17313 {
17314 PyThreadState* __tstate = wxPyBeginAllowThreads();
17315 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17316
17317 wxPyEndAllowThreads(__tstate);
17318 if (PyErr_Occurred()) SWIG_fail;
17319 }
17320 resultobj = SWIG_From_int((result));
17321 {
17322 if (temp2)
17323 delete arg2;
17324 }
17325 return resultobj;
17326 fail:
17327 {
17328 if (temp2)
17329 delete arg2;
17330 }
17331 return NULL;
17332 }
17333
17334
17335 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17336 PyObject *resultobj;
17337 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17338 wxString *arg2 = 0 ;
17339 wxString const &arg3_defvalue = wxPyEmptyString ;
17340 wxString *arg3 = (wxString *) &arg3_defvalue ;
17341 wxString result;
17342 bool temp2 = false ;
17343 bool temp3 = false ;
17344 PyObject * obj0 = 0 ;
17345 PyObject * obj1 = 0 ;
17346 PyObject * obj2 = 0 ;
17347 char *kwnames[] = {
17348 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17349 };
17350
17351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17353 if (SWIG_arg_fail(1)) SWIG_fail;
17354 {
17355 arg2 = wxString_in_helper(obj1);
17356 if (arg2 == NULL) SWIG_fail;
17357 temp2 = true;
17358 }
17359 if (obj2) {
17360 {
17361 arg3 = wxString_in_helper(obj2);
17362 if (arg3 == NULL) SWIG_fail;
17363 temp3 = true;
17364 }
17365 }
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17369
17370 wxPyEndAllowThreads(__tstate);
17371 if (PyErr_Occurred()) SWIG_fail;
17372 }
17373 {
17374 #if wxUSE_UNICODE
17375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17376 #else
17377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17378 #endif
17379 }
17380 {
17381 if (temp2)
17382 delete arg2;
17383 }
17384 {
17385 if (temp3)
17386 delete arg3;
17387 }
17388 return resultobj;
17389 fail:
17390 {
17391 if (temp2)
17392 delete arg2;
17393 }
17394 {
17395 if (temp3)
17396 delete arg3;
17397 }
17398 return NULL;
17399 }
17400
17401
17402 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17403 PyObject *resultobj;
17404 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17405 wxString *arg2 = 0 ;
17406 long arg3 = (long) 0 ;
17407 long result;
17408 bool temp2 = false ;
17409 PyObject * obj0 = 0 ;
17410 PyObject * obj1 = 0 ;
17411 PyObject * obj2 = 0 ;
17412 char *kwnames[] = {
17413 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17414 };
17415
17416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17418 if (SWIG_arg_fail(1)) SWIG_fail;
17419 {
17420 arg2 = wxString_in_helper(obj1);
17421 if (arg2 == NULL) SWIG_fail;
17422 temp2 = true;
17423 }
17424 if (obj2) {
17425 {
17426 arg3 = (long)(SWIG_As_long(obj2));
17427 if (SWIG_arg_fail(3)) SWIG_fail;
17428 }
17429 }
17430 {
17431 PyThreadState* __tstate = wxPyBeginAllowThreads();
17432 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17433
17434 wxPyEndAllowThreads(__tstate);
17435 if (PyErr_Occurred()) SWIG_fail;
17436 }
17437 {
17438 resultobj = SWIG_From_long((long)(result));
17439 }
17440 {
17441 if (temp2)
17442 delete arg2;
17443 }
17444 return resultobj;
17445 fail:
17446 {
17447 if (temp2)
17448 delete arg2;
17449 }
17450 return NULL;
17451 }
17452
17453
17454 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17455 PyObject *resultobj;
17456 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17457 wxString *arg2 = 0 ;
17458 double arg3 = (double) 0.0 ;
17459 double result;
17460 bool temp2 = false ;
17461 PyObject * obj0 = 0 ;
17462 PyObject * obj1 = 0 ;
17463 PyObject * obj2 = 0 ;
17464 char *kwnames[] = {
17465 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17466 };
17467
17468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17470 if (SWIG_arg_fail(1)) SWIG_fail;
17471 {
17472 arg2 = wxString_in_helper(obj1);
17473 if (arg2 == NULL) SWIG_fail;
17474 temp2 = true;
17475 }
17476 if (obj2) {
17477 {
17478 arg3 = (double)(SWIG_As_double(obj2));
17479 if (SWIG_arg_fail(3)) SWIG_fail;
17480 }
17481 }
17482 {
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17485
17486 wxPyEndAllowThreads(__tstate);
17487 if (PyErr_Occurred()) SWIG_fail;
17488 }
17489 {
17490 resultobj = SWIG_From_double((double)(result));
17491 }
17492 {
17493 if (temp2)
17494 delete arg2;
17495 }
17496 return resultobj;
17497 fail:
17498 {
17499 if (temp2)
17500 delete arg2;
17501 }
17502 return NULL;
17503 }
17504
17505
17506 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17507 PyObject *resultobj;
17508 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17509 wxString *arg2 = 0 ;
17510 bool arg3 = (bool) false ;
17511 bool result;
17512 bool temp2 = false ;
17513 PyObject * obj0 = 0 ;
17514 PyObject * obj1 = 0 ;
17515 PyObject * obj2 = 0 ;
17516 char *kwnames[] = {
17517 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17518 };
17519
17520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17522 if (SWIG_arg_fail(1)) SWIG_fail;
17523 {
17524 arg2 = wxString_in_helper(obj1);
17525 if (arg2 == NULL) SWIG_fail;
17526 temp2 = true;
17527 }
17528 if (obj2) {
17529 {
17530 arg3 = (bool)(SWIG_As_bool(obj2));
17531 if (SWIG_arg_fail(3)) SWIG_fail;
17532 }
17533 }
17534 {
17535 PyThreadState* __tstate = wxPyBeginAllowThreads();
17536 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17537
17538 wxPyEndAllowThreads(__tstate);
17539 if (PyErr_Occurred()) SWIG_fail;
17540 }
17541 {
17542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17543 }
17544 {
17545 if (temp2)
17546 delete arg2;
17547 }
17548 return resultobj;
17549 fail:
17550 {
17551 if (temp2)
17552 delete arg2;
17553 }
17554 return NULL;
17555 }
17556
17557
17558 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17559 PyObject *resultobj;
17560 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17561 wxString *arg2 = 0 ;
17562 wxString *arg3 = 0 ;
17563 bool result;
17564 bool temp2 = false ;
17565 bool temp3 = false ;
17566 PyObject * obj0 = 0 ;
17567 PyObject * obj1 = 0 ;
17568 PyObject * obj2 = 0 ;
17569 char *kwnames[] = {
17570 (char *) "self",(char *) "key",(char *) "value", NULL
17571 };
17572
17573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(1)) SWIG_fail;
17576 {
17577 arg2 = wxString_in_helper(obj1);
17578 if (arg2 == NULL) SWIG_fail;
17579 temp2 = true;
17580 }
17581 {
17582 arg3 = wxString_in_helper(obj2);
17583 if (arg3 == NULL) SWIG_fail;
17584 temp3 = true;
17585 }
17586 {
17587 PyThreadState* __tstate = wxPyBeginAllowThreads();
17588 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17589
17590 wxPyEndAllowThreads(__tstate);
17591 if (PyErr_Occurred()) SWIG_fail;
17592 }
17593 {
17594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17595 }
17596 {
17597 if (temp2)
17598 delete arg2;
17599 }
17600 {
17601 if (temp3)
17602 delete arg3;
17603 }
17604 return resultobj;
17605 fail:
17606 {
17607 if (temp2)
17608 delete arg2;
17609 }
17610 {
17611 if (temp3)
17612 delete arg3;
17613 }
17614 return NULL;
17615 }
17616
17617
17618 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17619 PyObject *resultobj;
17620 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17621 wxString *arg2 = 0 ;
17622 long arg3 ;
17623 bool result;
17624 bool temp2 = false ;
17625 PyObject * obj0 = 0 ;
17626 PyObject * obj1 = 0 ;
17627 PyObject * obj2 = 0 ;
17628 char *kwnames[] = {
17629 (char *) "self",(char *) "key",(char *) "value", NULL
17630 };
17631
17632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17634 if (SWIG_arg_fail(1)) SWIG_fail;
17635 {
17636 arg2 = wxString_in_helper(obj1);
17637 if (arg2 == NULL) SWIG_fail;
17638 temp2 = true;
17639 }
17640 {
17641 arg3 = (long)(SWIG_As_long(obj2));
17642 if (SWIG_arg_fail(3)) SWIG_fail;
17643 }
17644 {
17645 PyThreadState* __tstate = wxPyBeginAllowThreads();
17646 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17647
17648 wxPyEndAllowThreads(__tstate);
17649 if (PyErr_Occurred()) SWIG_fail;
17650 }
17651 {
17652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17653 }
17654 {
17655 if (temp2)
17656 delete arg2;
17657 }
17658 return resultobj;
17659 fail:
17660 {
17661 if (temp2)
17662 delete arg2;
17663 }
17664 return NULL;
17665 }
17666
17667
17668 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17669 PyObject *resultobj;
17670 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17671 wxString *arg2 = 0 ;
17672 double arg3 ;
17673 bool result;
17674 bool temp2 = false ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 PyObject * obj2 = 0 ;
17678 char *kwnames[] = {
17679 (char *) "self",(char *) "key",(char *) "value", NULL
17680 };
17681
17682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17684 if (SWIG_arg_fail(1)) SWIG_fail;
17685 {
17686 arg2 = wxString_in_helper(obj1);
17687 if (arg2 == NULL) SWIG_fail;
17688 temp2 = true;
17689 }
17690 {
17691 arg3 = (double)(SWIG_As_double(obj2));
17692 if (SWIG_arg_fail(3)) SWIG_fail;
17693 }
17694 {
17695 PyThreadState* __tstate = wxPyBeginAllowThreads();
17696 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17697
17698 wxPyEndAllowThreads(__tstate);
17699 if (PyErr_Occurred()) SWIG_fail;
17700 }
17701 {
17702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17703 }
17704 {
17705 if (temp2)
17706 delete arg2;
17707 }
17708 return resultobj;
17709 fail:
17710 {
17711 if (temp2)
17712 delete arg2;
17713 }
17714 return NULL;
17715 }
17716
17717
17718 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17719 PyObject *resultobj;
17720 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17721 wxString *arg2 = 0 ;
17722 bool arg3 ;
17723 bool result;
17724 bool temp2 = false ;
17725 PyObject * obj0 = 0 ;
17726 PyObject * obj1 = 0 ;
17727 PyObject * obj2 = 0 ;
17728 char *kwnames[] = {
17729 (char *) "self",(char *) "key",(char *) "value", NULL
17730 };
17731
17732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17734 if (SWIG_arg_fail(1)) SWIG_fail;
17735 {
17736 arg2 = wxString_in_helper(obj1);
17737 if (arg2 == NULL) SWIG_fail;
17738 temp2 = true;
17739 }
17740 {
17741 arg3 = (bool)(SWIG_As_bool(obj2));
17742 if (SWIG_arg_fail(3)) SWIG_fail;
17743 }
17744 {
17745 PyThreadState* __tstate = wxPyBeginAllowThreads();
17746 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17747
17748 wxPyEndAllowThreads(__tstate);
17749 if (PyErr_Occurred()) SWIG_fail;
17750 }
17751 {
17752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17753 }
17754 {
17755 if (temp2)
17756 delete arg2;
17757 }
17758 return resultobj;
17759 fail:
17760 {
17761 if (temp2)
17762 delete arg2;
17763 }
17764 return NULL;
17765 }
17766
17767
17768 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17769 PyObject *resultobj;
17770 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17771 bool arg2 = (bool) false ;
17772 bool result;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 char *kwnames[] = {
17776 (char *) "self",(char *) "currentOnly", NULL
17777 };
17778
17779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 if (obj1) {
17783 {
17784 arg2 = (bool)(SWIG_As_bool(obj1));
17785 if (SWIG_arg_fail(2)) SWIG_fail;
17786 }
17787 }
17788 {
17789 PyThreadState* __tstate = wxPyBeginAllowThreads();
17790 result = (bool)(arg1)->Flush(arg2);
17791
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 {
17796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17797 }
17798 return resultobj;
17799 fail:
17800 return NULL;
17801 }
17802
17803
17804 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17805 PyObject *resultobj;
17806 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17807 wxString *arg2 = 0 ;
17808 wxString *arg3 = 0 ;
17809 bool result;
17810 bool temp2 = false ;
17811 bool temp3 = false ;
17812 PyObject * obj0 = 0 ;
17813 PyObject * obj1 = 0 ;
17814 PyObject * obj2 = 0 ;
17815 char *kwnames[] = {
17816 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17817 };
17818
17819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17821 if (SWIG_arg_fail(1)) SWIG_fail;
17822 {
17823 arg2 = wxString_in_helper(obj1);
17824 if (arg2 == NULL) SWIG_fail;
17825 temp2 = true;
17826 }
17827 {
17828 arg3 = wxString_in_helper(obj2);
17829 if (arg3 == NULL) SWIG_fail;
17830 temp3 = true;
17831 }
17832 {
17833 PyThreadState* __tstate = wxPyBeginAllowThreads();
17834 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17835
17836 wxPyEndAllowThreads(__tstate);
17837 if (PyErr_Occurred()) SWIG_fail;
17838 }
17839 {
17840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17841 }
17842 {
17843 if (temp2)
17844 delete arg2;
17845 }
17846 {
17847 if (temp3)
17848 delete arg3;
17849 }
17850 return resultobj;
17851 fail:
17852 {
17853 if (temp2)
17854 delete arg2;
17855 }
17856 {
17857 if (temp3)
17858 delete arg3;
17859 }
17860 return NULL;
17861 }
17862
17863
17864 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17865 PyObject *resultobj;
17866 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17867 wxString *arg2 = 0 ;
17868 wxString *arg3 = 0 ;
17869 bool result;
17870 bool temp2 = false ;
17871 bool temp3 = false ;
17872 PyObject * obj0 = 0 ;
17873 PyObject * obj1 = 0 ;
17874 PyObject * obj2 = 0 ;
17875 char *kwnames[] = {
17876 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17877 };
17878
17879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17881 if (SWIG_arg_fail(1)) SWIG_fail;
17882 {
17883 arg2 = wxString_in_helper(obj1);
17884 if (arg2 == NULL) SWIG_fail;
17885 temp2 = true;
17886 }
17887 {
17888 arg3 = wxString_in_helper(obj2);
17889 if (arg3 == NULL) SWIG_fail;
17890 temp3 = true;
17891 }
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17895
17896 wxPyEndAllowThreads(__tstate);
17897 if (PyErr_Occurred()) SWIG_fail;
17898 }
17899 {
17900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17901 }
17902 {
17903 if (temp2)
17904 delete arg2;
17905 }
17906 {
17907 if (temp3)
17908 delete arg3;
17909 }
17910 return resultobj;
17911 fail:
17912 {
17913 if (temp2)
17914 delete arg2;
17915 }
17916 {
17917 if (temp3)
17918 delete arg3;
17919 }
17920 return NULL;
17921 }
17922
17923
17924 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17925 PyObject *resultobj;
17926 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17927 wxString *arg2 = 0 ;
17928 bool arg3 = (bool) true ;
17929 bool result;
17930 bool temp2 = false ;
17931 PyObject * obj0 = 0 ;
17932 PyObject * obj1 = 0 ;
17933 PyObject * obj2 = 0 ;
17934 char *kwnames[] = {
17935 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17936 };
17937
17938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17940 if (SWIG_arg_fail(1)) SWIG_fail;
17941 {
17942 arg2 = wxString_in_helper(obj1);
17943 if (arg2 == NULL) SWIG_fail;
17944 temp2 = true;
17945 }
17946 if (obj2) {
17947 {
17948 arg3 = (bool)(SWIG_As_bool(obj2));
17949 if (SWIG_arg_fail(3)) SWIG_fail;
17950 }
17951 }
17952 {
17953 PyThreadState* __tstate = wxPyBeginAllowThreads();
17954 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17955
17956 wxPyEndAllowThreads(__tstate);
17957 if (PyErr_Occurred()) SWIG_fail;
17958 }
17959 {
17960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17961 }
17962 {
17963 if (temp2)
17964 delete arg2;
17965 }
17966 return resultobj;
17967 fail:
17968 {
17969 if (temp2)
17970 delete arg2;
17971 }
17972 return NULL;
17973 }
17974
17975
17976 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17977 PyObject *resultobj;
17978 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17979 wxString *arg2 = 0 ;
17980 bool result;
17981 bool temp2 = false ;
17982 PyObject * obj0 = 0 ;
17983 PyObject * obj1 = 0 ;
17984 char *kwnames[] = {
17985 (char *) "self",(char *) "key", NULL
17986 };
17987
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17990 if (SWIG_arg_fail(1)) SWIG_fail;
17991 {
17992 arg2 = wxString_in_helper(obj1);
17993 if (arg2 == NULL) SWIG_fail;
17994 temp2 = true;
17995 }
17996 {
17997 PyThreadState* __tstate = wxPyBeginAllowThreads();
17998 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17999
18000 wxPyEndAllowThreads(__tstate);
18001 if (PyErr_Occurred()) SWIG_fail;
18002 }
18003 {
18004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18005 }
18006 {
18007 if (temp2)
18008 delete arg2;
18009 }
18010 return resultobj;
18011 fail:
18012 {
18013 if (temp2)
18014 delete arg2;
18015 }
18016 return NULL;
18017 }
18018
18019
18020 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18021 PyObject *resultobj;
18022 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18023 bool result;
18024 PyObject * obj0 = 0 ;
18025 char *kwnames[] = {
18026 (char *) "self", NULL
18027 };
18028
18029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18031 if (SWIG_arg_fail(1)) SWIG_fail;
18032 {
18033 PyThreadState* __tstate = wxPyBeginAllowThreads();
18034 result = (bool)(arg1)->DeleteAll();
18035
18036 wxPyEndAllowThreads(__tstate);
18037 if (PyErr_Occurred()) SWIG_fail;
18038 }
18039 {
18040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18041 }
18042 return resultobj;
18043 fail:
18044 return NULL;
18045 }
18046
18047
18048 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18049 PyObject *resultobj;
18050 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18051 bool arg2 = (bool) true ;
18052 PyObject * obj0 = 0 ;
18053 PyObject * obj1 = 0 ;
18054 char *kwnames[] = {
18055 (char *) "self",(char *) "doIt", NULL
18056 };
18057
18058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18060 if (SWIG_arg_fail(1)) SWIG_fail;
18061 if (obj1) {
18062 {
18063 arg2 = (bool)(SWIG_As_bool(obj1));
18064 if (SWIG_arg_fail(2)) SWIG_fail;
18065 }
18066 }
18067 {
18068 PyThreadState* __tstate = wxPyBeginAllowThreads();
18069 (arg1)->SetExpandEnvVars(arg2);
18070
18071 wxPyEndAllowThreads(__tstate);
18072 if (PyErr_Occurred()) SWIG_fail;
18073 }
18074 Py_INCREF(Py_None); resultobj = Py_None;
18075 return resultobj;
18076 fail:
18077 return NULL;
18078 }
18079
18080
18081 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj;
18083 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18084 bool result;
18085 PyObject * obj0 = 0 ;
18086 char *kwnames[] = {
18087 (char *) "self", NULL
18088 };
18089
18090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18092 if (SWIG_arg_fail(1)) SWIG_fail;
18093 {
18094 PyThreadState* __tstate = wxPyBeginAllowThreads();
18095 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18096
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 {
18101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18102 }
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18110 PyObject *resultobj;
18111 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18112 bool arg2 = (bool) true ;
18113 PyObject * obj0 = 0 ;
18114 PyObject * obj1 = 0 ;
18115 char *kwnames[] = {
18116 (char *) "self",(char *) "doIt", NULL
18117 };
18118
18119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18121 if (SWIG_arg_fail(1)) SWIG_fail;
18122 if (obj1) {
18123 {
18124 arg2 = (bool)(SWIG_As_bool(obj1));
18125 if (SWIG_arg_fail(2)) SWIG_fail;
18126 }
18127 }
18128 {
18129 PyThreadState* __tstate = wxPyBeginAllowThreads();
18130 (arg1)->SetRecordDefaults(arg2);
18131
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 Py_INCREF(Py_None); resultobj = Py_None;
18136 return resultobj;
18137 fail:
18138 return NULL;
18139 }
18140
18141
18142 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18143 PyObject *resultobj;
18144 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18145 bool result;
18146 PyObject * obj0 = 0 ;
18147 char *kwnames[] = {
18148 (char *) "self", NULL
18149 };
18150
18151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18153 if (SWIG_arg_fail(1)) SWIG_fail;
18154 {
18155 PyThreadState* __tstate = wxPyBeginAllowThreads();
18156 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18157
18158 wxPyEndAllowThreads(__tstate);
18159 if (PyErr_Occurred()) SWIG_fail;
18160 }
18161 {
18162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18163 }
18164 return resultobj;
18165 fail:
18166 return NULL;
18167 }
18168
18169
18170 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18171 PyObject *resultobj;
18172 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18173 wxString *arg2 = 0 ;
18174 wxString result;
18175 bool temp2 = false ;
18176 PyObject * obj0 = 0 ;
18177 PyObject * obj1 = 0 ;
18178 char *kwnames[] = {
18179 (char *) "self",(char *) "str", NULL
18180 };
18181
18182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18184 if (SWIG_arg_fail(1)) SWIG_fail;
18185 {
18186 arg2 = wxString_in_helper(obj1);
18187 if (arg2 == NULL) SWIG_fail;
18188 temp2 = true;
18189 }
18190 {
18191 PyThreadState* __tstate = wxPyBeginAllowThreads();
18192 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18193
18194 wxPyEndAllowThreads(__tstate);
18195 if (PyErr_Occurred()) SWIG_fail;
18196 }
18197 {
18198 #if wxUSE_UNICODE
18199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18200 #else
18201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18202 #endif
18203 }
18204 {
18205 if (temp2)
18206 delete arg2;
18207 }
18208 return resultobj;
18209 fail:
18210 {
18211 if (temp2)
18212 delete arg2;
18213 }
18214 return NULL;
18215 }
18216
18217
18218 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18219 PyObject *resultobj;
18220 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18221 wxString result;
18222 PyObject * obj0 = 0 ;
18223 char *kwnames[] = {
18224 (char *) "self", NULL
18225 };
18226
18227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18229 if (SWIG_arg_fail(1)) SWIG_fail;
18230 {
18231 PyThreadState* __tstate = wxPyBeginAllowThreads();
18232 result = ((wxConfigBase const *)arg1)->GetAppName();
18233
18234 wxPyEndAllowThreads(__tstate);
18235 if (PyErr_Occurred()) SWIG_fail;
18236 }
18237 {
18238 #if wxUSE_UNICODE
18239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18240 #else
18241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18242 #endif
18243 }
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18251 PyObject *resultobj;
18252 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18253 wxString result;
18254 PyObject * obj0 = 0 ;
18255 char *kwnames[] = {
18256 (char *) "self", NULL
18257 };
18258
18259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18261 if (SWIG_arg_fail(1)) SWIG_fail;
18262 {
18263 PyThreadState* __tstate = wxPyBeginAllowThreads();
18264 result = ((wxConfigBase const *)arg1)->GetVendorName();
18265
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 {
18270 #if wxUSE_UNICODE
18271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18272 #else
18273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18274 #endif
18275 }
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18283 PyObject *resultobj;
18284 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18285 wxString *arg2 = 0 ;
18286 bool temp2 = false ;
18287 PyObject * obj0 = 0 ;
18288 PyObject * obj1 = 0 ;
18289 char *kwnames[] = {
18290 (char *) "self",(char *) "appName", NULL
18291 };
18292
18293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18295 if (SWIG_arg_fail(1)) SWIG_fail;
18296 {
18297 arg2 = wxString_in_helper(obj1);
18298 if (arg2 == NULL) SWIG_fail;
18299 temp2 = true;
18300 }
18301 {
18302 PyThreadState* __tstate = wxPyBeginAllowThreads();
18303 (arg1)->SetAppName((wxString const &)*arg2);
18304
18305 wxPyEndAllowThreads(__tstate);
18306 if (PyErr_Occurred()) SWIG_fail;
18307 }
18308 Py_INCREF(Py_None); resultobj = Py_None;
18309 {
18310 if (temp2)
18311 delete arg2;
18312 }
18313 return resultobj;
18314 fail:
18315 {
18316 if (temp2)
18317 delete arg2;
18318 }
18319 return NULL;
18320 }
18321
18322
18323 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18324 PyObject *resultobj;
18325 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18326 wxString *arg2 = 0 ;
18327 bool temp2 = false ;
18328 PyObject * obj0 = 0 ;
18329 PyObject * obj1 = 0 ;
18330 char *kwnames[] = {
18331 (char *) "self",(char *) "vendorName", NULL
18332 };
18333
18334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18336 if (SWIG_arg_fail(1)) SWIG_fail;
18337 {
18338 arg2 = wxString_in_helper(obj1);
18339 if (arg2 == NULL) SWIG_fail;
18340 temp2 = true;
18341 }
18342 {
18343 PyThreadState* __tstate = wxPyBeginAllowThreads();
18344 (arg1)->SetVendorName((wxString const &)*arg2);
18345
18346 wxPyEndAllowThreads(__tstate);
18347 if (PyErr_Occurred()) SWIG_fail;
18348 }
18349 Py_INCREF(Py_None); resultobj = Py_None;
18350 {
18351 if (temp2)
18352 delete arg2;
18353 }
18354 return resultobj;
18355 fail:
18356 {
18357 if (temp2)
18358 delete arg2;
18359 }
18360 return NULL;
18361 }
18362
18363
18364 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18365 PyObject *resultobj;
18366 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18367 long arg2 ;
18368 PyObject * obj0 = 0 ;
18369 PyObject * obj1 = 0 ;
18370 char *kwnames[] = {
18371 (char *) "self",(char *) "style", NULL
18372 };
18373
18374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18376 if (SWIG_arg_fail(1)) SWIG_fail;
18377 {
18378 arg2 = (long)(SWIG_As_long(obj1));
18379 if (SWIG_arg_fail(2)) SWIG_fail;
18380 }
18381 {
18382 PyThreadState* __tstate = wxPyBeginAllowThreads();
18383 (arg1)->SetStyle(arg2);
18384
18385 wxPyEndAllowThreads(__tstate);
18386 if (PyErr_Occurred()) SWIG_fail;
18387 }
18388 Py_INCREF(Py_None); resultobj = Py_None;
18389 return resultobj;
18390 fail:
18391 return NULL;
18392 }
18393
18394
18395 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18396 PyObject *resultobj;
18397 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18398 long result;
18399 PyObject * obj0 = 0 ;
18400 char *kwnames[] = {
18401 (char *) "self", NULL
18402 };
18403
18404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18406 if (SWIG_arg_fail(1)) SWIG_fail;
18407 {
18408 PyThreadState* __tstate = wxPyBeginAllowThreads();
18409 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18410
18411 wxPyEndAllowThreads(__tstate);
18412 if (PyErr_Occurred()) SWIG_fail;
18413 }
18414 {
18415 resultobj = SWIG_From_long((long)(result));
18416 }
18417 return resultobj;
18418 fail:
18419 return NULL;
18420 }
18421
18422
18423 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18424 PyObject *obj;
18425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18426 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18427 Py_INCREF(obj);
18428 return Py_BuildValue((char *)"");
18429 }
18430 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18431 PyObject *resultobj;
18432 wxString const &arg1_defvalue = wxPyEmptyString ;
18433 wxString *arg1 = (wxString *) &arg1_defvalue ;
18434 wxString const &arg2_defvalue = wxPyEmptyString ;
18435 wxString *arg2 = (wxString *) &arg2_defvalue ;
18436 wxString const &arg3_defvalue = wxPyEmptyString ;
18437 wxString *arg3 = (wxString *) &arg3_defvalue ;
18438 wxString const &arg4_defvalue = wxPyEmptyString ;
18439 wxString *arg4 = (wxString *) &arg4_defvalue ;
18440 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18441 wxConfig *result;
18442 bool temp1 = false ;
18443 bool temp2 = false ;
18444 bool temp3 = false ;
18445 bool temp4 = false ;
18446 PyObject * obj0 = 0 ;
18447 PyObject * obj1 = 0 ;
18448 PyObject * obj2 = 0 ;
18449 PyObject * obj3 = 0 ;
18450 PyObject * obj4 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18456 if (obj0) {
18457 {
18458 arg1 = wxString_in_helper(obj0);
18459 if (arg1 == NULL) SWIG_fail;
18460 temp1 = true;
18461 }
18462 }
18463 if (obj1) {
18464 {
18465 arg2 = wxString_in_helper(obj1);
18466 if (arg2 == NULL) SWIG_fail;
18467 temp2 = true;
18468 }
18469 }
18470 if (obj2) {
18471 {
18472 arg3 = wxString_in_helper(obj2);
18473 if (arg3 == NULL) SWIG_fail;
18474 temp3 = true;
18475 }
18476 }
18477 if (obj3) {
18478 {
18479 arg4 = wxString_in_helper(obj3);
18480 if (arg4 == NULL) SWIG_fail;
18481 temp4 = true;
18482 }
18483 }
18484 if (obj4) {
18485 {
18486 arg5 = (long)(SWIG_As_long(obj4));
18487 if (SWIG_arg_fail(5)) SWIG_fail;
18488 }
18489 }
18490 {
18491 PyThreadState* __tstate = wxPyBeginAllowThreads();
18492 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18493
18494 wxPyEndAllowThreads(__tstate);
18495 if (PyErr_Occurred()) SWIG_fail;
18496 }
18497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18498 {
18499 if (temp1)
18500 delete arg1;
18501 }
18502 {
18503 if (temp2)
18504 delete arg2;
18505 }
18506 {
18507 if (temp3)
18508 delete arg3;
18509 }
18510 {
18511 if (temp4)
18512 delete arg4;
18513 }
18514 return resultobj;
18515 fail:
18516 {
18517 if (temp1)
18518 delete arg1;
18519 }
18520 {
18521 if (temp2)
18522 delete arg2;
18523 }
18524 {
18525 if (temp3)
18526 delete arg3;
18527 }
18528 {
18529 if (temp4)
18530 delete arg4;
18531 }
18532 return NULL;
18533 }
18534
18535
18536 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18537 PyObject *resultobj;
18538 wxConfig *arg1 = (wxConfig *) 0 ;
18539 PyObject * obj0 = 0 ;
18540 char *kwnames[] = {
18541 (char *) "self", NULL
18542 };
18543
18544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18546 if (SWIG_arg_fail(1)) SWIG_fail;
18547 {
18548 PyThreadState* __tstate = wxPyBeginAllowThreads();
18549 delete arg1;
18550
18551 wxPyEndAllowThreads(__tstate);
18552 if (PyErr_Occurred()) SWIG_fail;
18553 }
18554 Py_INCREF(Py_None); resultobj = Py_None;
18555 return resultobj;
18556 fail:
18557 return NULL;
18558 }
18559
18560
18561 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18562 PyObject *obj;
18563 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18564 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18565 Py_INCREF(obj);
18566 return Py_BuildValue((char *)"");
18567 }
18568 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18569 PyObject *resultobj;
18570 wxString const &arg1_defvalue = wxPyEmptyString ;
18571 wxString *arg1 = (wxString *) &arg1_defvalue ;
18572 wxString const &arg2_defvalue = wxPyEmptyString ;
18573 wxString *arg2 = (wxString *) &arg2_defvalue ;
18574 wxString const &arg3_defvalue = wxPyEmptyString ;
18575 wxString *arg3 = (wxString *) &arg3_defvalue ;
18576 wxString const &arg4_defvalue = wxPyEmptyString ;
18577 wxString *arg4 = (wxString *) &arg4_defvalue ;
18578 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18579 wxFileConfig *result;
18580 bool temp1 = false ;
18581 bool temp2 = false ;
18582 bool temp3 = false ;
18583 bool temp4 = false ;
18584 PyObject * obj0 = 0 ;
18585 PyObject * obj1 = 0 ;
18586 PyObject * obj2 = 0 ;
18587 PyObject * obj3 = 0 ;
18588 PyObject * obj4 = 0 ;
18589 char *kwnames[] = {
18590 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18591 };
18592
18593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18594 if (obj0) {
18595 {
18596 arg1 = wxString_in_helper(obj0);
18597 if (arg1 == NULL) SWIG_fail;
18598 temp1 = true;
18599 }
18600 }
18601 if (obj1) {
18602 {
18603 arg2 = wxString_in_helper(obj1);
18604 if (arg2 == NULL) SWIG_fail;
18605 temp2 = true;
18606 }
18607 }
18608 if (obj2) {
18609 {
18610 arg3 = wxString_in_helper(obj2);
18611 if (arg3 == NULL) SWIG_fail;
18612 temp3 = true;
18613 }
18614 }
18615 if (obj3) {
18616 {
18617 arg4 = wxString_in_helper(obj3);
18618 if (arg4 == NULL) SWIG_fail;
18619 temp4 = true;
18620 }
18621 }
18622 if (obj4) {
18623 {
18624 arg5 = (long)(SWIG_As_long(obj4));
18625 if (SWIG_arg_fail(5)) SWIG_fail;
18626 }
18627 }
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18631
18632 wxPyEndAllowThreads(__tstate);
18633 if (PyErr_Occurred()) SWIG_fail;
18634 }
18635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18636 {
18637 if (temp1)
18638 delete arg1;
18639 }
18640 {
18641 if (temp2)
18642 delete arg2;
18643 }
18644 {
18645 if (temp3)
18646 delete arg3;
18647 }
18648 {
18649 if (temp4)
18650 delete arg4;
18651 }
18652 return resultobj;
18653 fail:
18654 {
18655 if (temp1)
18656 delete arg1;
18657 }
18658 {
18659 if (temp2)
18660 delete arg2;
18661 }
18662 {
18663 if (temp3)
18664 delete arg3;
18665 }
18666 {
18667 if (temp4)
18668 delete arg4;
18669 }
18670 return NULL;
18671 }
18672
18673
18674 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj;
18676 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18677 PyObject * obj0 = 0 ;
18678 char *kwnames[] = {
18679 (char *) "self", NULL
18680 };
18681
18682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18684 if (SWIG_arg_fail(1)) SWIG_fail;
18685 {
18686 PyThreadState* __tstate = wxPyBeginAllowThreads();
18687 delete arg1;
18688
18689 wxPyEndAllowThreads(__tstate);
18690 if (PyErr_Occurred()) SWIG_fail;
18691 }
18692 Py_INCREF(Py_None); resultobj = Py_None;
18693 return resultobj;
18694 fail:
18695 return NULL;
18696 }
18697
18698
18699 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18700 PyObject *obj;
18701 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18702 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18703 Py_INCREF(obj);
18704 return Py_BuildValue((char *)"");
18705 }
18706 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18707 PyObject *resultobj;
18708 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18709 wxString *arg2 = 0 ;
18710 wxConfigPathChanger *result;
18711 bool temp2 = false ;
18712 PyObject * obj0 = 0 ;
18713 PyObject * obj1 = 0 ;
18714 char *kwnames[] = {
18715 (char *) "config",(char *) "entry", NULL
18716 };
18717
18718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18720 if (SWIG_arg_fail(1)) SWIG_fail;
18721 {
18722 arg2 = wxString_in_helper(obj1);
18723 if (arg2 == NULL) SWIG_fail;
18724 temp2 = true;
18725 }
18726 {
18727 PyThreadState* __tstate = wxPyBeginAllowThreads();
18728 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18729
18730 wxPyEndAllowThreads(__tstate);
18731 if (PyErr_Occurred()) SWIG_fail;
18732 }
18733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18734 {
18735 if (temp2)
18736 delete arg2;
18737 }
18738 return resultobj;
18739 fail:
18740 {
18741 if (temp2)
18742 delete arg2;
18743 }
18744 return NULL;
18745 }
18746
18747
18748 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj;
18750 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18751 PyObject * obj0 = 0 ;
18752 char *kwnames[] = {
18753 (char *) "self", NULL
18754 };
18755
18756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18758 if (SWIG_arg_fail(1)) SWIG_fail;
18759 {
18760 PyThreadState* __tstate = wxPyBeginAllowThreads();
18761 delete arg1;
18762
18763 wxPyEndAllowThreads(__tstate);
18764 if (PyErr_Occurred()) SWIG_fail;
18765 }
18766 Py_INCREF(Py_None); resultobj = Py_None;
18767 return resultobj;
18768 fail:
18769 return NULL;
18770 }
18771
18772
18773 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18774 PyObject *resultobj;
18775 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18776 wxString *result;
18777 PyObject * obj0 = 0 ;
18778 char *kwnames[] = {
18779 (char *) "self", NULL
18780 };
18781
18782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18784 if (SWIG_arg_fail(1)) SWIG_fail;
18785 {
18786 PyThreadState* __tstate = wxPyBeginAllowThreads();
18787 {
18788 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18789 result = (wxString *) &_result_ref;
18790 }
18791
18792 wxPyEndAllowThreads(__tstate);
18793 if (PyErr_Occurred()) SWIG_fail;
18794 }
18795 {
18796 #if wxUSE_UNICODE
18797 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18798 #else
18799 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18800 #endif
18801 }
18802 return resultobj;
18803 fail:
18804 return NULL;
18805 }
18806
18807
18808 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18809 PyObject *obj;
18810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18811 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18812 Py_INCREF(obj);
18813 return Py_BuildValue((char *)"");
18814 }
18815 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18816 PyObject *resultobj;
18817 wxString *arg1 = 0 ;
18818 wxString result;
18819 bool temp1 = false ;
18820 PyObject * obj0 = 0 ;
18821 char *kwnames[] = {
18822 (char *) "sz", NULL
18823 };
18824
18825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18826 {
18827 arg1 = wxString_in_helper(obj0);
18828 if (arg1 == NULL) SWIG_fail;
18829 temp1 = true;
18830 }
18831 {
18832 PyThreadState* __tstate = wxPyBeginAllowThreads();
18833 result = wxExpandEnvVars((wxString const &)*arg1);
18834
18835 wxPyEndAllowThreads(__tstate);
18836 if (PyErr_Occurred()) SWIG_fail;
18837 }
18838 {
18839 #if wxUSE_UNICODE
18840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18841 #else
18842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18843 #endif
18844 }
18845 {
18846 if (temp1)
18847 delete arg1;
18848 }
18849 return resultobj;
18850 fail:
18851 {
18852 if (temp1)
18853 delete arg1;
18854 }
18855 return NULL;
18856 }
18857
18858
18859 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18860 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18861 return 1;
18862 }
18863
18864
18865 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18866 PyObject *pyobj;
18867
18868 {
18869 #if wxUSE_UNICODE
18870 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18871 #else
18872 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18873 #endif
18874 }
18875 return pyobj;
18876 }
18877
18878
18879 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18880 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18881 return 1;
18882 }
18883
18884
18885 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18886 PyObject *pyobj;
18887
18888 {
18889 #if wxUSE_UNICODE
18890 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18891 #else
18892 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18893 #endif
18894 }
18895 return pyobj;
18896 }
18897
18898
18899 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18900 PyObject *resultobj;
18901 wxDateTime::Country arg1 ;
18902 PyObject * obj0 = 0 ;
18903 char *kwnames[] = {
18904 (char *) "country", NULL
18905 };
18906
18907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18908 {
18909 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18910 if (SWIG_arg_fail(1)) SWIG_fail;
18911 }
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18915
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 Py_INCREF(Py_None); resultobj = Py_None;
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj;
18928 wxDateTime::Country result;
18929 char *kwnames[] = {
18930 NULL
18931 };
18932
18933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18934 {
18935 PyThreadState* __tstate = wxPyBeginAllowThreads();
18936 result = (wxDateTime::Country)wxDateTime::GetCountry();
18937
18938 wxPyEndAllowThreads(__tstate);
18939 if (PyErr_Occurred()) SWIG_fail;
18940 }
18941 resultobj = SWIG_From_int((result));
18942 return resultobj;
18943 fail:
18944 return NULL;
18945 }
18946
18947
18948 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18949 PyObject *resultobj;
18950 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18951 bool result;
18952 PyObject * obj0 = 0 ;
18953 char *kwnames[] = {
18954 (char *) "country", NULL
18955 };
18956
18957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18958 if (obj0) {
18959 {
18960 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18961 if (SWIG_arg_fail(1)) SWIG_fail;
18962 }
18963 }
18964 {
18965 PyThreadState* __tstate = wxPyBeginAllowThreads();
18966 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18967
18968 wxPyEndAllowThreads(__tstate);
18969 if (PyErr_Occurred()) SWIG_fail;
18970 }
18971 {
18972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18973 }
18974 return resultobj;
18975 fail:
18976 return NULL;
18977 }
18978
18979
18980 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18981 PyObject *resultobj;
18982 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18983 int result;
18984 PyObject * obj0 = 0 ;
18985 char *kwnames[] = {
18986 (char *) "cal", NULL
18987 };
18988
18989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18990 if (obj0) {
18991 {
18992 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18993 if (SWIG_arg_fail(1)) SWIG_fail;
18994 }
18995 }
18996 {
18997 PyThreadState* __tstate = wxPyBeginAllowThreads();
18998 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18999
19000 wxPyEndAllowThreads(__tstate);
19001 if (PyErr_Occurred()) SWIG_fail;
19002 }
19003 {
19004 resultobj = SWIG_From_int((int)(result));
19005 }
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj;
19014 int arg1 ;
19015 int result;
19016 PyObject * obj0 = 0 ;
19017 char *kwnames[] = {
19018 (char *) "year", NULL
19019 };
19020
19021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19022 {
19023 arg1 = (int)(SWIG_As_int(obj0));
19024 if (SWIG_arg_fail(1)) SWIG_fail;
19025 }
19026 {
19027 PyThreadState* __tstate = wxPyBeginAllowThreads();
19028 result = (int)wxDateTime::ConvertYearToBC(arg1);
19029
19030 wxPyEndAllowThreads(__tstate);
19031 if (PyErr_Occurred()) SWIG_fail;
19032 }
19033 {
19034 resultobj = SWIG_From_int((int)(result));
19035 }
19036 return resultobj;
19037 fail:
19038 return NULL;
19039 }
19040
19041
19042 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19043 PyObject *resultobj;
19044 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19045 wxDateTime::Month result;
19046 PyObject * obj0 = 0 ;
19047 char *kwnames[] = {
19048 (char *) "cal", NULL
19049 };
19050
19051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19052 if (obj0) {
19053 {
19054 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19055 if (SWIG_arg_fail(1)) SWIG_fail;
19056 }
19057 }
19058 {
19059 PyThreadState* __tstate = wxPyBeginAllowThreads();
19060 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19061
19062 wxPyEndAllowThreads(__tstate);
19063 if (PyErr_Occurred()) SWIG_fail;
19064 }
19065 resultobj = SWIG_From_int((result));
19066 return resultobj;
19067 fail:
19068 return NULL;
19069 }
19070
19071
19072 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19073 PyObject *resultobj;
19074 int arg1 = (int) wxDateTime::Inv_Year ;
19075 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19076 bool result;
19077 PyObject * obj0 = 0 ;
19078 PyObject * obj1 = 0 ;
19079 char *kwnames[] = {
19080 (char *) "year",(char *) "cal", NULL
19081 };
19082
19083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19084 if (obj0) {
19085 {
19086 arg1 = (int)(SWIG_As_int(obj0));
19087 if (SWIG_arg_fail(1)) SWIG_fail;
19088 }
19089 }
19090 if (obj1) {
19091 {
19092 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19093 if (SWIG_arg_fail(2)) SWIG_fail;
19094 }
19095 }
19096 {
19097 PyThreadState* __tstate = wxPyBeginAllowThreads();
19098 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19099
19100 wxPyEndAllowThreads(__tstate);
19101 if (PyErr_Occurred()) SWIG_fail;
19102 }
19103 {
19104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19105 }
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19113 PyObject *resultobj;
19114 int arg1 = (int) wxDateTime::Inv_Year ;
19115 int result;
19116 PyObject * obj0 = 0 ;
19117 char *kwnames[] = {
19118 (char *) "year", NULL
19119 };
19120
19121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19122 if (obj0) {
19123 {
19124 arg1 = (int)(SWIG_As_int(obj0));
19125 if (SWIG_arg_fail(1)) SWIG_fail;
19126 }
19127 }
19128 {
19129 PyThreadState* __tstate = wxPyBeginAllowThreads();
19130 result = (int)wxDateTime::GetCentury(arg1);
19131
19132 wxPyEndAllowThreads(__tstate);
19133 if (PyErr_Occurred()) SWIG_fail;
19134 }
19135 {
19136 resultobj = SWIG_From_int((int)(result));
19137 }
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19145 PyObject *resultobj;
19146 int arg1 ;
19147 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19148 int result;
19149 PyObject * obj0 = 0 ;
19150 PyObject * obj1 = 0 ;
19151 char *kwnames[] = {
19152 (char *) "year",(char *) "cal", NULL
19153 };
19154
19155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19156 {
19157 arg1 = (int)(SWIG_As_int(obj0));
19158 if (SWIG_arg_fail(1)) SWIG_fail;
19159 }
19160 if (obj1) {
19161 {
19162 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19163 if (SWIG_arg_fail(2)) SWIG_fail;
19164 }
19165 }
19166 {
19167 PyThreadState* __tstate = wxPyBeginAllowThreads();
19168 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19169
19170 wxPyEndAllowThreads(__tstate);
19171 if (PyErr_Occurred()) SWIG_fail;
19172 }
19173 {
19174 resultobj = SWIG_From_int((int)(result));
19175 }
19176 return resultobj;
19177 fail:
19178 return NULL;
19179 }
19180
19181
19182 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19183 PyObject *resultobj;
19184 wxDateTime::Month arg1 ;
19185 int arg2 = (int) wxDateTime::Inv_Year ;
19186 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19187 int result;
19188 PyObject * obj0 = 0 ;
19189 PyObject * obj1 = 0 ;
19190 PyObject * obj2 = 0 ;
19191 char *kwnames[] = {
19192 (char *) "month",(char *) "year",(char *) "cal", NULL
19193 };
19194
19195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19196 {
19197 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19198 if (SWIG_arg_fail(1)) SWIG_fail;
19199 }
19200 if (obj1) {
19201 {
19202 arg2 = (int)(SWIG_As_int(obj1));
19203 if (SWIG_arg_fail(2)) SWIG_fail;
19204 }
19205 }
19206 if (obj2) {
19207 {
19208 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19209 if (SWIG_arg_fail(3)) SWIG_fail;
19210 }
19211 }
19212 {
19213 PyThreadState* __tstate = wxPyBeginAllowThreads();
19214 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19215
19216 wxPyEndAllowThreads(__tstate);
19217 if (PyErr_Occurred()) SWIG_fail;
19218 }
19219 {
19220 resultobj = SWIG_From_int((int)(result));
19221 }
19222 return resultobj;
19223 fail:
19224 return NULL;
19225 }
19226
19227
19228 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19229 PyObject *resultobj;
19230 wxDateTime::Month arg1 ;
19231 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19232 wxString result;
19233 PyObject * obj0 = 0 ;
19234 PyObject * obj1 = 0 ;
19235 char *kwnames[] = {
19236 (char *) "month",(char *) "flags", NULL
19237 };
19238
19239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19240 {
19241 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19242 if (SWIG_arg_fail(1)) SWIG_fail;
19243 }
19244 if (obj1) {
19245 {
19246 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19247 if (SWIG_arg_fail(2)) SWIG_fail;
19248 }
19249 }
19250 {
19251 PyThreadState* __tstate = wxPyBeginAllowThreads();
19252 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19253
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 {
19258 #if wxUSE_UNICODE
19259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19260 #else
19261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19262 #endif
19263 }
19264 return resultobj;
19265 fail:
19266 return NULL;
19267 }
19268
19269
19270 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19271 PyObject *resultobj;
19272 wxDateTime::WeekDay arg1 ;
19273 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19274 wxString result;
19275 PyObject * obj0 = 0 ;
19276 PyObject * obj1 = 0 ;
19277 char *kwnames[] = {
19278 (char *) "weekday",(char *) "flags", NULL
19279 };
19280
19281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19282 {
19283 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19284 if (SWIG_arg_fail(1)) SWIG_fail;
19285 }
19286 if (obj1) {
19287 {
19288 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19289 if (SWIG_arg_fail(2)) SWIG_fail;
19290 }
19291 }
19292 {
19293 PyThreadState* __tstate = wxPyBeginAllowThreads();
19294 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19295
19296 wxPyEndAllowThreads(__tstate);
19297 if (PyErr_Occurred()) SWIG_fail;
19298 }
19299 {
19300 #if wxUSE_UNICODE
19301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19302 #else
19303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19304 #endif
19305 }
19306 return resultobj;
19307 fail:
19308 return NULL;
19309 }
19310
19311
19312 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19313 PyObject *resultobj;
19314 PyObject *result;
19315 char *kwnames[] = {
19316 NULL
19317 };
19318
19319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19320 {
19321 PyThreadState* __tstate = wxPyBeginAllowThreads();
19322 result = (PyObject *)DateTime_GetAmPmStrings();
19323
19324 wxPyEndAllowThreads(__tstate);
19325 if (PyErr_Occurred()) SWIG_fail;
19326 }
19327 resultobj = result;
19328 return resultobj;
19329 fail:
19330 return NULL;
19331 }
19332
19333
19334 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19335 PyObject *resultobj;
19336 int arg1 = (int) wxDateTime::Inv_Year ;
19337 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19338 bool result;
19339 PyObject * obj0 = 0 ;
19340 PyObject * obj1 = 0 ;
19341 char *kwnames[] = {
19342 (char *) "year",(char *) "country", NULL
19343 };
19344
19345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19346 if (obj0) {
19347 {
19348 arg1 = (int)(SWIG_As_int(obj0));
19349 if (SWIG_arg_fail(1)) SWIG_fail;
19350 }
19351 }
19352 if (obj1) {
19353 {
19354 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19355 if (SWIG_arg_fail(2)) SWIG_fail;
19356 }
19357 }
19358 {
19359 PyThreadState* __tstate = wxPyBeginAllowThreads();
19360 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19361
19362 wxPyEndAllowThreads(__tstate);
19363 if (PyErr_Occurred()) SWIG_fail;
19364 }
19365 {
19366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19367 }
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj;
19376 int arg1 = (int) wxDateTime::Inv_Year ;
19377 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19378 wxDateTime result;
19379 PyObject * obj0 = 0 ;
19380 PyObject * obj1 = 0 ;
19381 char *kwnames[] = {
19382 (char *) "year",(char *) "country", NULL
19383 };
19384
19385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19386 if (obj0) {
19387 {
19388 arg1 = (int)(SWIG_As_int(obj0));
19389 if (SWIG_arg_fail(1)) SWIG_fail;
19390 }
19391 }
19392 if (obj1) {
19393 {
19394 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19395 if (SWIG_arg_fail(2)) SWIG_fail;
19396 }
19397 }
19398 {
19399 PyThreadState* __tstate = wxPyBeginAllowThreads();
19400 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19401
19402 wxPyEndAllowThreads(__tstate);
19403 if (PyErr_Occurred()) SWIG_fail;
19404 }
19405 {
19406 wxDateTime * resultptr;
19407 resultptr = new wxDateTime((wxDateTime &)(result));
19408 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19409 }
19410 return resultobj;
19411 fail:
19412 return NULL;
19413 }
19414
19415
19416 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19417 PyObject *resultobj;
19418 int arg1 = (int) wxDateTime::Inv_Year ;
19419 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19420 wxDateTime result;
19421 PyObject * obj0 = 0 ;
19422 PyObject * obj1 = 0 ;
19423 char *kwnames[] = {
19424 (char *) "year",(char *) "country", NULL
19425 };
19426
19427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19428 if (obj0) {
19429 {
19430 arg1 = (int)(SWIG_As_int(obj0));
19431 if (SWIG_arg_fail(1)) SWIG_fail;
19432 }
19433 }
19434 if (obj1) {
19435 {
19436 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19437 if (SWIG_arg_fail(2)) SWIG_fail;
19438 }
19439 }
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19443
19444 wxPyEndAllowThreads(__tstate);
19445 if (PyErr_Occurred()) SWIG_fail;
19446 }
19447 {
19448 wxDateTime * resultptr;
19449 resultptr = new wxDateTime((wxDateTime &)(result));
19450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19451 }
19452 return resultobj;
19453 fail:
19454 return NULL;
19455 }
19456
19457
19458 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19459 PyObject *resultobj;
19460 wxDateTime result;
19461 char *kwnames[] = {
19462 NULL
19463 };
19464
19465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19466 {
19467 PyThreadState* __tstate = wxPyBeginAllowThreads();
19468 result = wxDateTime::Now();
19469
19470 wxPyEndAllowThreads(__tstate);
19471 if (PyErr_Occurred()) SWIG_fail;
19472 }
19473 {
19474 wxDateTime * resultptr;
19475 resultptr = new wxDateTime((wxDateTime &)(result));
19476 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19477 }
19478 return resultobj;
19479 fail:
19480 return NULL;
19481 }
19482
19483
19484 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19485 PyObject *resultobj;
19486 wxDateTime result;
19487 char *kwnames[] = {
19488 NULL
19489 };
19490
19491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19492 {
19493 PyThreadState* __tstate = wxPyBeginAllowThreads();
19494 result = wxDateTime::UNow();
19495
19496 wxPyEndAllowThreads(__tstate);
19497 if (PyErr_Occurred()) SWIG_fail;
19498 }
19499 {
19500 wxDateTime * resultptr;
19501 resultptr = new wxDateTime((wxDateTime &)(result));
19502 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19503 }
19504 return resultobj;
19505 fail:
19506 return NULL;
19507 }
19508
19509
19510 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19511 PyObject *resultobj;
19512 wxDateTime result;
19513 char *kwnames[] = {
19514 NULL
19515 };
19516
19517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19518 {
19519 PyThreadState* __tstate = wxPyBeginAllowThreads();
19520 result = wxDateTime::Today();
19521
19522 wxPyEndAllowThreads(__tstate);
19523 if (PyErr_Occurred()) SWIG_fail;
19524 }
19525 {
19526 wxDateTime * resultptr;
19527 resultptr = new wxDateTime((wxDateTime &)(result));
19528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19529 }
19530 return resultobj;
19531 fail:
19532 return NULL;
19533 }
19534
19535
19536 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19537 PyObject *resultobj;
19538 wxDateTime *result;
19539 char *kwnames[] = {
19540 NULL
19541 };
19542
19543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19544 {
19545 PyThreadState* __tstate = wxPyBeginAllowThreads();
19546 result = (wxDateTime *)new wxDateTime();
19547
19548 wxPyEndAllowThreads(__tstate);
19549 if (PyErr_Occurred()) SWIG_fail;
19550 }
19551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19552 return resultobj;
19553 fail:
19554 return NULL;
19555 }
19556
19557
19558 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19559 PyObject *resultobj;
19560 time_t arg1 ;
19561 wxDateTime *result;
19562 PyObject * obj0 = 0 ;
19563 char *kwnames[] = {
19564 (char *) "timet", NULL
19565 };
19566
19567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19568 {
19569 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19570 if (SWIG_arg_fail(1)) SWIG_fail;
19571 }
19572 {
19573 PyThreadState* __tstate = wxPyBeginAllowThreads();
19574 result = (wxDateTime *)new wxDateTime(arg1);
19575
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj;
19588 double arg1 ;
19589 wxDateTime *result;
19590 PyObject * obj0 = 0 ;
19591 char *kwnames[] = {
19592 (char *) "jdn", NULL
19593 };
19594
19595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19596 {
19597 arg1 = (double)(SWIG_As_double(obj0));
19598 if (SWIG_arg_fail(1)) SWIG_fail;
19599 }
19600 {
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 result = (wxDateTime *)new wxDateTime(arg1);
19603
19604 wxPyEndAllowThreads(__tstate);
19605 if (PyErr_Occurred()) SWIG_fail;
19606 }
19607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19608 return resultobj;
19609 fail:
19610 return NULL;
19611 }
19612
19613
19614 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19615 PyObject *resultobj;
19616 int arg1 ;
19617 int arg2 = (int) 0 ;
19618 int arg3 = (int) 0 ;
19619 int arg4 = (int) 0 ;
19620 wxDateTime *result;
19621 PyObject * obj0 = 0 ;
19622 PyObject * obj1 = 0 ;
19623 PyObject * obj2 = 0 ;
19624 PyObject * obj3 = 0 ;
19625 char *kwnames[] = {
19626 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19627 };
19628
19629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19630 {
19631 arg1 = (int)(SWIG_As_int(obj0));
19632 if (SWIG_arg_fail(1)) SWIG_fail;
19633 }
19634 if (obj1) {
19635 {
19636 arg2 = (int)(SWIG_As_int(obj1));
19637 if (SWIG_arg_fail(2)) SWIG_fail;
19638 }
19639 }
19640 if (obj2) {
19641 {
19642 arg3 = (int)(SWIG_As_int(obj2));
19643 if (SWIG_arg_fail(3)) SWIG_fail;
19644 }
19645 }
19646 if (obj3) {
19647 {
19648 arg4 = (int)(SWIG_As_int(obj3));
19649 if (SWIG_arg_fail(4)) SWIG_fail;
19650 }
19651 }
19652 {
19653 PyThreadState* __tstate = wxPyBeginAllowThreads();
19654 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19655
19656 wxPyEndAllowThreads(__tstate);
19657 if (PyErr_Occurred()) SWIG_fail;
19658 }
19659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19660 return resultobj;
19661 fail:
19662 return NULL;
19663 }
19664
19665
19666 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19667 PyObject *resultobj;
19668 int arg1 ;
19669 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19670 int arg3 = (int) wxDateTime::Inv_Year ;
19671 int arg4 = (int) 0 ;
19672 int arg5 = (int) 0 ;
19673 int arg6 = (int) 0 ;
19674 int arg7 = (int) 0 ;
19675 wxDateTime *result;
19676 PyObject * obj0 = 0 ;
19677 PyObject * obj1 = 0 ;
19678 PyObject * obj2 = 0 ;
19679 PyObject * obj3 = 0 ;
19680 PyObject * obj4 = 0 ;
19681 PyObject * obj5 = 0 ;
19682 PyObject * obj6 = 0 ;
19683 char *kwnames[] = {
19684 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19685 };
19686
19687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19688 {
19689 arg1 = (int)(SWIG_As_int(obj0));
19690 if (SWIG_arg_fail(1)) SWIG_fail;
19691 }
19692 if (obj1) {
19693 {
19694 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19695 if (SWIG_arg_fail(2)) SWIG_fail;
19696 }
19697 }
19698 if (obj2) {
19699 {
19700 arg3 = (int)(SWIG_As_int(obj2));
19701 if (SWIG_arg_fail(3)) SWIG_fail;
19702 }
19703 }
19704 if (obj3) {
19705 {
19706 arg4 = (int)(SWIG_As_int(obj3));
19707 if (SWIG_arg_fail(4)) SWIG_fail;
19708 }
19709 }
19710 if (obj4) {
19711 {
19712 arg5 = (int)(SWIG_As_int(obj4));
19713 if (SWIG_arg_fail(5)) SWIG_fail;
19714 }
19715 }
19716 if (obj5) {
19717 {
19718 arg6 = (int)(SWIG_As_int(obj5));
19719 if (SWIG_arg_fail(6)) SWIG_fail;
19720 }
19721 }
19722 if (obj6) {
19723 {
19724 arg7 = (int)(SWIG_As_int(obj6));
19725 if (SWIG_arg_fail(7)) SWIG_fail;
19726 }
19727 }
19728 {
19729 PyThreadState* __tstate = wxPyBeginAllowThreads();
19730 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19731
19732 wxPyEndAllowThreads(__tstate);
19733 if (PyErr_Occurred()) SWIG_fail;
19734 }
19735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19736 return resultobj;
19737 fail:
19738 return NULL;
19739 }
19740
19741
19742 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19743 PyObject *resultobj;
19744 wxDateTime *arg1 = (wxDateTime *) 0 ;
19745 PyObject * obj0 = 0 ;
19746 char *kwnames[] = {
19747 (char *) "self", NULL
19748 };
19749
19750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19752 if (SWIG_arg_fail(1)) SWIG_fail;
19753 {
19754 PyThreadState* __tstate = wxPyBeginAllowThreads();
19755 delete arg1;
19756
19757 wxPyEndAllowThreads(__tstate);
19758 if (PyErr_Occurred()) SWIG_fail;
19759 }
19760 Py_INCREF(Py_None); resultobj = Py_None;
19761 return resultobj;
19762 fail:
19763 return NULL;
19764 }
19765
19766
19767 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19768 PyObject *resultobj;
19769 wxDateTime *arg1 = (wxDateTime *) 0 ;
19770 wxDateTime *result;
19771 PyObject * obj0 = 0 ;
19772 char *kwnames[] = {
19773 (char *) "self", NULL
19774 };
19775
19776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19778 if (SWIG_arg_fail(1)) SWIG_fail;
19779 {
19780 PyThreadState* __tstate = wxPyBeginAllowThreads();
19781 {
19782 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19783 result = (wxDateTime *) &_result_ref;
19784 }
19785
19786 wxPyEndAllowThreads(__tstate);
19787 if (PyErr_Occurred()) SWIG_fail;
19788 }
19789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19790 return resultobj;
19791 fail:
19792 return NULL;
19793 }
19794
19795
19796 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19797 PyObject *resultobj;
19798 wxDateTime *arg1 = (wxDateTime *) 0 ;
19799 time_t arg2 ;
19800 wxDateTime *result;
19801 PyObject * obj0 = 0 ;
19802 PyObject * obj1 = 0 ;
19803 char *kwnames[] = {
19804 (char *) "self",(char *) "timet", NULL
19805 };
19806
19807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19809 if (SWIG_arg_fail(1)) SWIG_fail;
19810 {
19811 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19812 if (SWIG_arg_fail(2)) SWIG_fail;
19813 }
19814 {
19815 PyThreadState* __tstate = wxPyBeginAllowThreads();
19816 {
19817 wxDateTime &_result_ref = (arg1)->Set(arg2);
19818 result = (wxDateTime *) &_result_ref;
19819 }
19820
19821 wxPyEndAllowThreads(__tstate);
19822 if (PyErr_Occurred()) SWIG_fail;
19823 }
19824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19825 return resultobj;
19826 fail:
19827 return NULL;
19828 }
19829
19830
19831 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19832 PyObject *resultobj;
19833 wxDateTime *arg1 = (wxDateTime *) 0 ;
19834 double arg2 ;
19835 wxDateTime *result;
19836 PyObject * obj0 = 0 ;
19837 PyObject * obj1 = 0 ;
19838 char *kwnames[] = {
19839 (char *) "self",(char *) "jdn", NULL
19840 };
19841
19842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19844 if (SWIG_arg_fail(1)) SWIG_fail;
19845 {
19846 arg2 = (double)(SWIG_As_double(obj1));
19847 if (SWIG_arg_fail(2)) SWIG_fail;
19848 }
19849 {
19850 PyThreadState* __tstate = wxPyBeginAllowThreads();
19851 {
19852 wxDateTime &_result_ref = (arg1)->Set(arg2);
19853 result = (wxDateTime *) &_result_ref;
19854 }
19855
19856 wxPyEndAllowThreads(__tstate);
19857 if (PyErr_Occurred()) SWIG_fail;
19858 }
19859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19860 return resultobj;
19861 fail:
19862 return NULL;
19863 }
19864
19865
19866 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19867 PyObject *resultobj;
19868 wxDateTime *arg1 = (wxDateTime *) 0 ;
19869 int arg2 ;
19870 int arg3 = (int) 0 ;
19871 int arg4 = (int) 0 ;
19872 int arg5 = (int) 0 ;
19873 wxDateTime *result;
19874 PyObject * obj0 = 0 ;
19875 PyObject * obj1 = 0 ;
19876 PyObject * obj2 = 0 ;
19877 PyObject * obj3 = 0 ;
19878 PyObject * obj4 = 0 ;
19879 char *kwnames[] = {
19880 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19881 };
19882
19883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19885 if (SWIG_arg_fail(1)) SWIG_fail;
19886 {
19887 arg2 = (int)(SWIG_As_int(obj1));
19888 if (SWIG_arg_fail(2)) SWIG_fail;
19889 }
19890 if (obj2) {
19891 {
19892 arg3 = (int)(SWIG_As_int(obj2));
19893 if (SWIG_arg_fail(3)) SWIG_fail;
19894 }
19895 }
19896 if (obj3) {
19897 {
19898 arg4 = (int)(SWIG_As_int(obj3));
19899 if (SWIG_arg_fail(4)) SWIG_fail;
19900 }
19901 }
19902 if (obj4) {
19903 {
19904 arg5 = (int)(SWIG_As_int(obj4));
19905 if (SWIG_arg_fail(5)) SWIG_fail;
19906 }
19907 }
19908 {
19909 PyThreadState* __tstate = wxPyBeginAllowThreads();
19910 {
19911 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19912 result = (wxDateTime *) &_result_ref;
19913 }
19914
19915 wxPyEndAllowThreads(__tstate);
19916 if (PyErr_Occurred()) SWIG_fail;
19917 }
19918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19919 return resultobj;
19920 fail:
19921 return NULL;
19922 }
19923
19924
19925 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19926 PyObject *resultobj;
19927 wxDateTime *arg1 = (wxDateTime *) 0 ;
19928 int arg2 ;
19929 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19930 int arg4 = (int) wxDateTime::Inv_Year ;
19931 int arg5 = (int) 0 ;
19932 int arg6 = (int) 0 ;
19933 int arg7 = (int) 0 ;
19934 int arg8 = (int) 0 ;
19935 wxDateTime *result;
19936 PyObject * obj0 = 0 ;
19937 PyObject * obj1 = 0 ;
19938 PyObject * obj2 = 0 ;
19939 PyObject * obj3 = 0 ;
19940 PyObject * obj4 = 0 ;
19941 PyObject * obj5 = 0 ;
19942 PyObject * obj6 = 0 ;
19943 PyObject * obj7 = 0 ;
19944 char *kwnames[] = {
19945 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19946 };
19947
19948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19950 if (SWIG_arg_fail(1)) SWIG_fail;
19951 {
19952 arg2 = (int)(SWIG_As_int(obj1));
19953 if (SWIG_arg_fail(2)) SWIG_fail;
19954 }
19955 if (obj2) {
19956 {
19957 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19958 if (SWIG_arg_fail(3)) SWIG_fail;
19959 }
19960 }
19961 if (obj3) {
19962 {
19963 arg4 = (int)(SWIG_As_int(obj3));
19964 if (SWIG_arg_fail(4)) SWIG_fail;
19965 }
19966 }
19967 if (obj4) {
19968 {
19969 arg5 = (int)(SWIG_As_int(obj4));
19970 if (SWIG_arg_fail(5)) SWIG_fail;
19971 }
19972 }
19973 if (obj5) {
19974 {
19975 arg6 = (int)(SWIG_As_int(obj5));
19976 if (SWIG_arg_fail(6)) SWIG_fail;
19977 }
19978 }
19979 if (obj6) {
19980 {
19981 arg7 = (int)(SWIG_As_int(obj6));
19982 if (SWIG_arg_fail(7)) SWIG_fail;
19983 }
19984 }
19985 if (obj7) {
19986 {
19987 arg8 = (int)(SWIG_As_int(obj7));
19988 if (SWIG_arg_fail(8)) SWIG_fail;
19989 }
19990 }
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 {
19994 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19995 result = (wxDateTime *) &_result_ref;
19996 }
19997
19998 wxPyEndAllowThreads(__tstate);
19999 if (PyErr_Occurred()) SWIG_fail;
20000 }
20001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20002 return resultobj;
20003 fail:
20004 return NULL;
20005 }
20006
20007
20008 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20009 PyObject *resultobj;
20010 wxDateTime *arg1 = (wxDateTime *) 0 ;
20011 wxDateTime *result;
20012 PyObject * obj0 = 0 ;
20013 char *kwnames[] = {
20014 (char *) "self", NULL
20015 };
20016
20017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20019 if (SWIG_arg_fail(1)) SWIG_fail;
20020 {
20021 PyThreadState* __tstate = wxPyBeginAllowThreads();
20022 {
20023 wxDateTime &_result_ref = (arg1)->ResetTime();
20024 result = (wxDateTime *) &_result_ref;
20025 }
20026
20027 wxPyEndAllowThreads(__tstate);
20028 if (PyErr_Occurred()) SWIG_fail;
20029 }
20030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20031 return resultobj;
20032 fail:
20033 return NULL;
20034 }
20035
20036
20037 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20038 PyObject *resultobj;
20039 wxDateTime *arg1 = (wxDateTime *) 0 ;
20040 int arg2 ;
20041 wxDateTime *result;
20042 PyObject * obj0 = 0 ;
20043 PyObject * obj1 = 0 ;
20044 char *kwnames[] = {
20045 (char *) "self",(char *) "year", NULL
20046 };
20047
20048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20050 if (SWIG_arg_fail(1)) SWIG_fail;
20051 {
20052 arg2 = (int)(SWIG_As_int(obj1));
20053 if (SWIG_arg_fail(2)) SWIG_fail;
20054 }
20055 {
20056 PyThreadState* __tstate = wxPyBeginAllowThreads();
20057 {
20058 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20059 result = (wxDateTime *) &_result_ref;
20060 }
20061
20062 wxPyEndAllowThreads(__tstate);
20063 if (PyErr_Occurred()) SWIG_fail;
20064 }
20065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20066 return resultobj;
20067 fail:
20068 return NULL;
20069 }
20070
20071
20072 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20073 PyObject *resultobj;
20074 wxDateTime *arg1 = (wxDateTime *) 0 ;
20075 wxDateTime::Month arg2 ;
20076 wxDateTime *result;
20077 PyObject * obj0 = 0 ;
20078 PyObject * obj1 = 0 ;
20079 char *kwnames[] = {
20080 (char *) "self",(char *) "month", NULL
20081 };
20082
20083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20085 if (SWIG_arg_fail(1)) SWIG_fail;
20086 {
20087 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20088 if (SWIG_arg_fail(2)) SWIG_fail;
20089 }
20090 {
20091 PyThreadState* __tstate = wxPyBeginAllowThreads();
20092 {
20093 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20094 result = (wxDateTime *) &_result_ref;
20095 }
20096
20097 wxPyEndAllowThreads(__tstate);
20098 if (PyErr_Occurred()) SWIG_fail;
20099 }
20100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20101 return resultobj;
20102 fail:
20103 return NULL;
20104 }
20105
20106
20107 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20108 PyObject *resultobj;
20109 wxDateTime *arg1 = (wxDateTime *) 0 ;
20110 int arg2 ;
20111 wxDateTime *result;
20112 PyObject * obj0 = 0 ;
20113 PyObject * obj1 = 0 ;
20114 char *kwnames[] = {
20115 (char *) "self",(char *) "day", NULL
20116 };
20117
20118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20120 if (SWIG_arg_fail(1)) SWIG_fail;
20121 {
20122 arg2 = (int)(SWIG_As_int(obj1));
20123 if (SWIG_arg_fail(2)) SWIG_fail;
20124 }
20125 {
20126 PyThreadState* __tstate = wxPyBeginAllowThreads();
20127 {
20128 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20129 result = (wxDateTime *) &_result_ref;
20130 }
20131
20132 wxPyEndAllowThreads(__tstate);
20133 if (PyErr_Occurred()) SWIG_fail;
20134 }
20135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20136 return resultobj;
20137 fail:
20138 return NULL;
20139 }
20140
20141
20142 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20143 PyObject *resultobj;
20144 wxDateTime *arg1 = (wxDateTime *) 0 ;
20145 int arg2 ;
20146 wxDateTime *result;
20147 PyObject * obj0 = 0 ;
20148 PyObject * obj1 = 0 ;
20149 char *kwnames[] = {
20150 (char *) "self",(char *) "hour", NULL
20151 };
20152
20153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20155 if (SWIG_arg_fail(1)) SWIG_fail;
20156 {
20157 arg2 = (int)(SWIG_As_int(obj1));
20158 if (SWIG_arg_fail(2)) SWIG_fail;
20159 }
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 {
20163 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20164 result = (wxDateTime *) &_result_ref;
20165 }
20166
20167 wxPyEndAllowThreads(__tstate);
20168 if (PyErr_Occurred()) SWIG_fail;
20169 }
20170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20171 return resultobj;
20172 fail:
20173 return NULL;
20174 }
20175
20176
20177 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20178 PyObject *resultobj;
20179 wxDateTime *arg1 = (wxDateTime *) 0 ;
20180 int arg2 ;
20181 wxDateTime *result;
20182 PyObject * obj0 = 0 ;
20183 PyObject * obj1 = 0 ;
20184 char *kwnames[] = {
20185 (char *) "self",(char *) "minute", NULL
20186 };
20187
20188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20190 if (SWIG_arg_fail(1)) SWIG_fail;
20191 {
20192 arg2 = (int)(SWIG_As_int(obj1));
20193 if (SWIG_arg_fail(2)) SWIG_fail;
20194 }
20195 {
20196 PyThreadState* __tstate = wxPyBeginAllowThreads();
20197 {
20198 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20199 result = (wxDateTime *) &_result_ref;
20200 }
20201
20202 wxPyEndAllowThreads(__tstate);
20203 if (PyErr_Occurred()) SWIG_fail;
20204 }
20205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20206 return resultobj;
20207 fail:
20208 return NULL;
20209 }
20210
20211
20212 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20213 PyObject *resultobj;
20214 wxDateTime *arg1 = (wxDateTime *) 0 ;
20215 int arg2 ;
20216 wxDateTime *result;
20217 PyObject * obj0 = 0 ;
20218 PyObject * obj1 = 0 ;
20219 char *kwnames[] = {
20220 (char *) "self",(char *) "second", NULL
20221 };
20222
20223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20225 if (SWIG_arg_fail(1)) SWIG_fail;
20226 {
20227 arg2 = (int)(SWIG_As_int(obj1));
20228 if (SWIG_arg_fail(2)) SWIG_fail;
20229 }
20230 {
20231 PyThreadState* __tstate = wxPyBeginAllowThreads();
20232 {
20233 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20234 result = (wxDateTime *) &_result_ref;
20235 }
20236
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20248 PyObject *resultobj;
20249 wxDateTime *arg1 = (wxDateTime *) 0 ;
20250 int arg2 ;
20251 wxDateTime *result;
20252 PyObject * obj0 = 0 ;
20253 PyObject * obj1 = 0 ;
20254 char *kwnames[] = {
20255 (char *) "self",(char *) "millisecond", NULL
20256 };
20257
20258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 {
20262 arg2 = (int)(SWIG_As_int(obj1));
20263 if (SWIG_arg_fail(2)) SWIG_fail;
20264 }
20265 {
20266 PyThreadState* __tstate = wxPyBeginAllowThreads();
20267 {
20268 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20269 result = (wxDateTime *) &_result_ref;
20270 }
20271
20272 wxPyEndAllowThreads(__tstate);
20273 if (PyErr_Occurred()) SWIG_fail;
20274 }
20275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20276 return resultobj;
20277 fail:
20278 return NULL;
20279 }
20280
20281
20282 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20283 PyObject *resultobj;
20284 wxDateTime *arg1 = (wxDateTime *) 0 ;
20285 wxDateTime::WeekDay arg2 ;
20286 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20287 wxDateTime *result;
20288 PyObject * obj0 = 0 ;
20289 PyObject * obj1 = 0 ;
20290 PyObject * obj2 = 0 ;
20291 char *kwnames[] = {
20292 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20293 };
20294
20295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20297 if (SWIG_arg_fail(1)) SWIG_fail;
20298 {
20299 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20300 if (SWIG_arg_fail(2)) SWIG_fail;
20301 }
20302 if (obj2) {
20303 {
20304 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20305 if (SWIG_arg_fail(3)) SWIG_fail;
20306 }
20307 }
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 {
20311 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20312 result = (wxDateTime *) &_result_ref;
20313 }
20314
20315 wxPyEndAllowThreads(__tstate);
20316 if (PyErr_Occurred()) SWIG_fail;
20317 }
20318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20319 return resultobj;
20320 fail:
20321 return NULL;
20322 }
20323
20324
20325 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20326 PyObject *resultobj;
20327 wxDateTime *arg1 = (wxDateTime *) 0 ;
20328 wxDateTime::WeekDay arg2 ;
20329 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20330 wxDateTime result;
20331 PyObject * obj0 = 0 ;
20332 PyObject * obj1 = 0 ;
20333 PyObject * obj2 = 0 ;
20334 char *kwnames[] = {
20335 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20336 };
20337
20338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20340 if (SWIG_arg_fail(1)) SWIG_fail;
20341 {
20342 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20343 if (SWIG_arg_fail(2)) SWIG_fail;
20344 }
20345 if (obj2) {
20346 {
20347 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20348 if (SWIG_arg_fail(3)) SWIG_fail;
20349 }
20350 }
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 {
20359 wxDateTime * resultptr;
20360 resultptr = new wxDateTime((wxDateTime &)(result));
20361 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20362 }
20363 return resultobj;
20364 fail:
20365 return NULL;
20366 }
20367
20368
20369 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20370 PyObject *resultobj;
20371 wxDateTime *arg1 = (wxDateTime *) 0 ;
20372 wxDateTime::WeekDay arg2 ;
20373 wxDateTime *result;
20374 PyObject * obj0 = 0 ;
20375 PyObject * obj1 = 0 ;
20376 char *kwnames[] = {
20377 (char *) "self",(char *) "weekday", NULL
20378 };
20379
20380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20382 if (SWIG_arg_fail(1)) SWIG_fail;
20383 {
20384 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20385 if (SWIG_arg_fail(2)) SWIG_fail;
20386 }
20387 {
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 {
20390 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20391 result = (wxDateTime *) &_result_ref;
20392 }
20393
20394 wxPyEndAllowThreads(__tstate);
20395 if (PyErr_Occurred()) SWIG_fail;
20396 }
20397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20398 return resultobj;
20399 fail:
20400 return NULL;
20401 }
20402
20403
20404 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20405 PyObject *resultobj;
20406 wxDateTime *arg1 = (wxDateTime *) 0 ;
20407 wxDateTime::WeekDay arg2 ;
20408 wxDateTime result;
20409 PyObject * obj0 = 0 ;
20410 PyObject * obj1 = 0 ;
20411 char *kwnames[] = {
20412 (char *) "self",(char *) "weekday", NULL
20413 };
20414
20415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20417 if (SWIG_arg_fail(1)) SWIG_fail;
20418 {
20419 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20420 if (SWIG_arg_fail(2)) SWIG_fail;
20421 }
20422 {
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20425
20426 wxPyEndAllowThreads(__tstate);
20427 if (PyErr_Occurred()) SWIG_fail;
20428 }
20429 {
20430 wxDateTime * resultptr;
20431 resultptr = new wxDateTime((wxDateTime &)(result));
20432 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20433 }
20434 return resultobj;
20435 fail:
20436 return NULL;
20437 }
20438
20439
20440 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20441 PyObject *resultobj;
20442 wxDateTime *arg1 = (wxDateTime *) 0 ;
20443 wxDateTime::WeekDay arg2 ;
20444 wxDateTime *result;
20445 PyObject * obj0 = 0 ;
20446 PyObject * obj1 = 0 ;
20447 char *kwnames[] = {
20448 (char *) "self",(char *) "weekday", NULL
20449 };
20450
20451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20453 if (SWIG_arg_fail(1)) SWIG_fail;
20454 {
20455 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20456 if (SWIG_arg_fail(2)) SWIG_fail;
20457 }
20458 {
20459 PyThreadState* __tstate = wxPyBeginAllowThreads();
20460 {
20461 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20462 result = (wxDateTime *) &_result_ref;
20463 }
20464
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20476 PyObject *resultobj;
20477 wxDateTime *arg1 = (wxDateTime *) 0 ;
20478 wxDateTime::WeekDay arg2 ;
20479 wxDateTime result;
20480 PyObject * obj0 = 0 ;
20481 PyObject * obj1 = 0 ;
20482 char *kwnames[] = {
20483 (char *) "self",(char *) "weekday", NULL
20484 };
20485
20486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20488 if (SWIG_arg_fail(1)) SWIG_fail;
20489 {
20490 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20491 if (SWIG_arg_fail(2)) SWIG_fail;
20492 }
20493 {
20494 PyThreadState* __tstate = wxPyBeginAllowThreads();
20495 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20496
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 {
20501 wxDateTime * resultptr;
20502 resultptr = new wxDateTime((wxDateTime &)(result));
20503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20504 }
20505 return resultobj;
20506 fail:
20507 return NULL;
20508 }
20509
20510
20511 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20512 PyObject *resultobj;
20513 wxDateTime *arg1 = (wxDateTime *) 0 ;
20514 wxDateTime::WeekDay arg2 ;
20515 int arg3 = (int) 1 ;
20516 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20517 int arg5 = (int) wxDateTime::Inv_Year ;
20518 bool result;
20519 PyObject * obj0 = 0 ;
20520 PyObject * obj1 = 0 ;
20521 PyObject * obj2 = 0 ;
20522 PyObject * obj3 = 0 ;
20523 PyObject * obj4 = 0 ;
20524 char *kwnames[] = {
20525 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20526 };
20527
20528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20530 if (SWIG_arg_fail(1)) SWIG_fail;
20531 {
20532 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20533 if (SWIG_arg_fail(2)) SWIG_fail;
20534 }
20535 if (obj2) {
20536 {
20537 arg3 = (int)(SWIG_As_int(obj2));
20538 if (SWIG_arg_fail(3)) SWIG_fail;
20539 }
20540 }
20541 if (obj3) {
20542 {
20543 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20544 if (SWIG_arg_fail(4)) SWIG_fail;
20545 }
20546 }
20547 if (obj4) {
20548 {
20549 arg5 = (int)(SWIG_As_int(obj4));
20550 if (SWIG_arg_fail(5)) SWIG_fail;
20551 }
20552 }
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20556
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 {
20561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20562 }
20563 return resultobj;
20564 fail:
20565 return NULL;
20566 }
20567
20568
20569 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20570 PyObject *resultobj;
20571 wxDateTime *arg1 = (wxDateTime *) 0 ;
20572 wxDateTime::WeekDay arg2 ;
20573 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20574 int arg4 = (int) wxDateTime::Inv_Year ;
20575 bool result;
20576 PyObject * obj0 = 0 ;
20577 PyObject * obj1 = 0 ;
20578 PyObject * obj2 = 0 ;
20579 PyObject * obj3 = 0 ;
20580 char *kwnames[] = {
20581 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20582 };
20583
20584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20586 if (SWIG_arg_fail(1)) SWIG_fail;
20587 {
20588 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20589 if (SWIG_arg_fail(2)) SWIG_fail;
20590 }
20591 if (obj2) {
20592 {
20593 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20594 if (SWIG_arg_fail(3)) SWIG_fail;
20595 }
20596 }
20597 if (obj3) {
20598 {
20599 arg4 = (int)(SWIG_As_int(obj3));
20600 if (SWIG_arg_fail(4)) SWIG_fail;
20601 }
20602 }
20603 {
20604 PyThreadState* __tstate = wxPyBeginAllowThreads();
20605 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20606
20607 wxPyEndAllowThreads(__tstate);
20608 if (PyErr_Occurred()) SWIG_fail;
20609 }
20610 {
20611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20612 }
20613 return resultobj;
20614 fail:
20615 return NULL;
20616 }
20617
20618
20619 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20620 PyObject *resultobj;
20621 wxDateTime *arg1 = (wxDateTime *) 0 ;
20622 wxDateTime::WeekDay arg2 ;
20623 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20624 int arg4 = (int) wxDateTime::Inv_Year ;
20625 wxDateTime result;
20626 PyObject * obj0 = 0 ;
20627 PyObject * obj1 = 0 ;
20628 PyObject * obj2 = 0 ;
20629 PyObject * obj3 = 0 ;
20630 char *kwnames[] = {
20631 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20632 };
20633
20634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20636 if (SWIG_arg_fail(1)) SWIG_fail;
20637 {
20638 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20639 if (SWIG_arg_fail(2)) SWIG_fail;
20640 }
20641 if (obj2) {
20642 {
20643 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20644 if (SWIG_arg_fail(3)) SWIG_fail;
20645 }
20646 }
20647 if (obj3) {
20648 {
20649 arg4 = (int)(SWIG_As_int(obj3));
20650 if (SWIG_arg_fail(4)) SWIG_fail;
20651 }
20652 }
20653 {
20654 PyThreadState* __tstate = wxPyBeginAllowThreads();
20655 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20656
20657 wxPyEndAllowThreads(__tstate);
20658 if (PyErr_Occurred()) SWIG_fail;
20659 }
20660 {
20661 wxDateTime * resultptr;
20662 resultptr = new wxDateTime((wxDateTime &)(result));
20663 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20664 }
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20672 PyObject *resultobj;
20673 wxDateTime *arg1 = (wxDateTime *) 0 ;
20674 int arg2 ;
20675 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20676 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20677 bool result;
20678 PyObject * obj0 = 0 ;
20679 PyObject * obj1 = 0 ;
20680 PyObject * obj2 = 0 ;
20681 PyObject * obj3 = 0 ;
20682 char *kwnames[] = {
20683 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20684 };
20685
20686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20688 if (SWIG_arg_fail(1)) SWIG_fail;
20689 {
20690 arg2 = (int)(SWIG_As_int(obj1));
20691 if (SWIG_arg_fail(2)) SWIG_fail;
20692 }
20693 if (obj2) {
20694 {
20695 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20696 if (SWIG_arg_fail(3)) SWIG_fail;
20697 }
20698 }
20699 if (obj3) {
20700 {
20701 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20702 if (SWIG_arg_fail(4)) SWIG_fail;
20703 }
20704 }
20705 {
20706 PyThreadState* __tstate = wxPyBeginAllowThreads();
20707 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20708
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 {
20713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20714 }
20715 return resultobj;
20716 fail:
20717 return NULL;
20718 }
20719
20720
20721 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20722 PyObject *resultobj;
20723 wxDateTime *arg1 = (wxDateTime *) 0 ;
20724 int arg2 ;
20725 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20726 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20727 wxDateTime result;
20728 PyObject * obj0 = 0 ;
20729 PyObject * obj1 = 0 ;
20730 PyObject * obj2 = 0 ;
20731 PyObject * obj3 = 0 ;
20732 char *kwnames[] = {
20733 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20734 };
20735
20736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20738 if (SWIG_arg_fail(1)) SWIG_fail;
20739 {
20740 arg2 = (int)(SWIG_As_int(obj1));
20741 if (SWIG_arg_fail(2)) SWIG_fail;
20742 }
20743 if (obj2) {
20744 {
20745 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20746 if (SWIG_arg_fail(3)) SWIG_fail;
20747 }
20748 }
20749 if (obj3) {
20750 {
20751 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20752 if (SWIG_arg_fail(4)) SWIG_fail;
20753 }
20754 }
20755 {
20756 PyThreadState* __tstate = wxPyBeginAllowThreads();
20757 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20758
20759 wxPyEndAllowThreads(__tstate);
20760 if (PyErr_Occurred()) SWIG_fail;
20761 }
20762 {
20763 wxDateTime * resultptr;
20764 resultptr = new wxDateTime((wxDateTime &)(result));
20765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20766 }
20767 return resultobj;
20768 fail:
20769 return NULL;
20770 }
20771
20772
20773 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20774 PyObject *resultobj;
20775 int arg1 ;
20776 int arg2 ;
20777 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20778 wxDateTime result;
20779 PyObject * obj0 = 0 ;
20780 PyObject * obj1 = 0 ;
20781 PyObject * obj2 = 0 ;
20782 char *kwnames[] = {
20783 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20784 };
20785
20786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20787 {
20788 arg1 = (int)(SWIG_As_int(obj0));
20789 if (SWIG_arg_fail(1)) SWIG_fail;
20790 }
20791 {
20792 arg2 = (int)(SWIG_As_int(obj1));
20793 if (SWIG_arg_fail(2)) SWIG_fail;
20794 }
20795 if (obj2) {
20796 {
20797 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20798 if (SWIG_arg_fail(3)) SWIG_fail;
20799 }
20800 }
20801 {
20802 PyThreadState* __tstate = wxPyBeginAllowThreads();
20803 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20804
20805 wxPyEndAllowThreads(__tstate);
20806 if (PyErr_Occurred()) SWIG_fail;
20807 }
20808 {
20809 wxDateTime * resultptr;
20810 resultptr = new wxDateTime((wxDateTime &)(result));
20811 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20812 }
20813 return resultobj;
20814 fail:
20815 return NULL;
20816 }
20817
20818
20819 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20820 PyObject *resultobj;
20821 wxDateTime *arg1 = (wxDateTime *) 0 ;
20822 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20823 int arg3 = (int) wxDateTime::Inv_Year ;
20824 wxDateTime *result;
20825 PyObject * obj0 = 0 ;
20826 PyObject * obj1 = 0 ;
20827 PyObject * obj2 = 0 ;
20828 char *kwnames[] = {
20829 (char *) "self",(char *) "month",(char *) "year", NULL
20830 };
20831
20832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20834 if (SWIG_arg_fail(1)) SWIG_fail;
20835 if (obj1) {
20836 {
20837 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20838 if (SWIG_arg_fail(2)) SWIG_fail;
20839 }
20840 }
20841 if (obj2) {
20842 {
20843 arg3 = (int)(SWIG_As_int(obj2));
20844 if (SWIG_arg_fail(3)) SWIG_fail;
20845 }
20846 }
20847 {
20848 PyThreadState* __tstate = wxPyBeginAllowThreads();
20849 {
20850 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20851 result = (wxDateTime *) &_result_ref;
20852 }
20853
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20858 return resultobj;
20859 fail:
20860 return NULL;
20861 }
20862
20863
20864 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20865 PyObject *resultobj;
20866 wxDateTime *arg1 = (wxDateTime *) 0 ;
20867 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20868 int arg3 = (int) wxDateTime::Inv_Year ;
20869 wxDateTime result;
20870 PyObject * obj0 = 0 ;
20871 PyObject * obj1 = 0 ;
20872 PyObject * obj2 = 0 ;
20873 char *kwnames[] = {
20874 (char *) "self",(char *) "month",(char *) "year", NULL
20875 };
20876
20877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20879 if (SWIG_arg_fail(1)) SWIG_fail;
20880 if (obj1) {
20881 {
20882 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20883 if (SWIG_arg_fail(2)) SWIG_fail;
20884 }
20885 }
20886 if (obj2) {
20887 {
20888 arg3 = (int)(SWIG_As_int(obj2));
20889 if (SWIG_arg_fail(3)) SWIG_fail;
20890 }
20891 }
20892 {
20893 PyThreadState* __tstate = wxPyBeginAllowThreads();
20894 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20895
20896 wxPyEndAllowThreads(__tstate);
20897 if (PyErr_Occurred()) SWIG_fail;
20898 }
20899 {
20900 wxDateTime * resultptr;
20901 resultptr = new wxDateTime((wxDateTime &)(result));
20902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20911 PyObject *resultobj;
20912 wxDateTime *arg1 = (wxDateTime *) 0 ;
20913 int arg2 ;
20914 wxDateTime *result;
20915 PyObject * obj0 = 0 ;
20916 PyObject * obj1 = 0 ;
20917 char *kwnames[] = {
20918 (char *) "self",(char *) "yday", NULL
20919 };
20920
20921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20923 if (SWIG_arg_fail(1)) SWIG_fail;
20924 {
20925 arg2 = (int)(SWIG_As_int(obj1));
20926 if (SWIG_arg_fail(2)) SWIG_fail;
20927 }
20928 {
20929 PyThreadState* __tstate = wxPyBeginAllowThreads();
20930 {
20931 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20932 result = (wxDateTime *) &_result_ref;
20933 }
20934
20935 wxPyEndAllowThreads(__tstate);
20936 if (PyErr_Occurred()) SWIG_fail;
20937 }
20938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20939 return resultobj;
20940 fail:
20941 return NULL;
20942 }
20943
20944
20945 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20946 PyObject *resultobj;
20947 wxDateTime *arg1 = (wxDateTime *) 0 ;
20948 int arg2 ;
20949 wxDateTime result;
20950 PyObject * obj0 = 0 ;
20951 PyObject * obj1 = 0 ;
20952 char *kwnames[] = {
20953 (char *) "self",(char *) "yday", NULL
20954 };
20955
20956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20958 if (SWIG_arg_fail(1)) SWIG_fail;
20959 {
20960 arg2 = (int)(SWIG_As_int(obj1));
20961 if (SWIG_arg_fail(2)) SWIG_fail;
20962 }
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 result = (arg1)->GetYearDay(arg2);
20966
20967 wxPyEndAllowThreads(__tstate);
20968 if (PyErr_Occurred()) SWIG_fail;
20969 }
20970 {
20971 wxDateTime * resultptr;
20972 resultptr = new wxDateTime((wxDateTime &)(result));
20973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20974 }
20975 return resultobj;
20976 fail:
20977 return NULL;
20978 }
20979
20980
20981 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20982 PyObject *resultobj;
20983 wxDateTime *arg1 = (wxDateTime *) 0 ;
20984 double result;
20985 PyObject * obj0 = 0 ;
20986 char *kwnames[] = {
20987 (char *) "self", NULL
20988 };
20989
20990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20992 if (SWIG_arg_fail(1)) SWIG_fail;
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 result = (double)(arg1)->GetJulianDayNumber();
20996
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 {
21001 resultobj = SWIG_From_double((double)(result));
21002 }
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21010 PyObject *resultobj;
21011 wxDateTime *arg1 = (wxDateTime *) 0 ;
21012 double result;
21013 PyObject * obj0 = 0 ;
21014 char *kwnames[] = {
21015 (char *) "self", NULL
21016 };
21017
21018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21020 if (SWIG_arg_fail(1)) SWIG_fail;
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 result = (double)(arg1)->GetJDN();
21024
21025 wxPyEndAllowThreads(__tstate);
21026 if (PyErr_Occurred()) SWIG_fail;
21027 }
21028 {
21029 resultobj = SWIG_From_double((double)(result));
21030 }
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21038 PyObject *resultobj;
21039 wxDateTime *arg1 = (wxDateTime *) 0 ;
21040 double result;
21041 PyObject * obj0 = 0 ;
21042 char *kwnames[] = {
21043 (char *) "self", NULL
21044 };
21045
21046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21048 if (SWIG_arg_fail(1)) SWIG_fail;
21049 {
21050 PyThreadState* __tstate = wxPyBeginAllowThreads();
21051 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21052
21053 wxPyEndAllowThreads(__tstate);
21054 if (PyErr_Occurred()) SWIG_fail;
21055 }
21056 {
21057 resultobj = SWIG_From_double((double)(result));
21058 }
21059 return resultobj;
21060 fail:
21061 return NULL;
21062 }
21063
21064
21065 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21066 PyObject *resultobj;
21067 wxDateTime *arg1 = (wxDateTime *) 0 ;
21068 double result;
21069 PyObject * obj0 = 0 ;
21070 char *kwnames[] = {
21071 (char *) "self", NULL
21072 };
21073
21074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21076 if (SWIG_arg_fail(1)) SWIG_fail;
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 result = (double)(arg1)->GetMJD();
21080
21081 wxPyEndAllowThreads(__tstate);
21082 if (PyErr_Occurred()) SWIG_fail;
21083 }
21084 {
21085 resultobj = SWIG_From_double((double)(result));
21086 }
21087 return resultobj;
21088 fail:
21089 return NULL;
21090 }
21091
21092
21093 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21094 PyObject *resultobj;
21095 wxDateTime *arg1 = (wxDateTime *) 0 ;
21096 double result;
21097 PyObject * obj0 = 0 ;
21098 char *kwnames[] = {
21099 (char *) "self", NULL
21100 };
21101
21102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21104 if (SWIG_arg_fail(1)) SWIG_fail;
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 result = (double)(arg1)->GetRataDie();
21108
21109 wxPyEndAllowThreads(__tstate);
21110 if (PyErr_Occurred()) SWIG_fail;
21111 }
21112 {
21113 resultobj = SWIG_From_double((double)(result));
21114 }
21115 return resultobj;
21116 fail:
21117 return NULL;
21118 }
21119
21120
21121 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21122 PyObject *resultobj;
21123 wxDateTime *arg1 = (wxDateTime *) 0 ;
21124 wxDateTime::TimeZone *arg2 = 0 ;
21125 bool arg3 = (bool) false ;
21126 wxDateTime result;
21127 bool temp2 = false ;
21128 PyObject * obj0 = 0 ;
21129 PyObject * obj1 = 0 ;
21130 PyObject * obj2 = 0 ;
21131 char *kwnames[] = {
21132 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21133 };
21134
21135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21137 if (SWIG_arg_fail(1)) SWIG_fail;
21138 {
21139 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21140 temp2 = true;
21141 }
21142 if (obj2) {
21143 {
21144 arg3 = (bool)(SWIG_As_bool(obj2));
21145 if (SWIG_arg_fail(3)) SWIG_fail;
21146 }
21147 }
21148 {
21149 PyThreadState* __tstate = wxPyBeginAllowThreads();
21150 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21151
21152 wxPyEndAllowThreads(__tstate);
21153 if (PyErr_Occurred()) SWIG_fail;
21154 }
21155 {
21156 wxDateTime * resultptr;
21157 resultptr = new wxDateTime((wxDateTime &)(result));
21158 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21159 }
21160 {
21161 if (temp2) delete arg2;
21162 }
21163 return resultobj;
21164 fail:
21165 {
21166 if (temp2) delete arg2;
21167 }
21168 return NULL;
21169 }
21170
21171
21172 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21173 PyObject *resultobj;
21174 wxDateTime *arg1 = (wxDateTime *) 0 ;
21175 wxDateTime::TimeZone *arg2 = 0 ;
21176 bool arg3 = (bool) false ;
21177 wxDateTime *result;
21178 bool temp2 = false ;
21179 PyObject * obj0 = 0 ;
21180 PyObject * obj1 = 0 ;
21181 PyObject * obj2 = 0 ;
21182 char *kwnames[] = {
21183 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21184 };
21185
21186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21188 if (SWIG_arg_fail(1)) SWIG_fail;
21189 {
21190 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21191 temp2 = true;
21192 }
21193 if (obj2) {
21194 {
21195 arg3 = (bool)(SWIG_As_bool(obj2));
21196 if (SWIG_arg_fail(3)) SWIG_fail;
21197 }
21198 }
21199 {
21200 PyThreadState* __tstate = wxPyBeginAllowThreads();
21201 {
21202 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21203 result = (wxDateTime *) &_result_ref;
21204 }
21205
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21210 {
21211 if (temp2) delete arg2;
21212 }
21213 return resultobj;
21214 fail:
21215 {
21216 if (temp2) delete arg2;
21217 }
21218 return NULL;
21219 }
21220
21221
21222 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21223 PyObject *resultobj;
21224 wxDateTime *arg1 = (wxDateTime *) 0 ;
21225 bool arg2 = (bool) false ;
21226 wxDateTime result;
21227 PyObject * obj0 = 0 ;
21228 PyObject * obj1 = 0 ;
21229 char *kwnames[] = {
21230 (char *) "self",(char *) "noDST", NULL
21231 };
21232
21233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21235 if (SWIG_arg_fail(1)) SWIG_fail;
21236 if (obj1) {
21237 {
21238 arg2 = (bool)(SWIG_As_bool(obj1));
21239 if (SWIG_arg_fail(2)) SWIG_fail;
21240 }
21241 }
21242 {
21243 PyThreadState* __tstate = wxPyBeginAllowThreads();
21244 result = (arg1)->ToGMT(arg2);
21245
21246 wxPyEndAllowThreads(__tstate);
21247 if (PyErr_Occurred()) SWIG_fail;
21248 }
21249 {
21250 wxDateTime * resultptr;
21251 resultptr = new wxDateTime((wxDateTime &)(result));
21252 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21253 }
21254 return resultobj;
21255 fail:
21256 return NULL;
21257 }
21258
21259
21260 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21261 PyObject *resultobj;
21262 wxDateTime *arg1 = (wxDateTime *) 0 ;
21263 bool arg2 = (bool) false ;
21264 wxDateTime *result;
21265 PyObject * obj0 = 0 ;
21266 PyObject * obj1 = 0 ;
21267 char *kwnames[] = {
21268 (char *) "self",(char *) "noDST", NULL
21269 };
21270
21271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21273 if (SWIG_arg_fail(1)) SWIG_fail;
21274 if (obj1) {
21275 {
21276 arg2 = (bool)(SWIG_As_bool(obj1));
21277 if (SWIG_arg_fail(2)) SWIG_fail;
21278 }
21279 }
21280 {
21281 PyThreadState* __tstate = wxPyBeginAllowThreads();
21282 {
21283 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21284 result = (wxDateTime *) &_result_ref;
21285 }
21286
21287 wxPyEndAllowThreads(__tstate);
21288 if (PyErr_Occurred()) SWIG_fail;
21289 }
21290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21291 return resultobj;
21292 fail:
21293 return NULL;
21294 }
21295
21296
21297 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21298 PyObject *resultobj;
21299 wxDateTime *arg1 = (wxDateTime *) 0 ;
21300 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21301 int result;
21302 PyObject * obj0 = 0 ;
21303 PyObject * obj1 = 0 ;
21304 char *kwnames[] = {
21305 (char *) "self",(char *) "country", NULL
21306 };
21307
21308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21310 if (SWIG_arg_fail(1)) SWIG_fail;
21311 if (obj1) {
21312 {
21313 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21314 if (SWIG_arg_fail(2)) SWIG_fail;
21315 }
21316 }
21317 {
21318 PyThreadState* __tstate = wxPyBeginAllowThreads();
21319 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21320
21321 wxPyEndAllowThreads(__tstate);
21322 if (PyErr_Occurred()) SWIG_fail;
21323 }
21324 {
21325 resultobj = SWIG_From_int((int)(result));
21326 }
21327 return resultobj;
21328 fail:
21329 return NULL;
21330 }
21331
21332
21333 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21334 PyObject *resultobj;
21335 wxDateTime *arg1 = (wxDateTime *) 0 ;
21336 bool result;
21337 PyObject * obj0 = 0 ;
21338 char *kwnames[] = {
21339 (char *) "self", NULL
21340 };
21341
21342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21344 if (SWIG_arg_fail(1)) SWIG_fail;
21345 {
21346 PyThreadState* __tstate = wxPyBeginAllowThreads();
21347 result = (bool)((wxDateTime const *)arg1)->IsValid();
21348
21349 wxPyEndAllowThreads(__tstate);
21350 if (PyErr_Occurred()) SWIG_fail;
21351 }
21352 {
21353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21354 }
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21362 PyObject *resultobj;
21363 wxDateTime *arg1 = (wxDateTime *) 0 ;
21364 time_t result;
21365 PyObject * obj0 = 0 ;
21366 char *kwnames[] = {
21367 (char *) "self", NULL
21368 };
21369
21370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21372 if (SWIG_arg_fail(1)) SWIG_fail;
21373 {
21374 PyThreadState* __tstate = wxPyBeginAllowThreads();
21375 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21376
21377 wxPyEndAllowThreads(__tstate);
21378 if (PyErr_Occurred()) SWIG_fail;
21379 }
21380 {
21381 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21382 }
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj;
21391 wxDateTime *arg1 = (wxDateTime *) 0 ;
21392 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21393 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21394 int result;
21395 bool temp2 = false ;
21396 PyObject * obj0 = 0 ;
21397 PyObject * obj1 = 0 ;
21398 char *kwnames[] = {
21399 (char *) "self",(char *) "tz", NULL
21400 };
21401
21402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21404 if (SWIG_arg_fail(1)) SWIG_fail;
21405 if (obj1) {
21406 {
21407 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21408 temp2 = true;
21409 }
21410 }
21411 {
21412 PyThreadState* __tstate = wxPyBeginAllowThreads();
21413 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21414
21415 wxPyEndAllowThreads(__tstate);
21416 if (PyErr_Occurred()) SWIG_fail;
21417 }
21418 {
21419 resultobj = SWIG_From_int((int)(result));
21420 }
21421 {
21422 if (temp2) delete arg2;
21423 }
21424 return resultobj;
21425 fail:
21426 {
21427 if (temp2) delete arg2;
21428 }
21429 return NULL;
21430 }
21431
21432
21433 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21434 PyObject *resultobj;
21435 wxDateTime *arg1 = (wxDateTime *) 0 ;
21436 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21437 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21438 wxDateTime::Month result;
21439 bool temp2 = false ;
21440 PyObject * obj0 = 0 ;
21441 PyObject * obj1 = 0 ;
21442 char *kwnames[] = {
21443 (char *) "self",(char *) "tz", NULL
21444 };
21445
21446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21448 if (SWIG_arg_fail(1)) SWIG_fail;
21449 if (obj1) {
21450 {
21451 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21452 temp2 = true;
21453 }
21454 }
21455 {
21456 PyThreadState* __tstate = wxPyBeginAllowThreads();
21457 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21458
21459 wxPyEndAllowThreads(__tstate);
21460 if (PyErr_Occurred()) SWIG_fail;
21461 }
21462 resultobj = SWIG_From_int((result));
21463 {
21464 if (temp2) delete arg2;
21465 }
21466 return resultobj;
21467 fail:
21468 {
21469 if (temp2) delete arg2;
21470 }
21471 return NULL;
21472 }
21473
21474
21475 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21476 PyObject *resultobj;
21477 wxDateTime *arg1 = (wxDateTime *) 0 ;
21478 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21479 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21480 int result;
21481 bool temp2 = false ;
21482 PyObject * obj0 = 0 ;
21483 PyObject * obj1 = 0 ;
21484 char *kwnames[] = {
21485 (char *) "self",(char *) "tz", NULL
21486 };
21487
21488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21490 if (SWIG_arg_fail(1)) SWIG_fail;
21491 if (obj1) {
21492 {
21493 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21494 temp2 = true;
21495 }
21496 }
21497 {
21498 PyThreadState* __tstate = wxPyBeginAllowThreads();
21499 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21500
21501 wxPyEndAllowThreads(__tstate);
21502 if (PyErr_Occurred()) SWIG_fail;
21503 }
21504 {
21505 resultobj = SWIG_From_int((int)(result));
21506 }
21507 {
21508 if (temp2) delete arg2;
21509 }
21510 return resultobj;
21511 fail:
21512 {
21513 if (temp2) delete arg2;
21514 }
21515 return NULL;
21516 }
21517
21518
21519 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21520 PyObject *resultobj;
21521 wxDateTime *arg1 = (wxDateTime *) 0 ;
21522 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21523 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21524 wxDateTime::WeekDay result;
21525 bool temp2 = false ;
21526 PyObject * obj0 = 0 ;
21527 PyObject * obj1 = 0 ;
21528 char *kwnames[] = {
21529 (char *) "self",(char *) "tz", NULL
21530 };
21531
21532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21534 if (SWIG_arg_fail(1)) SWIG_fail;
21535 if (obj1) {
21536 {
21537 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21538 temp2 = true;
21539 }
21540 }
21541 {
21542 PyThreadState* __tstate = wxPyBeginAllowThreads();
21543 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21544
21545 wxPyEndAllowThreads(__tstate);
21546 if (PyErr_Occurred()) SWIG_fail;
21547 }
21548 resultobj = SWIG_From_int((result));
21549 {
21550 if (temp2) delete arg2;
21551 }
21552 return resultobj;
21553 fail:
21554 {
21555 if (temp2) delete arg2;
21556 }
21557 return NULL;
21558 }
21559
21560
21561 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21562 PyObject *resultobj;
21563 wxDateTime *arg1 = (wxDateTime *) 0 ;
21564 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21565 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21566 int result;
21567 bool temp2 = false ;
21568 PyObject * obj0 = 0 ;
21569 PyObject * obj1 = 0 ;
21570 char *kwnames[] = {
21571 (char *) "self",(char *) "tz", NULL
21572 };
21573
21574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21576 if (SWIG_arg_fail(1)) SWIG_fail;
21577 if (obj1) {
21578 {
21579 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21580 temp2 = true;
21581 }
21582 }
21583 {
21584 PyThreadState* __tstate = wxPyBeginAllowThreads();
21585 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21586
21587 wxPyEndAllowThreads(__tstate);
21588 if (PyErr_Occurred()) SWIG_fail;
21589 }
21590 {
21591 resultobj = SWIG_From_int((int)(result));
21592 }
21593 {
21594 if (temp2) delete arg2;
21595 }
21596 return resultobj;
21597 fail:
21598 {
21599 if (temp2) delete arg2;
21600 }
21601 return NULL;
21602 }
21603
21604
21605 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21606 PyObject *resultobj;
21607 wxDateTime *arg1 = (wxDateTime *) 0 ;
21608 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21609 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21610 int result;
21611 bool temp2 = false ;
21612 PyObject * obj0 = 0 ;
21613 PyObject * obj1 = 0 ;
21614 char *kwnames[] = {
21615 (char *) "self",(char *) "tz", NULL
21616 };
21617
21618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21620 if (SWIG_arg_fail(1)) SWIG_fail;
21621 if (obj1) {
21622 {
21623 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21624 temp2 = true;
21625 }
21626 }
21627 {
21628 PyThreadState* __tstate = wxPyBeginAllowThreads();
21629 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21630
21631 wxPyEndAllowThreads(__tstate);
21632 if (PyErr_Occurred()) SWIG_fail;
21633 }
21634 {
21635 resultobj = SWIG_From_int((int)(result));
21636 }
21637 {
21638 if (temp2) delete arg2;
21639 }
21640 return resultobj;
21641 fail:
21642 {
21643 if (temp2) delete arg2;
21644 }
21645 return NULL;
21646 }
21647
21648
21649 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21650 PyObject *resultobj;
21651 wxDateTime *arg1 = (wxDateTime *) 0 ;
21652 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21653 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21654 int result;
21655 bool temp2 = false ;
21656 PyObject * obj0 = 0 ;
21657 PyObject * obj1 = 0 ;
21658 char *kwnames[] = {
21659 (char *) "self",(char *) "tz", NULL
21660 };
21661
21662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21664 if (SWIG_arg_fail(1)) SWIG_fail;
21665 if (obj1) {
21666 {
21667 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21668 temp2 = true;
21669 }
21670 }
21671 {
21672 PyThreadState* __tstate = wxPyBeginAllowThreads();
21673 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21674
21675 wxPyEndAllowThreads(__tstate);
21676 if (PyErr_Occurred()) SWIG_fail;
21677 }
21678 {
21679 resultobj = SWIG_From_int((int)(result));
21680 }
21681 {
21682 if (temp2) delete arg2;
21683 }
21684 return resultobj;
21685 fail:
21686 {
21687 if (temp2) delete arg2;
21688 }
21689 return NULL;
21690 }
21691
21692
21693 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21694 PyObject *resultobj;
21695 wxDateTime *arg1 = (wxDateTime *) 0 ;
21696 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21697 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21698 int result;
21699 bool temp2 = false ;
21700 PyObject * obj0 = 0 ;
21701 PyObject * obj1 = 0 ;
21702 char *kwnames[] = {
21703 (char *) "self",(char *) "tz", NULL
21704 };
21705
21706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21708 if (SWIG_arg_fail(1)) SWIG_fail;
21709 if (obj1) {
21710 {
21711 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21712 temp2 = true;
21713 }
21714 }
21715 {
21716 PyThreadState* __tstate = wxPyBeginAllowThreads();
21717 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21718
21719 wxPyEndAllowThreads(__tstate);
21720 if (PyErr_Occurred()) SWIG_fail;
21721 }
21722 {
21723 resultobj = SWIG_From_int((int)(result));
21724 }
21725 {
21726 if (temp2) delete arg2;
21727 }
21728 return resultobj;
21729 fail:
21730 {
21731 if (temp2) delete arg2;
21732 }
21733 return NULL;
21734 }
21735
21736
21737 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21738 PyObject *resultobj;
21739 wxDateTime *arg1 = (wxDateTime *) 0 ;
21740 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21741 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21742 int result;
21743 bool temp2 = false ;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 char *kwnames[] = {
21747 (char *) "self",(char *) "tz", NULL
21748 };
21749
21750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21752 if (SWIG_arg_fail(1)) SWIG_fail;
21753 if (obj1) {
21754 {
21755 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21756 temp2 = true;
21757 }
21758 }
21759 {
21760 PyThreadState* __tstate = wxPyBeginAllowThreads();
21761 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21762
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 {
21767 resultobj = SWIG_From_int((int)(result));
21768 }
21769 {
21770 if (temp2) delete arg2;
21771 }
21772 return resultobj;
21773 fail:
21774 {
21775 if (temp2) delete arg2;
21776 }
21777 return NULL;
21778 }
21779
21780
21781 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21782 PyObject *resultobj;
21783 wxDateTime *arg1 = (wxDateTime *) 0 ;
21784 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21785 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21786 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21787 int result;
21788 bool temp3 = false ;
21789 PyObject * obj0 = 0 ;
21790 PyObject * obj1 = 0 ;
21791 PyObject * obj2 = 0 ;
21792 char *kwnames[] = {
21793 (char *) "self",(char *) "flags",(char *) "tz", NULL
21794 };
21795
21796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21798 if (SWIG_arg_fail(1)) SWIG_fail;
21799 if (obj1) {
21800 {
21801 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21802 if (SWIG_arg_fail(2)) SWIG_fail;
21803 }
21804 }
21805 if (obj2) {
21806 {
21807 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21808 temp3 = true;
21809 }
21810 }
21811 {
21812 PyThreadState* __tstate = wxPyBeginAllowThreads();
21813 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21814
21815 wxPyEndAllowThreads(__tstate);
21816 if (PyErr_Occurred()) SWIG_fail;
21817 }
21818 {
21819 resultobj = SWIG_From_int((int)(result));
21820 }
21821 {
21822 if (temp3) delete arg3;
21823 }
21824 return resultobj;
21825 fail:
21826 {
21827 if (temp3) delete arg3;
21828 }
21829 return NULL;
21830 }
21831
21832
21833 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21834 PyObject *resultobj;
21835 wxDateTime *arg1 = (wxDateTime *) 0 ;
21836 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21837 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21838 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21839 int result;
21840 bool temp3 = false ;
21841 PyObject * obj0 = 0 ;
21842 PyObject * obj1 = 0 ;
21843 PyObject * obj2 = 0 ;
21844 char *kwnames[] = {
21845 (char *) "self",(char *) "flags",(char *) "tz", NULL
21846 };
21847
21848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21850 if (SWIG_arg_fail(1)) SWIG_fail;
21851 if (obj1) {
21852 {
21853 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21854 if (SWIG_arg_fail(2)) SWIG_fail;
21855 }
21856 }
21857 if (obj2) {
21858 {
21859 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21860 temp3 = true;
21861 }
21862 }
21863 {
21864 PyThreadState* __tstate = wxPyBeginAllowThreads();
21865 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21866
21867 wxPyEndAllowThreads(__tstate);
21868 if (PyErr_Occurred()) SWIG_fail;
21869 }
21870 {
21871 resultobj = SWIG_From_int((int)(result));
21872 }
21873 {
21874 if (temp3) delete arg3;
21875 }
21876 return resultobj;
21877 fail:
21878 {
21879 if (temp3) delete arg3;
21880 }
21881 return NULL;
21882 }
21883
21884
21885 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj;
21887 wxDateTime *arg1 = (wxDateTime *) 0 ;
21888 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21889 bool result;
21890 PyObject * obj0 = 0 ;
21891 PyObject * obj1 = 0 ;
21892 char *kwnames[] = {
21893 (char *) "self",(char *) "country", NULL
21894 };
21895
21896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21898 if (SWIG_arg_fail(1)) SWIG_fail;
21899 if (obj1) {
21900 {
21901 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21902 if (SWIG_arg_fail(2)) SWIG_fail;
21903 }
21904 }
21905 {
21906 PyThreadState* __tstate = wxPyBeginAllowThreads();
21907 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21908
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 {
21913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21914 }
21915 return resultobj;
21916 fail:
21917 return NULL;
21918 }
21919
21920
21921 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21922 PyObject *resultobj;
21923 wxDateTime *arg1 = (wxDateTime *) 0 ;
21924 wxDateTime *arg2 = 0 ;
21925 bool result;
21926 PyObject * obj0 = 0 ;
21927 PyObject * obj1 = 0 ;
21928 char *kwnames[] = {
21929 (char *) "self",(char *) "datetime", NULL
21930 };
21931
21932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21934 if (SWIG_arg_fail(1)) SWIG_fail;
21935 {
21936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21937 if (SWIG_arg_fail(2)) SWIG_fail;
21938 if (arg2 == NULL) {
21939 SWIG_null_ref("wxDateTime");
21940 }
21941 if (SWIG_arg_fail(2)) SWIG_fail;
21942 }
21943 {
21944 PyThreadState* __tstate = wxPyBeginAllowThreads();
21945 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21946
21947 wxPyEndAllowThreads(__tstate);
21948 if (PyErr_Occurred()) SWIG_fail;
21949 }
21950 {
21951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21952 }
21953 return resultobj;
21954 fail:
21955 return NULL;
21956 }
21957
21958
21959 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21960 PyObject *resultobj;
21961 wxDateTime *arg1 = (wxDateTime *) 0 ;
21962 wxDateTime *arg2 = 0 ;
21963 bool result;
21964 PyObject * obj0 = 0 ;
21965 PyObject * obj1 = 0 ;
21966 char *kwnames[] = {
21967 (char *) "self",(char *) "datetime", NULL
21968 };
21969
21970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21972 if (SWIG_arg_fail(1)) SWIG_fail;
21973 {
21974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21975 if (SWIG_arg_fail(2)) SWIG_fail;
21976 if (arg2 == NULL) {
21977 SWIG_null_ref("wxDateTime");
21978 }
21979 if (SWIG_arg_fail(2)) SWIG_fail;
21980 }
21981 {
21982 PyThreadState* __tstate = wxPyBeginAllowThreads();
21983 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21984
21985 wxPyEndAllowThreads(__tstate);
21986 if (PyErr_Occurred()) SWIG_fail;
21987 }
21988 {
21989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21990 }
21991 return resultobj;
21992 fail:
21993 return NULL;
21994 }
21995
21996
21997 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21998 PyObject *resultobj;
21999 wxDateTime *arg1 = (wxDateTime *) 0 ;
22000 wxDateTime *arg2 = 0 ;
22001 bool result;
22002 PyObject * obj0 = 0 ;
22003 PyObject * obj1 = 0 ;
22004 char *kwnames[] = {
22005 (char *) "self",(char *) "datetime", NULL
22006 };
22007
22008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22010 if (SWIG_arg_fail(1)) SWIG_fail;
22011 {
22012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22013 if (SWIG_arg_fail(2)) SWIG_fail;
22014 if (arg2 == NULL) {
22015 SWIG_null_ref("wxDateTime");
22016 }
22017 if (SWIG_arg_fail(2)) SWIG_fail;
22018 }
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22022
22023 wxPyEndAllowThreads(__tstate);
22024 if (PyErr_Occurred()) SWIG_fail;
22025 }
22026 {
22027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22028 }
22029 return resultobj;
22030 fail:
22031 return NULL;
22032 }
22033
22034
22035 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22036 PyObject *resultobj;
22037 wxDateTime *arg1 = (wxDateTime *) 0 ;
22038 wxDateTime *arg2 = 0 ;
22039 wxDateTime *arg3 = 0 ;
22040 bool result;
22041 PyObject * obj0 = 0 ;
22042 PyObject * obj1 = 0 ;
22043 PyObject * obj2 = 0 ;
22044 char *kwnames[] = {
22045 (char *) "self",(char *) "t1",(char *) "t2", NULL
22046 };
22047
22048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22050 if (SWIG_arg_fail(1)) SWIG_fail;
22051 {
22052 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22053 if (SWIG_arg_fail(2)) SWIG_fail;
22054 if (arg2 == NULL) {
22055 SWIG_null_ref("wxDateTime");
22056 }
22057 if (SWIG_arg_fail(2)) SWIG_fail;
22058 }
22059 {
22060 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22061 if (SWIG_arg_fail(3)) SWIG_fail;
22062 if (arg3 == NULL) {
22063 SWIG_null_ref("wxDateTime");
22064 }
22065 if (SWIG_arg_fail(3)) SWIG_fail;
22066 }
22067 {
22068 PyThreadState* __tstate = wxPyBeginAllowThreads();
22069 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22070
22071 wxPyEndAllowThreads(__tstate);
22072 if (PyErr_Occurred()) SWIG_fail;
22073 }
22074 {
22075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22076 }
22077 return resultobj;
22078 fail:
22079 return NULL;
22080 }
22081
22082
22083 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22084 PyObject *resultobj;
22085 wxDateTime *arg1 = (wxDateTime *) 0 ;
22086 wxDateTime *arg2 = 0 ;
22087 wxDateTime *arg3 = 0 ;
22088 bool result;
22089 PyObject * obj0 = 0 ;
22090 PyObject * obj1 = 0 ;
22091 PyObject * obj2 = 0 ;
22092 char *kwnames[] = {
22093 (char *) "self",(char *) "t1",(char *) "t2", NULL
22094 };
22095
22096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22098 if (SWIG_arg_fail(1)) SWIG_fail;
22099 {
22100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22101 if (SWIG_arg_fail(2)) SWIG_fail;
22102 if (arg2 == NULL) {
22103 SWIG_null_ref("wxDateTime");
22104 }
22105 if (SWIG_arg_fail(2)) SWIG_fail;
22106 }
22107 {
22108 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22109 if (SWIG_arg_fail(3)) SWIG_fail;
22110 if (arg3 == NULL) {
22111 SWIG_null_ref("wxDateTime");
22112 }
22113 if (SWIG_arg_fail(3)) SWIG_fail;
22114 }
22115 {
22116 PyThreadState* __tstate = wxPyBeginAllowThreads();
22117 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22118
22119 wxPyEndAllowThreads(__tstate);
22120 if (PyErr_Occurred()) SWIG_fail;
22121 }
22122 {
22123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22124 }
22125 return resultobj;
22126 fail:
22127 return NULL;
22128 }
22129
22130
22131 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22132 PyObject *resultobj;
22133 wxDateTime *arg1 = (wxDateTime *) 0 ;
22134 wxDateTime *arg2 = 0 ;
22135 bool result;
22136 PyObject * obj0 = 0 ;
22137 PyObject * obj1 = 0 ;
22138 char *kwnames[] = {
22139 (char *) "self",(char *) "dt", NULL
22140 };
22141
22142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22144 if (SWIG_arg_fail(1)) SWIG_fail;
22145 {
22146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22147 if (SWIG_arg_fail(2)) SWIG_fail;
22148 if (arg2 == NULL) {
22149 SWIG_null_ref("wxDateTime");
22150 }
22151 if (SWIG_arg_fail(2)) SWIG_fail;
22152 }
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22156
22157 wxPyEndAllowThreads(__tstate);
22158 if (PyErr_Occurred()) SWIG_fail;
22159 }
22160 {
22161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22162 }
22163 return resultobj;
22164 fail:
22165 return NULL;
22166 }
22167
22168
22169 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22170 PyObject *resultobj;
22171 wxDateTime *arg1 = (wxDateTime *) 0 ;
22172 wxDateTime *arg2 = 0 ;
22173 bool result;
22174 PyObject * obj0 = 0 ;
22175 PyObject * obj1 = 0 ;
22176 char *kwnames[] = {
22177 (char *) "self",(char *) "dt", NULL
22178 };
22179
22180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22182 if (SWIG_arg_fail(1)) SWIG_fail;
22183 {
22184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22185 if (SWIG_arg_fail(2)) SWIG_fail;
22186 if (arg2 == NULL) {
22187 SWIG_null_ref("wxDateTime");
22188 }
22189 if (SWIG_arg_fail(2)) SWIG_fail;
22190 }
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22194
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 {
22199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22200 }
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22208 PyObject *resultobj;
22209 wxDateTime *arg1 = (wxDateTime *) 0 ;
22210 wxDateTime *arg2 = 0 ;
22211 wxTimeSpan *arg3 = 0 ;
22212 bool result;
22213 PyObject * obj0 = 0 ;
22214 PyObject * obj1 = 0 ;
22215 PyObject * obj2 = 0 ;
22216 char *kwnames[] = {
22217 (char *) "self",(char *) "dt",(char *) "ts", NULL
22218 };
22219
22220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22222 if (SWIG_arg_fail(1)) SWIG_fail;
22223 {
22224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22225 if (SWIG_arg_fail(2)) SWIG_fail;
22226 if (arg2 == NULL) {
22227 SWIG_null_ref("wxDateTime");
22228 }
22229 if (SWIG_arg_fail(2)) SWIG_fail;
22230 }
22231 {
22232 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22233 if (SWIG_arg_fail(3)) SWIG_fail;
22234 if (arg3 == NULL) {
22235 SWIG_null_ref("wxTimeSpan");
22236 }
22237 if (SWIG_arg_fail(3)) SWIG_fail;
22238 }
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22242
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 {
22247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22248 }
22249 return resultobj;
22250 fail:
22251 return NULL;
22252 }
22253
22254
22255 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22256 PyObject *resultobj;
22257 wxDateTime *arg1 = (wxDateTime *) 0 ;
22258 wxTimeSpan *arg2 = 0 ;
22259 wxDateTime *result;
22260 PyObject * obj0 = 0 ;
22261 PyObject * obj1 = 0 ;
22262 char *kwnames[] = {
22263 (char *) "self",(char *) "diff", NULL
22264 };
22265
22266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22268 if (SWIG_arg_fail(1)) SWIG_fail;
22269 {
22270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22271 if (SWIG_arg_fail(2)) SWIG_fail;
22272 if (arg2 == NULL) {
22273 SWIG_null_ref("wxTimeSpan");
22274 }
22275 if (SWIG_arg_fail(2)) SWIG_fail;
22276 }
22277 {
22278 PyThreadState* __tstate = wxPyBeginAllowThreads();
22279 {
22280 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22281 result = (wxDateTime *) &_result_ref;
22282 }
22283
22284 wxPyEndAllowThreads(__tstate);
22285 if (PyErr_Occurred()) SWIG_fail;
22286 }
22287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22288 return resultobj;
22289 fail:
22290 return NULL;
22291 }
22292
22293
22294 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22295 PyObject *resultobj;
22296 wxDateTime *arg1 = (wxDateTime *) 0 ;
22297 wxDateSpan *arg2 = 0 ;
22298 wxDateTime *result;
22299 PyObject * obj0 = 0 ;
22300 PyObject * obj1 = 0 ;
22301 char *kwnames[] = {
22302 (char *) "self",(char *) "diff", NULL
22303 };
22304
22305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22307 if (SWIG_arg_fail(1)) SWIG_fail;
22308 {
22309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22310 if (SWIG_arg_fail(2)) SWIG_fail;
22311 if (arg2 == NULL) {
22312 SWIG_null_ref("wxDateSpan");
22313 }
22314 if (SWIG_arg_fail(2)) SWIG_fail;
22315 }
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 {
22319 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22320 result = (wxDateTime *) &_result_ref;
22321 }
22322
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22327 return resultobj;
22328 fail:
22329 return NULL;
22330 }
22331
22332
22333 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22334 PyObject *resultobj;
22335 wxDateTime *arg1 = (wxDateTime *) 0 ;
22336 wxTimeSpan *arg2 = 0 ;
22337 wxDateTime *result;
22338 PyObject * obj0 = 0 ;
22339 PyObject * obj1 = 0 ;
22340 char *kwnames[] = {
22341 (char *) "self",(char *) "diff", NULL
22342 };
22343
22344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22346 if (SWIG_arg_fail(1)) SWIG_fail;
22347 {
22348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22349 if (SWIG_arg_fail(2)) SWIG_fail;
22350 if (arg2 == NULL) {
22351 SWIG_null_ref("wxTimeSpan");
22352 }
22353 if (SWIG_arg_fail(2)) SWIG_fail;
22354 }
22355 {
22356 PyThreadState* __tstate = wxPyBeginAllowThreads();
22357 {
22358 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22359 result = (wxDateTime *) &_result_ref;
22360 }
22361
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22366 return resultobj;
22367 fail:
22368 return NULL;
22369 }
22370
22371
22372 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22373 PyObject *resultobj;
22374 wxDateTime *arg1 = (wxDateTime *) 0 ;
22375 wxDateSpan *arg2 = 0 ;
22376 wxDateTime *result;
22377 PyObject * obj0 = 0 ;
22378 PyObject * obj1 = 0 ;
22379 char *kwnames[] = {
22380 (char *) "self",(char *) "diff", NULL
22381 };
22382
22383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22385 if (SWIG_arg_fail(1)) SWIG_fail;
22386 {
22387 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22388 if (SWIG_arg_fail(2)) SWIG_fail;
22389 if (arg2 == NULL) {
22390 SWIG_null_ref("wxDateSpan");
22391 }
22392 if (SWIG_arg_fail(2)) SWIG_fail;
22393 }
22394 {
22395 PyThreadState* __tstate = wxPyBeginAllowThreads();
22396 {
22397 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22398 result = (wxDateTime *) &_result_ref;
22399 }
22400
22401 wxPyEndAllowThreads(__tstate);
22402 if (PyErr_Occurred()) SWIG_fail;
22403 }
22404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22405 return resultobj;
22406 fail:
22407 return NULL;
22408 }
22409
22410
22411 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22412 PyObject *resultobj;
22413 wxDateTime *arg1 = (wxDateTime *) 0 ;
22414 wxDateTime *arg2 = 0 ;
22415 wxTimeSpan result;
22416 PyObject * obj0 = 0 ;
22417 PyObject * obj1 = 0 ;
22418 char *kwnames[] = {
22419 (char *) "self",(char *) "dt", NULL
22420 };
22421
22422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22424 if (SWIG_arg_fail(1)) SWIG_fail;
22425 {
22426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22427 if (SWIG_arg_fail(2)) SWIG_fail;
22428 if (arg2 == NULL) {
22429 SWIG_null_ref("wxDateTime");
22430 }
22431 if (SWIG_arg_fail(2)) SWIG_fail;
22432 }
22433 {
22434 PyThreadState* __tstate = wxPyBeginAllowThreads();
22435 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22436
22437 wxPyEndAllowThreads(__tstate);
22438 if (PyErr_Occurred()) SWIG_fail;
22439 }
22440 {
22441 wxTimeSpan * resultptr;
22442 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22443 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22444 }
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22452 PyObject *resultobj;
22453 wxDateTime *arg1 = (wxDateTime *) 0 ;
22454 wxTimeSpan *arg2 = 0 ;
22455 wxDateTime *result;
22456 PyObject * obj0 = 0 ;
22457 PyObject * obj1 = 0 ;
22458
22459 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22461 if (SWIG_arg_fail(1)) SWIG_fail;
22462 {
22463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22464 if (SWIG_arg_fail(2)) SWIG_fail;
22465 if (arg2 == NULL) {
22466 SWIG_null_ref("wxTimeSpan");
22467 }
22468 if (SWIG_arg_fail(2)) SWIG_fail;
22469 }
22470 {
22471 PyThreadState* __tstate = wxPyBeginAllowThreads();
22472 {
22473 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22474 result = (wxDateTime *) &_result_ref;
22475 }
22476
22477 wxPyEndAllowThreads(__tstate);
22478 if (PyErr_Occurred()) SWIG_fail;
22479 }
22480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22488 PyObject *resultobj;
22489 wxDateTime *arg1 = (wxDateTime *) 0 ;
22490 wxDateSpan *arg2 = 0 ;
22491 wxDateTime *result;
22492 PyObject * obj0 = 0 ;
22493 PyObject * obj1 = 0 ;
22494
22495 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22497 if (SWIG_arg_fail(1)) SWIG_fail;
22498 {
22499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22500 if (SWIG_arg_fail(2)) SWIG_fail;
22501 if (arg2 == NULL) {
22502 SWIG_null_ref("wxDateSpan");
22503 }
22504 if (SWIG_arg_fail(2)) SWIG_fail;
22505 }
22506 {
22507 PyThreadState* __tstate = wxPyBeginAllowThreads();
22508 {
22509 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22510 result = (wxDateTime *) &_result_ref;
22511 }
22512
22513 wxPyEndAllowThreads(__tstate);
22514 if (PyErr_Occurred()) SWIG_fail;
22515 }
22516 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22524 int argc;
22525 PyObject *argv[3];
22526 int ii;
22527
22528 argc = PyObject_Length(args);
22529 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22530 argv[ii] = PyTuple_GetItem(args,ii);
22531 }
22532 if (argc == 2) {
22533 int _v;
22534 {
22535 void *ptr;
22536 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22537 _v = 0;
22538 PyErr_Clear();
22539 } else {
22540 _v = 1;
22541 }
22542 }
22543 if (_v) {
22544 {
22545 void *ptr = 0;
22546 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22547 _v = 0;
22548 PyErr_Clear();
22549 } else {
22550 _v = (ptr != 0);
22551 }
22552 }
22553 if (_v) {
22554 return _wrap_DateTime___iadd____SWIG_0(self,args);
22555 }
22556 }
22557 }
22558 if (argc == 2) {
22559 int _v;
22560 {
22561 void *ptr;
22562 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22563 _v = 0;
22564 PyErr_Clear();
22565 } else {
22566 _v = 1;
22567 }
22568 }
22569 if (_v) {
22570 {
22571 void *ptr = 0;
22572 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22573 _v = 0;
22574 PyErr_Clear();
22575 } else {
22576 _v = (ptr != 0);
22577 }
22578 }
22579 if (_v) {
22580 return _wrap_DateTime___iadd____SWIG_1(self,args);
22581 }
22582 }
22583 }
22584
22585 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22586 return NULL;
22587 }
22588
22589
22590 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22591 PyObject *resultobj;
22592 wxDateTime *arg1 = (wxDateTime *) 0 ;
22593 wxTimeSpan *arg2 = 0 ;
22594 wxDateTime *result;
22595 PyObject * obj0 = 0 ;
22596 PyObject * obj1 = 0 ;
22597
22598 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22600 if (SWIG_arg_fail(1)) SWIG_fail;
22601 {
22602 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22603 if (SWIG_arg_fail(2)) SWIG_fail;
22604 if (arg2 == NULL) {
22605 SWIG_null_ref("wxTimeSpan");
22606 }
22607 if (SWIG_arg_fail(2)) SWIG_fail;
22608 }
22609 {
22610 PyThreadState* __tstate = wxPyBeginAllowThreads();
22611 {
22612 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22613 result = (wxDateTime *) &_result_ref;
22614 }
22615
22616 wxPyEndAllowThreads(__tstate);
22617 if (PyErr_Occurred()) SWIG_fail;
22618 }
22619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22620 return resultobj;
22621 fail:
22622 return NULL;
22623 }
22624
22625
22626 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22627 PyObject *resultobj;
22628 wxDateTime *arg1 = (wxDateTime *) 0 ;
22629 wxDateSpan *arg2 = 0 ;
22630 wxDateTime *result;
22631 PyObject * obj0 = 0 ;
22632 PyObject * obj1 = 0 ;
22633
22634 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22636 if (SWIG_arg_fail(1)) SWIG_fail;
22637 {
22638 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22639 if (SWIG_arg_fail(2)) SWIG_fail;
22640 if (arg2 == NULL) {
22641 SWIG_null_ref("wxDateSpan");
22642 }
22643 if (SWIG_arg_fail(2)) SWIG_fail;
22644 }
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 {
22648 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22649 result = (wxDateTime *) &_result_ref;
22650 }
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22663 int argc;
22664 PyObject *argv[3];
22665 int ii;
22666
22667 argc = PyObject_Length(args);
22668 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22669 argv[ii] = PyTuple_GetItem(args,ii);
22670 }
22671 if (argc == 2) {
22672 int _v;
22673 {
22674 void *ptr;
22675 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22676 _v = 0;
22677 PyErr_Clear();
22678 } else {
22679 _v = 1;
22680 }
22681 }
22682 if (_v) {
22683 {
22684 void *ptr = 0;
22685 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22686 _v = 0;
22687 PyErr_Clear();
22688 } else {
22689 _v = (ptr != 0);
22690 }
22691 }
22692 if (_v) {
22693 return _wrap_DateTime___isub____SWIG_0(self,args);
22694 }
22695 }
22696 }
22697 if (argc == 2) {
22698 int _v;
22699 {
22700 void *ptr;
22701 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22702 _v = 0;
22703 PyErr_Clear();
22704 } else {
22705 _v = 1;
22706 }
22707 }
22708 if (_v) {
22709 {
22710 void *ptr = 0;
22711 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22712 _v = 0;
22713 PyErr_Clear();
22714 } else {
22715 _v = (ptr != 0);
22716 }
22717 }
22718 if (_v) {
22719 return _wrap_DateTime___isub____SWIG_1(self,args);
22720 }
22721 }
22722 }
22723
22724 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22725 return NULL;
22726 }
22727
22728
22729 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22730 PyObject *resultobj;
22731 wxDateTime *arg1 = (wxDateTime *) 0 ;
22732 wxTimeSpan *arg2 = 0 ;
22733 wxDateTime result;
22734 PyObject * obj0 = 0 ;
22735 PyObject * obj1 = 0 ;
22736
22737 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22739 if (SWIG_arg_fail(1)) SWIG_fail;
22740 {
22741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22742 if (SWIG_arg_fail(2)) SWIG_fail;
22743 if (arg2 == NULL) {
22744 SWIG_null_ref("wxTimeSpan");
22745 }
22746 if (SWIG_arg_fail(2)) SWIG_fail;
22747 }
22748 {
22749 PyThreadState* __tstate = wxPyBeginAllowThreads();
22750 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22751
22752 wxPyEndAllowThreads(__tstate);
22753 if (PyErr_Occurred()) SWIG_fail;
22754 }
22755 {
22756 wxDateTime * resultptr;
22757 resultptr = new wxDateTime((wxDateTime &)(result));
22758 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22759 }
22760 return resultobj;
22761 fail:
22762 return NULL;
22763 }
22764
22765
22766 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22767 PyObject *resultobj;
22768 wxDateTime *arg1 = (wxDateTime *) 0 ;
22769 wxDateSpan *arg2 = 0 ;
22770 wxDateTime result;
22771 PyObject * obj0 = 0 ;
22772 PyObject * obj1 = 0 ;
22773
22774 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22776 if (SWIG_arg_fail(1)) SWIG_fail;
22777 {
22778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22779 if (SWIG_arg_fail(2)) SWIG_fail;
22780 if (arg2 == NULL) {
22781 SWIG_null_ref("wxDateSpan");
22782 }
22783 if (SWIG_arg_fail(2)) SWIG_fail;
22784 }
22785 {
22786 PyThreadState* __tstate = wxPyBeginAllowThreads();
22787 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22788
22789 wxPyEndAllowThreads(__tstate);
22790 if (PyErr_Occurred()) SWIG_fail;
22791 }
22792 {
22793 wxDateTime * resultptr;
22794 resultptr = new wxDateTime((wxDateTime &)(result));
22795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22796 }
22797 return resultobj;
22798 fail:
22799 return NULL;
22800 }
22801
22802
22803 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22804 int argc;
22805 PyObject *argv[3];
22806 int ii;
22807
22808 argc = PyObject_Length(args);
22809 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22810 argv[ii] = PyTuple_GetItem(args,ii);
22811 }
22812 if (argc == 2) {
22813 int _v;
22814 {
22815 void *ptr;
22816 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22817 _v = 0;
22818 PyErr_Clear();
22819 } else {
22820 _v = 1;
22821 }
22822 }
22823 if (_v) {
22824 {
22825 void *ptr = 0;
22826 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22827 _v = 0;
22828 PyErr_Clear();
22829 } else {
22830 _v = (ptr != 0);
22831 }
22832 }
22833 if (_v) {
22834 return _wrap_DateTime___add____SWIG_0(self,args);
22835 }
22836 }
22837 }
22838 if (argc == 2) {
22839 int _v;
22840 {
22841 void *ptr;
22842 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22843 _v = 0;
22844 PyErr_Clear();
22845 } else {
22846 _v = 1;
22847 }
22848 }
22849 if (_v) {
22850 {
22851 void *ptr = 0;
22852 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22853 _v = 0;
22854 PyErr_Clear();
22855 } else {
22856 _v = (ptr != 0);
22857 }
22858 }
22859 if (_v) {
22860 return _wrap_DateTime___add____SWIG_1(self,args);
22861 }
22862 }
22863 }
22864
22865 Py_INCREF(Py_NotImplemented);
22866 return Py_NotImplemented;
22867 }
22868
22869
22870 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22871 PyObject *resultobj;
22872 wxDateTime *arg1 = (wxDateTime *) 0 ;
22873 wxDateTime *arg2 = 0 ;
22874 wxTimeSpan result;
22875 PyObject * obj0 = 0 ;
22876 PyObject * obj1 = 0 ;
22877
22878 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22880 if (SWIG_arg_fail(1)) SWIG_fail;
22881 {
22882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22883 if (SWIG_arg_fail(2)) SWIG_fail;
22884 if (arg2 == NULL) {
22885 SWIG_null_ref("wxDateTime");
22886 }
22887 if (SWIG_arg_fail(2)) SWIG_fail;
22888 }
22889 {
22890 PyThreadState* __tstate = wxPyBeginAllowThreads();
22891 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22892
22893 wxPyEndAllowThreads(__tstate);
22894 if (PyErr_Occurred()) SWIG_fail;
22895 }
22896 {
22897 wxTimeSpan * resultptr;
22898 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22899 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22900 }
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22908 PyObject *resultobj;
22909 wxDateTime *arg1 = (wxDateTime *) 0 ;
22910 wxTimeSpan *arg2 = 0 ;
22911 wxDateTime result;
22912 PyObject * obj0 = 0 ;
22913 PyObject * obj1 = 0 ;
22914
22915 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22917 if (SWIG_arg_fail(1)) SWIG_fail;
22918 {
22919 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22920 if (SWIG_arg_fail(2)) SWIG_fail;
22921 if (arg2 == NULL) {
22922 SWIG_null_ref("wxTimeSpan");
22923 }
22924 if (SWIG_arg_fail(2)) SWIG_fail;
22925 }
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22929
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 {
22934 wxDateTime * resultptr;
22935 resultptr = new wxDateTime((wxDateTime &)(result));
22936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22937 }
22938 return resultobj;
22939 fail:
22940 return NULL;
22941 }
22942
22943
22944 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22945 PyObject *resultobj;
22946 wxDateTime *arg1 = (wxDateTime *) 0 ;
22947 wxDateSpan *arg2 = 0 ;
22948 wxDateTime result;
22949 PyObject * obj0 = 0 ;
22950 PyObject * obj1 = 0 ;
22951
22952 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22954 if (SWIG_arg_fail(1)) SWIG_fail;
22955 {
22956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22957 if (SWIG_arg_fail(2)) SWIG_fail;
22958 if (arg2 == NULL) {
22959 SWIG_null_ref("wxDateSpan");
22960 }
22961 if (SWIG_arg_fail(2)) SWIG_fail;
22962 }
22963 {
22964 PyThreadState* __tstate = wxPyBeginAllowThreads();
22965 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22966
22967 wxPyEndAllowThreads(__tstate);
22968 if (PyErr_Occurred()) SWIG_fail;
22969 }
22970 {
22971 wxDateTime * resultptr;
22972 resultptr = new wxDateTime((wxDateTime &)(result));
22973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22974 }
22975 return resultobj;
22976 fail:
22977 return NULL;
22978 }
22979
22980
22981 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22982 int argc;
22983 PyObject *argv[3];
22984 int ii;
22985
22986 argc = PyObject_Length(args);
22987 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22988 argv[ii] = PyTuple_GetItem(args,ii);
22989 }
22990 if (argc == 2) {
22991 int _v;
22992 {
22993 void *ptr;
22994 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22995 _v = 0;
22996 PyErr_Clear();
22997 } else {
22998 _v = 1;
22999 }
23000 }
23001 if (_v) {
23002 {
23003 void *ptr = 0;
23004 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23005 _v = 0;
23006 PyErr_Clear();
23007 } else {
23008 _v = (ptr != 0);
23009 }
23010 }
23011 if (_v) {
23012 return _wrap_DateTime___sub____SWIG_0(self,args);
23013 }
23014 }
23015 }
23016 if (argc == 2) {
23017 int _v;
23018 {
23019 void *ptr;
23020 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23021 _v = 0;
23022 PyErr_Clear();
23023 } else {
23024 _v = 1;
23025 }
23026 }
23027 if (_v) {
23028 {
23029 void *ptr = 0;
23030 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23031 _v = 0;
23032 PyErr_Clear();
23033 } else {
23034 _v = (ptr != 0);
23035 }
23036 }
23037 if (_v) {
23038 return _wrap_DateTime___sub____SWIG_1(self,args);
23039 }
23040 }
23041 }
23042 if (argc == 2) {
23043 int _v;
23044 {
23045 void *ptr;
23046 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23047 _v = 0;
23048 PyErr_Clear();
23049 } else {
23050 _v = 1;
23051 }
23052 }
23053 if (_v) {
23054 {
23055 void *ptr = 0;
23056 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23057 _v = 0;
23058 PyErr_Clear();
23059 } else {
23060 _v = (ptr != 0);
23061 }
23062 }
23063 if (_v) {
23064 return _wrap_DateTime___sub____SWIG_2(self,args);
23065 }
23066 }
23067 }
23068
23069 Py_INCREF(Py_NotImplemented);
23070 return Py_NotImplemented;
23071 }
23072
23073
23074 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23075 PyObject *resultobj;
23076 wxDateTime *arg1 = (wxDateTime *) 0 ;
23077 wxDateTime *arg2 = (wxDateTime *) 0 ;
23078 bool result;
23079 PyObject * obj0 = 0 ;
23080 PyObject * obj1 = 0 ;
23081 char *kwnames[] = {
23082 (char *) "self",(char *) "other", NULL
23083 };
23084
23085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23087 if (SWIG_arg_fail(1)) SWIG_fail;
23088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23089 if (SWIG_arg_fail(2)) SWIG_fail;
23090 {
23091 PyThreadState* __tstate = wxPyBeginAllowThreads();
23092 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23093
23094 wxPyEndAllowThreads(__tstate);
23095 if (PyErr_Occurred()) SWIG_fail;
23096 }
23097 {
23098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23099 }
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23107 PyObject *resultobj;
23108 wxDateTime *arg1 = (wxDateTime *) 0 ;
23109 wxDateTime *arg2 = (wxDateTime *) 0 ;
23110 bool result;
23111 PyObject * obj0 = 0 ;
23112 PyObject * obj1 = 0 ;
23113 char *kwnames[] = {
23114 (char *) "self",(char *) "other", NULL
23115 };
23116
23117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23119 if (SWIG_arg_fail(1)) SWIG_fail;
23120 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23121 if (SWIG_arg_fail(2)) SWIG_fail;
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23125
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 {
23130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23131 }
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23139 PyObject *resultobj;
23140 wxDateTime *arg1 = (wxDateTime *) 0 ;
23141 wxDateTime *arg2 = (wxDateTime *) 0 ;
23142 bool result;
23143 PyObject * obj0 = 0 ;
23144 PyObject * obj1 = 0 ;
23145 char *kwnames[] = {
23146 (char *) "self",(char *) "other", NULL
23147 };
23148
23149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23151 if (SWIG_arg_fail(1)) SWIG_fail;
23152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23153 if (SWIG_arg_fail(2)) SWIG_fail;
23154 {
23155 PyThreadState* __tstate = wxPyBeginAllowThreads();
23156 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23157
23158 wxPyEndAllowThreads(__tstate);
23159 if (PyErr_Occurred()) SWIG_fail;
23160 }
23161 {
23162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23163 }
23164 return resultobj;
23165 fail:
23166 return NULL;
23167 }
23168
23169
23170 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23171 PyObject *resultobj;
23172 wxDateTime *arg1 = (wxDateTime *) 0 ;
23173 wxDateTime *arg2 = (wxDateTime *) 0 ;
23174 bool result;
23175 PyObject * obj0 = 0 ;
23176 PyObject * obj1 = 0 ;
23177 char *kwnames[] = {
23178 (char *) "self",(char *) "other", NULL
23179 };
23180
23181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23183 if (SWIG_arg_fail(1)) SWIG_fail;
23184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23185 if (SWIG_arg_fail(2)) SWIG_fail;
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23189
23190 wxPyEndAllowThreads(__tstate);
23191 if (PyErr_Occurred()) SWIG_fail;
23192 }
23193 {
23194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23195 }
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23203 PyObject *resultobj;
23204 wxDateTime *arg1 = (wxDateTime *) 0 ;
23205 wxDateTime *arg2 = (wxDateTime *) 0 ;
23206 bool result;
23207 PyObject * obj0 = 0 ;
23208 PyObject * obj1 = 0 ;
23209 char *kwnames[] = {
23210 (char *) "self",(char *) "other", NULL
23211 };
23212
23213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23215 if (SWIG_arg_fail(1)) SWIG_fail;
23216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23217 if (SWIG_arg_fail(2)) SWIG_fail;
23218 {
23219 PyThreadState* __tstate = wxPyBeginAllowThreads();
23220 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23221
23222 wxPyEndAllowThreads(__tstate);
23223 if (PyErr_Occurred()) SWIG_fail;
23224 }
23225 {
23226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23227 }
23228 return resultobj;
23229 fail:
23230 return NULL;
23231 }
23232
23233
23234 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23235 PyObject *resultobj;
23236 wxDateTime *arg1 = (wxDateTime *) 0 ;
23237 wxDateTime *arg2 = (wxDateTime *) 0 ;
23238 bool result;
23239 PyObject * obj0 = 0 ;
23240 PyObject * obj1 = 0 ;
23241 char *kwnames[] = {
23242 (char *) "self",(char *) "other", NULL
23243 };
23244
23245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23247 if (SWIG_arg_fail(1)) SWIG_fail;
23248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23249 if (SWIG_arg_fail(2)) SWIG_fail;
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23253
23254 wxPyEndAllowThreads(__tstate);
23255 if (PyErr_Occurred()) SWIG_fail;
23256 }
23257 {
23258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23259 }
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23267 PyObject *resultobj;
23268 wxDateTime *arg1 = (wxDateTime *) 0 ;
23269 wxString *arg2 = 0 ;
23270 int result;
23271 bool temp2 = false ;
23272 PyObject * obj0 = 0 ;
23273 PyObject * obj1 = 0 ;
23274 char *kwnames[] = {
23275 (char *) "self",(char *) "date", NULL
23276 };
23277
23278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23280 if (SWIG_arg_fail(1)) SWIG_fail;
23281 {
23282 arg2 = wxString_in_helper(obj1);
23283 if (arg2 == NULL) SWIG_fail;
23284 temp2 = true;
23285 }
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23289
23290 wxPyEndAllowThreads(__tstate);
23291 if (PyErr_Occurred()) SWIG_fail;
23292 }
23293 {
23294 resultobj = SWIG_From_int((int)(result));
23295 }
23296 {
23297 if (temp2)
23298 delete arg2;
23299 }
23300 return resultobj;
23301 fail:
23302 {
23303 if (temp2)
23304 delete arg2;
23305 }
23306 return NULL;
23307 }
23308
23309
23310 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23311 PyObject *resultobj;
23312 wxDateTime *arg1 = (wxDateTime *) 0 ;
23313 wxString *arg2 = 0 ;
23314 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23315 wxString *arg3 = (wxString *) &arg3_defvalue ;
23316 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23317 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23318 int result;
23319 bool temp2 = false ;
23320 bool temp3 = false ;
23321 PyObject * obj0 = 0 ;
23322 PyObject * obj1 = 0 ;
23323 PyObject * obj2 = 0 ;
23324 PyObject * obj3 = 0 ;
23325 char *kwnames[] = {
23326 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23327 };
23328
23329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23331 if (SWIG_arg_fail(1)) SWIG_fail;
23332 {
23333 arg2 = wxString_in_helper(obj1);
23334 if (arg2 == NULL) SWIG_fail;
23335 temp2 = true;
23336 }
23337 if (obj2) {
23338 {
23339 arg3 = wxString_in_helper(obj2);
23340 if (arg3 == NULL) SWIG_fail;
23341 temp3 = true;
23342 }
23343 }
23344 if (obj3) {
23345 {
23346 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23347 if (SWIG_arg_fail(4)) SWIG_fail;
23348 if (arg4 == NULL) {
23349 SWIG_null_ref("wxDateTime");
23350 }
23351 if (SWIG_arg_fail(4)) SWIG_fail;
23352 }
23353 }
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23357
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 {
23362 resultobj = SWIG_From_int((int)(result));
23363 }
23364 {
23365 if (temp2)
23366 delete arg2;
23367 }
23368 {
23369 if (temp3)
23370 delete arg3;
23371 }
23372 return resultobj;
23373 fail:
23374 {
23375 if (temp2)
23376 delete arg2;
23377 }
23378 {
23379 if (temp3)
23380 delete arg3;
23381 }
23382 return NULL;
23383 }
23384
23385
23386 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23387 PyObject *resultobj;
23388 wxDateTime *arg1 = (wxDateTime *) 0 ;
23389 wxString *arg2 = 0 ;
23390 int result;
23391 bool temp2 = false ;
23392 PyObject * obj0 = 0 ;
23393 PyObject * obj1 = 0 ;
23394 char *kwnames[] = {
23395 (char *) "self",(char *) "datetime", NULL
23396 };
23397
23398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23400 if (SWIG_arg_fail(1)) SWIG_fail;
23401 {
23402 arg2 = wxString_in_helper(obj1);
23403 if (arg2 == NULL) SWIG_fail;
23404 temp2 = true;
23405 }
23406 {
23407 PyThreadState* __tstate = wxPyBeginAllowThreads();
23408 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23409
23410 wxPyEndAllowThreads(__tstate);
23411 if (PyErr_Occurred()) SWIG_fail;
23412 }
23413 {
23414 resultobj = SWIG_From_int((int)(result));
23415 }
23416 {
23417 if (temp2)
23418 delete arg2;
23419 }
23420 return resultobj;
23421 fail:
23422 {
23423 if (temp2)
23424 delete arg2;
23425 }
23426 return NULL;
23427 }
23428
23429
23430 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23431 PyObject *resultobj;
23432 wxDateTime *arg1 = (wxDateTime *) 0 ;
23433 wxString *arg2 = 0 ;
23434 int result;
23435 bool temp2 = false ;
23436 PyObject * obj0 = 0 ;
23437 PyObject * obj1 = 0 ;
23438 char *kwnames[] = {
23439 (char *) "self",(char *) "date", NULL
23440 };
23441
23442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23444 if (SWIG_arg_fail(1)) SWIG_fail;
23445 {
23446 arg2 = wxString_in_helper(obj1);
23447 if (arg2 == NULL) SWIG_fail;
23448 temp2 = true;
23449 }
23450 {
23451 PyThreadState* __tstate = wxPyBeginAllowThreads();
23452 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23453
23454 wxPyEndAllowThreads(__tstate);
23455 if (PyErr_Occurred()) SWIG_fail;
23456 }
23457 {
23458 resultobj = SWIG_From_int((int)(result));
23459 }
23460 {
23461 if (temp2)
23462 delete arg2;
23463 }
23464 return resultobj;
23465 fail:
23466 {
23467 if (temp2)
23468 delete arg2;
23469 }
23470 return NULL;
23471 }
23472
23473
23474 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23475 PyObject *resultobj;
23476 wxDateTime *arg1 = (wxDateTime *) 0 ;
23477 wxString *arg2 = 0 ;
23478 int result;
23479 bool temp2 = false ;
23480 PyObject * obj0 = 0 ;
23481 PyObject * obj1 = 0 ;
23482 char *kwnames[] = {
23483 (char *) "self",(char *) "time", NULL
23484 };
23485
23486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23488 if (SWIG_arg_fail(1)) SWIG_fail;
23489 {
23490 arg2 = wxString_in_helper(obj1);
23491 if (arg2 == NULL) SWIG_fail;
23492 temp2 = true;
23493 }
23494 {
23495 PyThreadState* __tstate = wxPyBeginAllowThreads();
23496 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23497
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 {
23502 resultobj = SWIG_From_int((int)(result));
23503 }
23504 {
23505 if (temp2)
23506 delete arg2;
23507 }
23508 return resultobj;
23509 fail:
23510 {
23511 if (temp2)
23512 delete arg2;
23513 }
23514 return NULL;
23515 }
23516
23517
23518 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23519 PyObject *resultobj;
23520 wxDateTime *arg1 = (wxDateTime *) 0 ;
23521 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23522 wxString *arg2 = (wxString *) &arg2_defvalue ;
23523 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23524 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23525 wxString result;
23526 bool temp2 = false ;
23527 bool temp3 = false ;
23528 PyObject * obj0 = 0 ;
23529 PyObject * obj1 = 0 ;
23530 PyObject * obj2 = 0 ;
23531 char *kwnames[] = {
23532 (char *) "self",(char *) "format",(char *) "tz", NULL
23533 };
23534
23535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23537 if (SWIG_arg_fail(1)) SWIG_fail;
23538 if (obj1) {
23539 {
23540 arg2 = wxString_in_helper(obj1);
23541 if (arg2 == NULL) SWIG_fail;
23542 temp2 = true;
23543 }
23544 }
23545 if (obj2) {
23546 {
23547 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23548 temp3 = true;
23549 }
23550 }
23551 {
23552 PyThreadState* __tstate = wxPyBeginAllowThreads();
23553 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23554
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 {
23559 #if wxUSE_UNICODE
23560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23561 #else
23562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23563 #endif
23564 }
23565 {
23566 if (temp2)
23567 delete arg2;
23568 }
23569 {
23570 if (temp3) delete arg3;
23571 }
23572 return resultobj;
23573 fail:
23574 {
23575 if (temp2)
23576 delete arg2;
23577 }
23578 {
23579 if (temp3) delete arg3;
23580 }
23581 return NULL;
23582 }
23583
23584
23585 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23586 PyObject *resultobj;
23587 wxDateTime *arg1 = (wxDateTime *) 0 ;
23588 wxString result;
23589 PyObject * obj0 = 0 ;
23590 char *kwnames[] = {
23591 (char *) "self", NULL
23592 };
23593
23594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23596 if (SWIG_arg_fail(1)) SWIG_fail;
23597 {
23598 PyThreadState* __tstate = wxPyBeginAllowThreads();
23599 result = ((wxDateTime const *)arg1)->FormatDate();
23600
23601 wxPyEndAllowThreads(__tstate);
23602 if (PyErr_Occurred()) SWIG_fail;
23603 }
23604 {
23605 #if wxUSE_UNICODE
23606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23607 #else
23608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23609 #endif
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj;
23619 wxDateTime *arg1 = (wxDateTime *) 0 ;
23620 wxString result;
23621 PyObject * obj0 = 0 ;
23622 char *kwnames[] = {
23623 (char *) "self", NULL
23624 };
23625
23626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23628 if (SWIG_arg_fail(1)) SWIG_fail;
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 result = ((wxDateTime const *)arg1)->FormatTime();
23632
23633 wxPyEndAllowThreads(__tstate);
23634 if (PyErr_Occurred()) SWIG_fail;
23635 }
23636 {
23637 #if wxUSE_UNICODE
23638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23639 #else
23640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23641 #endif
23642 }
23643 return resultobj;
23644 fail:
23645 return NULL;
23646 }
23647
23648
23649 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj;
23651 wxDateTime *arg1 = (wxDateTime *) 0 ;
23652 wxString result;
23653 PyObject * obj0 = 0 ;
23654 char *kwnames[] = {
23655 (char *) "self", NULL
23656 };
23657
23658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23660 if (SWIG_arg_fail(1)) SWIG_fail;
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 result = ((wxDateTime const *)arg1)->FormatISODate();
23664
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 {
23669 #if wxUSE_UNICODE
23670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23671 #else
23672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23673 #endif
23674 }
23675 return resultobj;
23676 fail:
23677 return NULL;
23678 }
23679
23680
23681 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23682 PyObject *resultobj;
23683 wxDateTime *arg1 = (wxDateTime *) 0 ;
23684 wxString result;
23685 PyObject * obj0 = 0 ;
23686 char *kwnames[] = {
23687 (char *) "self", NULL
23688 };
23689
23690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23692 if (SWIG_arg_fail(1)) SWIG_fail;
23693 {
23694 PyThreadState* __tstate = wxPyBeginAllowThreads();
23695 result = ((wxDateTime const *)arg1)->FormatISOTime();
23696
23697 wxPyEndAllowThreads(__tstate);
23698 if (PyErr_Occurred()) SWIG_fail;
23699 }
23700 {
23701 #if wxUSE_UNICODE
23702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23703 #else
23704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23705 #endif
23706 }
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23714 PyObject *obj;
23715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23716 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23717 Py_INCREF(obj);
23718 return Py_BuildValue((char *)"");
23719 }
23720 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23721 PyObject *resultobj;
23722 long arg1 ;
23723 wxTimeSpan result;
23724 PyObject * obj0 = 0 ;
23725 char *kwnames[] = {
23726 (char *) "sec", NULL
23727 };
23728
23729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23730 {
23731 arg1 = (long)(SWIG_As_long(obj0));
23732 if (SWIG_arg_fail(1)) SWIG_fail;
23733 }
23734 {
23735 PyThreadState* __tstate = wxPyBeginAllowThreads();
23736 result = wxTimeSpan::Seconds(arg1);
23737
23738 wxPyEndAllowThreads(__tstate);
23739 if (PyErr_Occurred()) SWIG_fail;
23740 }
23741 {
23742 wxTimeSpan * resultptr;
23743 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23744 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23745 }
23746 return resultobj;
23747 fail:
23748 return NULL;
23749 }
23750
23751
23752 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj;
23754 wxTimeSpan result;
23755 char *kwnames[] = {
23756 NULL
23757 };
23758
23759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23760 {
23761 PyThreadState* __tstate = wxPyBeginAllowThreads();
23762 result = wxTimeSpan::Second();
23763
23764 wxPyEndAllowThreads(__tstate);
23765 if (PyErr_Occurred()) SWIG_fail;
23766 }
23767 {
23768 wxTimeSpan * resultptr;
23769 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23770 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23771 }
23772 return resultobj;
23773 fail:
23774 return NULL;
23775 }
23776
23777
23778 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23779 PyObject *resultobj;
23780 long arg1 ;
23781 wxTimeSpan result;
23782 PyObject * obj0 = 0 ;
23783 char *kwnames[] = {
23784 (char *) "min", NULL
23785 };
23786
23787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23788 {
23789 arg1 = (long)(SWIG_As_long(obj0));
23790 if (SWIG_arg_fail(1)) SWIG_fail;
23791 }
23792 {
23793 PyThreadState* __tstate = wxPyBeginAllowThreads();
23794 result = wxTimeSpan::Minutes(arg1);
23795
23796 wxPyEndAllowThreads(__tstate);
23797 if (PyErr_Occurred()) SWIG_fail;
23798 }
23799 {
23800 wxTimeSpan * resultptr;
23801 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23802 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23803 }
23804 return resultobj;
23805 fail:
23806 return NULL;
23807 }
23808
23809
23810 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23811 PyObject *resultobj;
23812 wxTimeSpan result;
23813 char *kwnames[] = {
23814 NULL
23815 };
23816
23817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23818 {
23819 PyThreadState* __tstate = wxPyBeginAllowThreads();
23820 result = wxTimeSpan::Minute();
23821
23822 wxPyEndAllowThreads(__tstate);
23823 if (PyErr_Occurred()) SWIG_fail;
23824 }
23825 {
23826 wxTimeSpan * resultptr;
23827 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23829 }
23830 return resultobj;
23831 fail:
23832 return NULL;
23833 }
23834
23835
23836 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj;
23838 long arg1 ;
23839 wxTimeSpan result;
23840 PyObject * obj0 = 0 ;
23841 char *kwnames[] = {
23842 (char *) "hours", NULL
23843 };
23844
23845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23846 {
23847 arg1 = (long)(SWIG_As_long(obj0));
23848 if (SWIG_arg_fail(1)) SWIG_fail;
23849 }
23850 {
23851 PyThreadState* __tstate = wxPyBeginAllowThreads();
23852 result = wxTimeSpan::Hours(arg1);
23853
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 {
23858 wxTimeSpan * resultptr;
23859 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23860 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23861 }
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23869 PyObject *resultobj;
23870 wxTimeSpan result;
23871 char *kwnames[] = {
23872 NULL
23873 };
23874
23875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23876 {
23877 PyThreadState* __tstate = wxPyBeginAllowThreads();
23878 result = wxTimeSpan::Hour();
23879
23880 wxPyEndAllowThreads(__tstate);
23881 if (PyErr_Occurred()) SWIG_fail;
23882 }
23883 {
23884 wxTimeSpan * resultptr;
23885 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23887 }
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj;
23896 long arg1 ;
23897 wxTimeSpan result;
23898 PyObject * obj0 = 0 ;
23899 char *kwnames[] = {
23900 (char *) "days", NULL
23901 };
23902
23903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23904 {
23905 arg1 = (long)(SWIG_As_long(obj0));
23906 if (SWIG_arg_fail(1)) SWIG_fail;
23907 }
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = wxTimeSpan::Days(arg1);
23911
23912 wxPyEndAllowThreads(__tstate);
23913 if (PyErr_Occurred()) SWIG_fail;
23914 }
23915 {
23916 wxTimeSpan * resultptr;
23917 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23919 }
23920 return resultobj;
23921 fail:
23922 return NULL;
23923 }
23924
23925
23926 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23927 PyObject *resultobj;
23928 wxTimeSpan result;
23929 char *kwnames[] = {
23930 NULL
23931 };
23932
23933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 result = wxTimeSpan::Day();
23937
23938 wxPyEndAllowThreads(__tstate);
23939 if (PyErr_Occurred()) SWIG_fail;
23940 }
23941 {
23942 wxTimeSpan * resultptr;
23943 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23945 }
23946 return resultobj;
23947 fail:
23948 return NULL;
23949 }
23950
23951
23952 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23953 PyObject *resultobj;
23954 long arg1 ;
23955 wxTimeSpan result;
23956 PyObject * obj0 = 0 ;
23957 char *kwnames[] = {
23958 (char *) "days", NULL
23959 };
23960
23961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23962 {
23963 arg1 = (long)(SWIG_As_long(obj0));
23964 if (SWIG_arg_fail(1)) SWIG_fail;
23965 }
23966 {
23967 PyThreadState* __tstate = wxPyBeginAllowThreads();
23968 result = wxTimeSpan::Weeks(arg1);
23969
23970 wxPyEndAllowThreads(__tstate);
23971 if (PyErr_Occurred()) SWIG_fail;
23972 }
23973 {
23974 wxTimeSpan * resultptr;
23975 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23976 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23977 }
23978 return resultobj;
23979 fail:
23980 return NULL;
23981 }
23982
23983
23984 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23985 PyObject *resultobj;
23986 wxTimeSpan result;
23987 char *kwnames[] = {
23988 NULL
23989 };
23990
23991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 result = wxTimeSpan::Week();
23995
23996 wxPyEndAllowThreads(__tstate);
23997 if (PyErr_Occurred()) SWIG_fail;
23998 }
23999 {
24000 wxTimeSpan * resultptr;
24001 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24003 }
24004 return resultobj;
24005 fail:
24006 return NULL;
24007 }
24008
24009
24010 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24011 PyObject *resultobj;
24012 long arg1 = (long) 0 ;
24013 long arg2 = (long) 0 ;
24014 long arg3 = (long) 0 ;
24015 long arg4 = (long) 0 ;
24016 wxTimeSpan *result;
24017 PyObject * obj0 = 0 ;
24018 PyObject * obj1 = 0 ;
24019 PyObject * obj2 = 0 ;
24020 PyObject * obj3 = 0 ;
24021 char *kwnames[] = {
24022 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24023 };
24024
24025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24026 if (obj0) {
24027 {
24028 arg1 = (long)(SWIG_As_long(obj0));
24029 if (SWIG_arg_fail(1)) SWIG_fail;
24030 }
24031 }
24032 if (obj1) {
24033 {
24034 arg2 = (long)(SWIG_As_long(obj1));
24035 if (SWIG_arg_fail(2)) SWIG_fail;
24036 }
24037 }
24038 if (obj2) {
24039 {
24040 arg3 = (long)(SWIG_As_long(obj2));
24041 if (SWIG_arg_fail(3)) SWIG_fail;
24042 }
24043 }
24044 if (obj3) {
24045 {
24046 arg4 = (long)(SWIG_As_long(obj3));
24047 if (SWIG_arg_fail(4)) SWIG_fail;
24048 }
24049 }
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24053
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24065 PyObject *resultobj;
24066 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24067 PyObject * obj0 = 0 ;
24068 char *kwnames[] = {
24069 (char *) "self", NULL
24070 };
24071
24072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24074 if (SWIG_arg_fail(1)) SWIG_fail;
24075 {
24076 PyThreadState* __tstate = wxPyBeginAllowThreads();
24077 delete arg1;
24078
24079 wxPyEndAllowThreads(__tstate);
24080 if (PyErr_Occurred()) SWIG_fail;
24081 }
24082 Py_INCREF(Py_None); resultobj = Py_None;
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj;
24091 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24092 wxTimeSpan *arg2 = 0 ;
24093 wxTimeSpan *result;
24094 PyObject * obj0 = 0 ;
24095 PyObject * obj1 = 0 ;
24096 char *kwnames[] = {
24097 (char *) "self",(char *) "diff", NULL
24098 };
24099
24100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24102 if (SWIG_arg_fail(1)) SWIG_fail;
24103 {
24104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24105 if (SWIG_arg_fail(2)) SWIG_fail;
24106 if (arg2 == NULL) {
24107 SWIG_null_ref("wxTimeSpan");
24108 }
24109 if (SWIG_arg_fail(2)) SWIG_fail;
24110 }
24111 {
24112 PyThreadState* __tstate = wxPyBeginAllowThreads();
24113 {
24114 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24115 result = (wxTimeSpan *) &_result_ref;
24116 }
24117
24118 wxPyEndAllowThreads(__tstate);
24119 if (PyErr_Occurred()) SWIG_fail;
24120 }
24121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24122 return resultobj;
24123 fail:
24124 return NULL;
24125 }
24126
24127
24128 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24129 PyObject *resultobj;
24130 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24131 wxTimeSpan *arg2 = 0 ;
24132 wxTimeSpan *result;
24133 PyObject * obj0 = 0 ;
24134 PyObject * obj1 = 0 ;
24135 char *kwnames[] = {
24136 (char *) "self",(char *) "diff", NULL
24137 };
24138
24139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24141 if (SWIG_arg_fail(1)) SWIG_fail;
24142 {
24143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24144 if (SWIG_arg_fail(2)) SWIG_fail;
24145 if (arg2 == NULL) {
24146 SWIG_null_ref("wxTimeSpan");
24147 }
24148 if (SWIG_arg_fail(2)) SWIG_fail;
24149 }
24150 {
24151 PyThreadState* __tstate = wxPyBeginAllowThreads();
24152 {
24153 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24154 result = (wxTimeSpan *) &_result_ref;
24155 }
24156
24157 wxPyEndAllowThreads(__tstate);
24158 if (PyErr_Occurred()) SWIG_fail;
24159 }
24160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24161 return resultobj;
24162 fail:
24163 return NULL;
24164 }
24165
24166
24167 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24168 PyObject *resultobj;
24169 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24170 int arg2 ;
24171 wxTimeSpan *result;
24172 PyObject * obj0 = 0 ;
24173 PyObject * obj1 = 0 ;
24174 char *kwnames[] = {
24175 (char *) "self",(char *) "n", NULL
24176 };
24177
24178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24180 if (SWIG_arg_fail(1)) SWIG_fail;
24181 {
24182 arg2 = (int)(SWIG_As_int(obj1));
24183 if (SWIG_arg_fail(2)) SWIG_fail;
24184 }
24185 {
24186 PyThreadState* __tstate = wxPyBeginAllowThreads();
24187 {
24188 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24189 result = (wxTimeSpan *) &_result_ref;
24190 }
24191
24192 wxPyEndAllowThreads(__tstate);
24193 if (PyErr_Occurred()) SWIG_fail;
24194 }
24195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24196 return resultobj;
24197 fail:
24198 return NULL;
24199 }
24200
24201
24202 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24203 PyObject *resultobj;
24204 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24205 wxTimeSpan *result;
24206 PyObject * obj0 = 0 ;
24207 char *kwnames[] = {
24208 (char *) "self", NULL
24209 };
24210
24211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24213 if (SWIG_arg_fail(1)) SWIG_fail;
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 {
24217 wxTimeSpan &_result_ref = (arg1)->Neg();
24218 result = (wxTimeSpan *) &_result_ref;
24219 }
24220
24221 wxPyEndAllowThreads(__tstate);
24222 if (PyErr_Occurred()) SWIG_fail;
24223 }
24224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24225 return resultobj;
24226 fail:
24227 return NULL;
24228 }
24229
24230
24231 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24232 PyObject *resultobj;
24233 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24234 wxTimeSpan result;
24235 PyObject * obj0 = 0 ;
24236 char *kwnames[] = {
24237 (char *) "self", NULL
24238 };
24239
24240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24242 if (SWIG_arg_fail(1)) SWIG_fail;
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 result = ((wxTimeSpan const *)arg1)->Abs();
24246
24247 wxPyEndAllowThreads(__tstate);
24248 if (PyErr_Occurred()) SWIG_fail;
24249 }
24250 {
24251 wxTimeSpan * resultptr;
24252 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24253 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24254 }
24255 return resultobj;
24256 fail:
24257 return NULL;
24258 }
24259
24260
24261 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24262 PyObject *resultobj;
24263 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24264 wxTimeSpan *arg2 = 0 ;
24265 wxTimeSpan *result;
24266 PyObject * obj0 = 0 ;
24267 PyObject * obj1 = 0 ;
24268 char *kwnames[] = {
24269 (char *) "self",(char *) "diff", NULL
24270 };
24271
24272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24274 if (SWIG_arg_fail(1)) SWIG_fail;
24275 {
24276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24277 if (SWIG_arg_fail(2)) SWIG_fail;
24278 if (arg2 == NULL) {
24279 SWIG_null_ref("wxTimeSpan");
24280 }
24281 if (SWIG_arg_fail(2)) SWIG_fail;
24282 }
24283 {
24284 PyThreadState* __tstate = wxPyBeginAllowThreads();
24285 {
24286 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24287 result = (wxTimeSpan *) &_result_ref;
24288 }
24289
24290 wxPyEndAllowThreads(__tstate);
24291 if (PyErr_Occurred()) SWIG_fail;
24292 }
24293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24294 return resultobj;
24295 fail:
24296 return NULL;
24297 }
24298
24299
24300 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24301 PyObject *resultobj;
24302 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24303 wxTimeSpan *arg2 = 0 ;
24304 wxTimeSpan *result;
24305 PyObject * obj0 = 0 ;
24306 PyObject * obj1 = 0 ;
24307 char *kwnames[] = {
24308 (char *) "self",(char *) "diff", NULL
24309 };
24310
24311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24313 if (SWIG_arg_fail(1)) SWIG_fail;
24314 {
24315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24316 if (SWIG_arg_fail(2)) SWIG_fail;
24317 if (arg2 == NULL) {
24318 SWIG_null_ref("wxTimeSpan");
24319 }
24320 if (SWIG_arg_fail(2)) SWIG_fail;
24321 }
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 {
24325 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24326 result = (wxTimeSpan *) &_result_ref;
24327 }
24328
24329 wxPyEndAllowThreads(__tstate);
24330 if (PyErr_Occurred()) SWIG_fail;
24331 }
24332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24340 PyObject *resultobj;
24341 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24342 int arg2 ;
24343 wxTimeSpan *result;
24344 PyObject * obj0 = 0 ;
24345 PyObject * obj1 = 0 ;
24346 char *kwnames[] = {
24347 (char *) "self",(char *) "n", NULL
24348 };
24349
24350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24352 if (SWIG_arg_fail(1)) SWIG_fail;
24353 {
24354 arg2 = (int)(SWIG_As_int(obj1));
24355 if (SWIG_arg_fail(2)) SWIG_fail;
24356 }
24357 {
24358 PyThreadState* __tstate = wxPyBeginAllowThreads();
24359 {
24360 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24361 result = (wxTimeSpan *) &_result_ref;
24362 }
24363
24364 wxPyEndAllowThreads(__tstate);
24365 if (PyErr_Occurred()) SWIG_fail;
24366 }
24367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24375 PyObject *resultobj;
24376 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24377 wxTimeSpan *result;
24378 PyObject * obj0 = 0 ;
24379 char *kwnames[] = {
24380 (char *) "self", NULL
24381 };
24382
24383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24385 if (SWIG_arg_fail(1)) SWIG_fail;
24386 {
24387 PyThreadState* __tstate = wxPyBeginAllowThreads();
24388 {
24389 wxTimeSpan &_result_ref = (arg1)->operator -();
24390 result = (wxTimeSpan *) &_result_ref;
24391 }
24392
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24404 PyObject *resultobj;
24405 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24406 wxTimeSpan *arg2 = 0 ;
24407 wxTimeSpan result;
24408 PyObject * obj0 = 0 ;
24409 PyObject * obj1 = 0 ;
24410 char *kwnames[] = {
24411 (char *) "self",(char *) "other", NULL
24412 };
24413
24414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24416 if (SWIG_arg_fail(1)) SWIG_fail;
24417 {
24418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24419 if (SWIG_arg_fail(2)) SWIG_fail;
24420 if (arg2 == NULL) {
24421 SWIG_null_ref("wxTimeSpan");
24422 }
24423 if (SWIG_arg_fail(2)) SWIG_fail;
24424 }
24425 {
24426 PyThreadState* __tstate = wxPyBeginAllowThreads();
24427 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24428
24429 wxPyEndAllowThreads(__tstate);
24430 if (PyErr_Occurred()) SWIG_fail;
24431 }
24432 {
24433 wxTimeSpan * resultptr;
24434 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24436 }
24437 return resultobj;
24438 fail:
24439 return NULL;
24440 }
24441
24442
24443 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj;
24445 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24446 wxTimeSpan *arg2 = 0 ;
24447 wxTimeSpan result;
24448 PyObject * obj0 = 0 ;
24449 PyObject * obj1 = 0 ;
24450 char *kwnames[] = {
24451 (char *) "self",(char *) "other", NULL
24452 };
24453
24454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24456 if (SWIG_arg_fail(1)) SWIG_fail;
24457 {
24458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24459 if (SWIG_arg_fail(2)) SWIG_fail;
24460 if (arg2 == NULL) {
24461 SWIG_null_ref("wxTimeSpan");
24462 }
24463 if (SWIG_arg_fail(2)) SWIG_fail;
24464 }
24465 {
24466 PyThreadState* __tstate = wxPyBeginAllowThreads();
24467 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24468
24469 wxPyEndAllowThreads(__tstate);
24470 if (PyErr_Occurred()) SWIG_fail;
24471 }
24472 {
24473 wxTimeSpan * resultptr;
24474 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24475 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24476 }
24477 return resultobj;
24478 fail:
24479 return NULL;
24480 }
24481
24482
24483 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24484 PyObject *resultobj;
24485 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24486 int arg2 ;
24487 wxTimeSpan result;
24488 PyObject * obj0 = 0 ;
24489 PyObject * obj1 = 0 ;
24490 char *kwnames[] = {
24491 (char *) "self",(char *) "n", NULL
24492 };
24493
24494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24496 if (SWIG_arg_fail(1)) SWIG_fail;
24497 {
24498 arg2 = (int)(SWIG_As_int(obj1));
24499 if (SWIG_arg_fail(2)) SWIG_fail;
24500 }
24501 {
24502 PyThreadState* __tstate = wxPyBeginAllowThreads();
24503 result = wxTimeSpan___mul__(arg1,arg2);
24504
24505 wxPyEndAllowThreads(__tstate);
24506 if (PyErr_Occurred()) SWIG_fail;
24507 }
24508 {
24509 wxTimeSpan * resultptr;
24510 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24511 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24512 }
24513 return resultobj;
24514 fail:
24515 return NULL;
24516 }
24517
24518
24519 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24520 PyObject *resultobj;
24521 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24522 int arg2 ;
24523 wxTimeSpan result;
24524 PyObject * obj0 = 0 ;
24525 PyObject * obj1 = 0 ;
24526 char *kwnames[] = {
24527 (char *) "self",(char *) "n", NULL
24528 };
24529
24530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24532 if (SWIG_arg_fail(1)) SWIG_fail;
24533 {
24534 arg2 = (int)(SWIG_As_int(obj1));
24535 if (SWIG_arg_fail(2)) SWIG_fail;
24536 }
24537 {
24538 PyThreadState* __tstate = wxPyBeginAllowThreads();
24539 result = wxTimeSpan___rmul__(arg1,arg2);
24540
24541 wxPyEndAllowThreads(__tstate);
24542 if (PyErr_Occurred()) SWIG_fail;
24543 }
24544 {
24545 wxTimeSpan * resultptr;
24546 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24548 }
24549 return resultobj;
24550 fail:
24551 return NULL;
24552 }
24553
24554
24555 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24556 PyObject *resultobj;
24557 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24558 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24559 bool result;
24560 PyObject * obj0 = 0 ;
24561 PyObject * obj1 = 0 ;
24562 char *kwnames[] = {
24563 (char *) "self",(char *) "other", NULL
24564 };
24565
24566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24568 if (SWIG_arg_fail(1)) SWIG_fail;
24569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24570 if (SWIG_arg_fail(2)) SWIG_fail;
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24574
24575 wxPyEndAllowThreads(__tstate);
24576 if (PyErr_Occurred()) SWIG_fail;
24577 }
24578 {
24579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24580 }
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj;
24589 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24590 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24591 bool result;
24592 PyObject * obj0 = 0 ;
24593 PyObject * obj1 = 0 ;
24594 char *kwnames[] = {
24595 (char *) "self",(char *) "other", NULL
24596 };
24597
24598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24600 if (SWIG_arg_fail(1)) SWIG_fail;
24601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24602 if (SWIG_arg_fail(2)) SWIG_fail;
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24606
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 {
24611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24612 }
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24620 PyObject *resultobj;
24621 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24622 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24623 bool result;
24624 PyObject * obj0 = 0 ;
24625 PyObject * obj1 = 0 ;
24626 char *kwnames[] = {
24627 (char *) "self",(char *) "other", NULL
24628 };
24629
24630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24632 if (SWIG_arg_fail(1)) SWIG_fail;
24633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24634 if (SWIG_arg_fail(2)) SWIG_fail;
24635 {
24636 PyThreadState* __tstate = wxPyBeginAllowThreads();
24637 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24638
24639 wxPyEndAllowThreads(__tstate);
24640 if (PyErr_Occurred()) SWIG_fail;
24641 }
24642 {
24643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24644 }
24645 return resultobj;
24646 fail:
24647 return NULL;
24648 }
24649
24650
24651 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24652 PyObject *resultobj;
24653 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24654 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24655 bool result;
24656 PyObject * obj0 = 0 ;
24657 PyObject * obj1 = 0 ;
24658 char *kwnames[] = {
24659 (char *) "self",(char *) "other", NULL
24660 };
24661
24662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24664 if (SWIG_arg_fail(1)) SWIG_fail;
24665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24666 if (SWIG_arg_fail(2)) SWIG_fail;
24667 {
24668 PyThreadState* __tstate = wxPyBeginAllowThreads();
24669 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24670
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 {
24675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24676 }
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj;
24685 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24686 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24687 bool result;
24688 PyObject * obj0 = 0 ;
24689 PyObject * obj1 = 0 ;
24690 char *kwnames[] = {
24691 (char *) "self",(char *) "other", NULL
24692 };
24693
24694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24696 if (SWIG_arg_fail(1)) SWIG_fail;
24697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24698 if (SWIG_arg_fail(2)) SWIG_fail;
24699 {
24700 PyThreadState* __tstate = wxPyBeginAllowThreads();
24701 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24702
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 {
24707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24708 }
24709 return resultobj;
24710 fail:
24711 return NULL;
24712 }
24713
24714
24715 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24716 PyObject *resultobj;
24717 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24718 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24719 bool result;
24720 PyObject * obj0 = 0 ;
24721 PyObject * obj1 = 0 ;
24722 char *kwnames[] = {
24723 (char *) "self",(char *) "other", NULL
24724 };
24725
24726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24728 if (SWIG_arg_fail(1)) SWIG_fail;
24729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24730 if (SWIG_arg_fail(2)) SWIG_fail;
24731 {
24732 PyThreadState* __tstate = wxPyBeginAllowThreads();
24733 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24734
24735 wxPyEndAllowThreads(__tstate);
24736 if (PyErr_Occurred()) SWIG_fail;
24737 }
24738 {
24739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24740 }
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj;
24749 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24750 bool result;
24751 PyObject * obj0 = 0 ;
24752 char *kwnames[] = {
24753 (char *) "self", NULL
24754 };
24755
24756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24758 if (SWIG_arg_fail(1)) SWIG_fail;
24759 {
24760 PyThreadState* __tstate = wxPyBeginAllowThreads();
24761 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24762
24763 wxPyEndAllowThreads(__tstate);
24764 if (PyErr_Occurred()) SWIG_fail;
24765 }
24766 {
24767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24768 }
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj;
24777 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24778 bool result;
24779 PyObject * obj0 = 0 ;
24780 char *kwnames[] = {
24781 (char *) "self", NULL
24782 };
24783
24784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24786 if (SWIG_arg_fail(1)) SWIG_fail;
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24796 }
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24804 PyObject *resultobj;
24805 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24806 bool result;
24807 PyObject * obj0 = 0 ;
24808 char *kwnames[] = {
24809 (char *) "self", NULL
24810 };
24811
24812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24814 if (SWIG_arg_fail(1)) SWIG_fail;
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 {
24823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24824 }
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj;
24833 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24834 wxTimeSpan *arg2 = 0 ;
24835 bool result;
24836 PyObject * obj0 = 0 ;
24837 PyObject * obj1 = 0 ;
24838 char *kwnames[] = {
24839 (char *) "self",(char *) "ts", NULL
24840 };
24841
24842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24844 if (SWIG_arg_fail(1)) SWIG_fail;
24845 {
24846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24847 if (SWIG_arg_fail(2)) SWIG_fail;
24848 if (arg2 == NULL) {
24849 SWIG_null_ref("wxTimeSpan");
24850 }
24851 if (SWIG_arg_fail(2)) SWIG_fail;
24852 }
24853 {
24854 PyThreadState* __tstate = wxPyBeginAllowThreads();
24855 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24856
24857 wxPyEndAllowThreads(__tstate);
24858 if (PyErr_Occurred()) SWIG_fail;
24859 }
24860 {
24861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24862 }
24863 return resultobj;
24864 fail:
24865 return NULL;
24866 }
24867
24868
24869 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24870 PyObject *resultobj;
24871 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24872 wxTimeSpan *arg2 = 0 ;
24873 bool result;
24874 PyObject * obj0 = 0 ;
24875 PyObject * obj1 = 0 ;
24876 char *kwnames[] = {
24877 (char *) "self",(char *) "ts", NULL
24878 };
24879
24880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24882 if (SWIG_arg_fail(1)) SWIG_fail;
24883 {
24884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24885 if (SWIG_arg_fail(2)) SWIG_fail;
24886 if (arg2 == NULL) {
24887 SWIG_null_ref("wxTimeSpan");
24888 }
24889 if (SWIG_arg_fail(2)) SWIG_fail;
24890 }
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24894
24895 wxPyEndAllowThreads(__tstate);
24896 if (PyErr_Occurred()) SWIG_fail;
24897 }
24898 {
24899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24900 }
24901 return resultobj;
24902 fail:
24903 return NULL;
24904 }
24905
24906
24907 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24908 PyObject *resultobj;
24909 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24910 wxTimeSpan *arg2 = 0 ;
24911 bool result;
24912 PyObject * obj0 = 0 ;
24913 PyObject * obj1 = 0 ;
24914 char *kwnames[] = {
24915 (char *) "self",(char *) "t", NULL
24916 };
24917
24918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24920 if (SWIG_arg_fail(1)) SWIG_fail;
24921 {
24922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24923 if (SWIG_arg_fail(2)) SWIG_fail;
24924 if (arg2 == NULL) {
24925 SWIG_null_ref("wxTimeSpan");
24926 }
24927 if (SWIG_arg_fail(2)) SWIG_fail;
24928 }
24929 {
24930 PyThreadState* __tstate = wxPyBeginAllowThreads();
24931 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24932
24933 wxPyEndAllowThreads(__tstate);
24934 if (PyErr_Occurred()) SWIG_fail;
24935 }
24936 {
24937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24938 }
24939 return resultobj;
24940 fail:
24941 return NULL;
24942 }
24943
24944
24945 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24946 PyObject *resultobj;
24947 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24948 int result;
24949 PyObject * obj0 = 0 ;
24950 char *kwnames[] = {
24951 (char *) "self", NULL
24952 };
24953
24954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24956 if (SWIG_arg_fail(1)) SWIG_fail;
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24960
24961 wxPyEndAllowThreads(__tstate);
24962 if (PyErr_Occurred()) SWIG_fail;
24963 }
24964 {
24965 resultobj = SWIG_From_int((int)(result));
24966 }
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24974 PyObject *resultobj;
24975 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24976 int result;
24977 PyObject * obj0 = 0 ;
24978 char *kwnames[] = {
24979 (char *) "self", NULL
24980 };
24981
24982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24984 if (SWIG_arg_fail(1)) SWIG_fail;
24985 {
24986 PyThreadState* __tstate = wxPyBeginAllowThreads();
24987 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24988
24989 wxPyEndAllowThreads(__tstate);
24990 if (PyErr_Occurred()) SWIG_fail;
24991 }
24992 {
24993 resultobj = SWIG_From_int((int)(result));
24994 }
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj;
25003 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25004 int result;
25005 PyObject * obj0 = 0 ;
25006 char *kwnames[] = {
25007 (char *) "self", NULL
25008 };
25009
25010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25012 if (SWIG_arg_fail(1)) SWIG_fail;
25013 {
25014 PyThreadState* __tstate = wxPyBeginAllowThreads();
25015 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25016
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 {
25021 resultobj = SWIG_From_int((int)(result));
25022 }
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25030 PyObject *resultobj;
25031 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25032 int result;
25033 PyObject * obj0 = 0 ;
25034 char *kwnames[] = {
25035 (char *) "self", NULL
25036 };
25037
25038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25040 if (SWIG_arg_fail(1)) SWIG_fail;
25041 {
25042 PyThreadState* __tstate = wxPyBeginAllowThreads();
25043 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25044
25045 wxPyEndAllowThreads(__tstate);
25046 if (PyErr_Occurred()) SWIG_fail;
25047 }
25048 {
25049 resultobj = SWIG_From_int((int)(result));
25050 }
25051 return resultobj;
25052 fail:
25053 return NULL;
25054 }
25055
25056
25057 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25058 PyObject *resultobj;
25059 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25060 wxLongLong result;
25061 PyObject * obj0 = 0 ;
25062 char *kwnames[] = {
25063 (char *) "self", NULL
25064 };
25065
25066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25068 if (SWIG_arg_fail(1)) SWIG_fail;
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25072
25073 wxPyEndAllowThreads(__tstate);
25074 if (PyErr_Occurred()) SWIG_fail;
25075 }
25076 {
25077 PyObject *hi, *lo, *shifter, *shifted;
25078 hi = PyLong_FromLong( (&result)->GetHi() );
25079 lo = PyLong_FromLong( (&result)->GetLo() );
25080 shifter = PyLong_FromLong(32);
25081 shifted = PyNumber_Lshift(hi, shifter);
25082 resultobj = PyNumber_Or(shifted, lo);
25083 Py_DECREF(hi);
25084 Py_DECREF(lo);
25085 Py_DECREF(shifter);
25086 Py_DECREF(shifted);
25087 }
25088 return resultobj;
25089 fail:
25090 return NULL;
25091 }
25092
25093
25094 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25095 PyObject *resultobj;
25096 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25097 wxLongLong result;
25098 PyObject * obj0 = 0 ;
25099 char *kwnames[] = {
25100 (char *) "self", NULL
25101 };
25102
25103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25105 if (SWIG_arg_fail(1)) SWIG_fail;
25106 {
25107 PyThreadState* __tstate = wxPyBeginAllowThreads();
25108 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25109
25110 wxPyEndAllowThreads(__tstate);
25111 if (PyErr_Occurred()) SWIG_fail;
25112 }
25113 {
25114 PyObject *hi, *lo, *shifter, *shifted;
25115 hi = PyLong_FromLong( (&result)->GetHi() );
25116 lo = PyLong_FromLong( (&result)->GetLo() );
25117 shifter = PyLong_FromLong(32);
25118 shifted = PyNumber_Lshift(hi, shifter);
25119 resultobj = PyNumber_Or(shifted, lo);
25120 Py_DECREF(hi);
25121 Py_DECREF(lo);
25122 Py_DECREF(shifter);
25123 Py_DECREF(shifted);
25124 }
25125 return resultobj;
25126 fail:
25127 return NULL;
25128 }
25129
25130
25131 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25132 PyObject *resultobj;
25133 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25134 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25135 wxString *arg2 = (wxString *) &arg2_defvalue ;
25136 wxString result;
25137 bool temp2 = false ;
25138 PyObject * obj0 = 0 ;
25139 PyObject * obj1 = 0 ;
25140 char *kwnames[] = {
25141 (char *) "self",(char *) "format", NULL
25142 };
25143
25144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25146 if (SWIG_arg_fail(1)) SWIG_fail;
25147 if (obj1) {
25148 {
25149 arg2 = wxString_in_helper(obj1);
25150 if (arg2 == NULL) SWIG_fail;
25151 temp2 = true;
25152 }
25153 }
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 #if wxUSE_UNICODE
25163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25164 #else
25165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25166 #endif
25167 }
25168 {
25169 if (temp2)
25170 delete arg2;
25171 }
25172 return resultobj;
25173 fail:
25174 {
25175 if (temp2)
25176 delete arg2;
25177 }
25178 return NULL;
25179 }
25180
25181
25182 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25183 PyObject *obj;
25184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25185 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25186 Py_INCREF(obj);
25187 return Py_BuildValue((char *)"");
25188 }
25189 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25190 PyObject *resultobj;
25191 int arg1 = (int) 0 ;
25192 int arg2 = (int) 0 ;
25193 int arg3 = (int) 0 ;
25194 int arg4 = (int) 0 ;
25195 wxDateSpan *result;
25196 PyObject * obj0 = 0 ;
25197 PyObject * obj1 = 0 ;
25198 PyObject * obj2 = 0 ;
25199 PyObject * obj3 = 0 ;
25200 char *kwnames[] = {
25201 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25202 };
25203
25204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25205 if (obj0) {
25206 {
25207 arg1 = (int)(SWIG_As_int(obj0));
25208 if (SWIG_arg_fail(1)) SWIG_fail;
25209 }
25210 }
25211 if (obj1) {
25212 {
25213 arg2 = (int)(SWIG_As_int(obj1));
25214 if (SWIG_arg_fail(2)) SWIG_fail;
25215 }
25216 }
25217 if (obj2) {
25218 {
25219 arg3 = (int)(SWIG_As_int(obj2));
25220 if (SWIG_arg_fail(3)) SWIG_fail;
25221 }
25222 }
25223 if (obj3) {
25224 {
25225 arg4 = (int)(SWIG_As_int(obj3));
25226 if (SWIG_arg_fail(4)) SWIG_fail;
25227 }
25228 }
25229 {
25230 PyThreadState* __tstate = wxPyBeginAllowThreads();
25231 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25232
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25237 return resultobj;
25238 fail:
25239 return NULL;
25240 }
25241
25242
25243 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25244 PyObject *resultobj;
25245 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25246 PyObject * obj0 = 0 ;
25247 char *kwnames[] = {
25248 (char *) "self", NULL
25249 };
25250
25251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25253 if (SWIG_arg_fail(1)) SWIG_fail;
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 delete arg1;
25257
25258 wxPyEndAllowThreads(__tstate);
25259 if (PyErr_Occurred()) SWIG_fail;
25260 }
25261 Py_INCREF(Py_None); resultobj = Py_None;
25262 return resultobj;
25263 fail:
25264 return NULL;
25265 }
25266
25267
25268 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25269 PyObject *resultobj;
25270 int arg1 ;
25271 wxDateSpan result;
25272 PyObject * obj0 = 0 ;
25273 char *kwnames[] = {
25274 (char *) "days", NULL
25275 };
25276
25277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25278 {
25279 arg1 = (int)(SWIG_As_int(obj0));
25280 if (SWIG_arg_fail(1)) SWIG_fail;
25281 }
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 result = wxDateSpan::Days(arg1);
25285
25286 wxPyEndAllowThreads(__tstate);
25287 if (PyErr_Occurred()) SWIG_fail;
25288 }
25289 {
25290 wxDateSpan * resultptr;
25291 resultptr = new wxDateSpan((wxDateSpan &)(result));
25292 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25293 }
25294 return resultobj;
25295 fail:
25296 return NULL;
25297 }
25298
25299
25300 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25301 PyObject *resultobj;
25302 wxDateSpan result;
25303 char *kwnames[] = {
25304 NULL
25305 };
25306
25307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25308 {
25309 PyThreadState* __tstate = wxPyBeginAllowThreads();
25310 result = wxDateSpan::Day();
25311
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 {
25316 wxDateSpan * resultptr;
25317 resultptr = new wxDateSpan((wxDateSpan &)(result));
25318 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25319 }
25320 return resultobj;
25321 fail:
25322 return NULL;
25323 }
25324
25325
25326 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25327 PyObject *resultobj;
25328 int arg1 ;
25329 wxDateSpan result;
25330 PyObject * obj0 = 0 ;
25331 char *kwnames[] = {
25332 (char *) "weeks", NULL
25333 };
25334
25335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25336 {
25337 arg1 = (int)(SWIG_As_int(obj0));
25338 if (SWIG_arg_fail(1)) SWIG_fail;
25339 }
25340 {
25341 PyThreadState* __tstate = wxPyBeginAllowThreads();
25342 result = wxDateSpan::Weeks(arg1);
25343
25344 wxPyEndAllowThreads(__tstate);
25345 if (PyErr_Occurred()) SWIG_fail;
25346 }
25347 {
25348 wxDateSpan * resultptr;
25349 resultptr = new wxDateSpan((wxDateSpan &)(result));
25350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25351 }
25352 return resultobj;
25353 fail:
25354 return NULL;
25355 }
25356
25357
25358 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25359 PyObject *resultobj;
25360 wxDateSpan result;
25361 char *kwnames[] = {
25362 NULL
25363 };
25364
25365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25366 {
25367 PyThreadState* __tstate = wxPyBeginAllowThreads();
25368 result = wxDateSpan::Week();
25369
25370 wxPyEndAllowThreads(__tstate);
25371 if (PyErr_Occurred()) SWIG_fail;
25372 }
25373 {
25374 wxDateSpan * resultptr;
25375 resultptr = new wxDateSpan((wxDateSpan &)(result));
25376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25377 }
25378 return resultobj;
25379 fail:
25380 return NULL;
25381 }
25382
25383
25384 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25385 PyObject *resultobj;
25386 int arg1 ;
25387 wxDateSpan result;
25388 PyObject * obj0 = 0 ;
25389 char *kwnames[] = {
25390 (char *) "mon", NULL
25391 };
25392
25393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25394 {
25395 arg1 = (int)(SWIG_As_int(obj0));
25396 if (SWIG_arg_fail(1)) SWIG_fail;
25397 }
25398 {
25399 PyThreadState* __tstate = wxPyBeginAllowThreads();
25400 result = wxDateSpan::Months(arg1);
25401
25402 wxPyEndAllowThreads(__tstate);
25403 if (PyErr_Occurred()) SWIG_fail;
25404 }
25405 {
25406 wxDateSpan * resultptr;
25407 resultptr = new wxDateSpan((wxDateSpan &)(result));
25408 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25409 }
25410 return resultobj;
25411 fail:
25412 return NULL;
25413 }
25414
25415
25416 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25417 PyObject *resultobj;
25418 wxDateSpan result;
25419 char *kwnames[] = {
25420 NULL
25421 };
25422
25423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25424 {
25425 PyThreadState* __tstate = wxPyBeginAllowThreads();
25426 result = wxDateSpan::Month();
25427
25428 wxPyEndAllowThreads(__tstate);
25429 if (PyErr_Occurred()) SWIG_fail;
25430 }
25431 {
25432 wxDateSpan * resultptr;
25433 resultptr = new wxDateSpan((wxDateSpan &)(result));
25434 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25435 }
25436 return resultobj;
25437 fail:
25438 return NULL;
25439 }
25440
25441
25442 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25443 PyObject *resultobj;
25444 int arg1 ;
25445 wxDateSpan result;
25446 PyObject * obj0 = 0 ;
25447 char *kwnames[] = {
25448 (char *) "years", NULL
25449 };
25450
25451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25452 {
25453 arg1 = (int)(SWIG_As_int(obj0));
25454 if (SWIG_arg_fail(1)) SWIG_fail;
25455 }
25456 {
25457 PyThreadState* __tstate = wxPyBeginAllowThreads();
25458 result = wxDateSpan::Years(arg1);
25459
25460 wxPyEndAllowThreads(__tstate);
25461 if (PyErr_Occurred()) SWIG_fail;
25462 }
25463 {
25464 wxDateSpan * resultptr;
25465 resultptr = new wxDateSpan((wxDateSpan &)(result));
25466 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25467 }
25468 return resultobj;
25469 fail:
25470 return NULL;
25471 }
25472
25473
25474 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25475 PyObject *resultobj;
25476 wxDateSpan result;
25477 char *kwnames[] = {
25478 NULL
25479 };
25480
25481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25482 {
25483 PyThreadState* __tstate = wxPyBeginAllowThreads();
25484 result = wxDateSpan::Year();
25485
25486 wxPyEndAllowThreads(__tstate);
25487 if (PyErr_Occurred()) SWIG_fail;
25488 }
25489 {
25490 wxDateSpan * resultptr;
25491 resultptr = new wxDateSpan((wxDateSpan &)(result));
25492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25493 }
25494 return resultobj;
25495 fail:
25496 return NULL;
25497 }
25498
25499
25500 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25501 PyObject *resultobj;
25502 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25503 int arg2 ;
25504 wxDateSpan *result;
25505 PyObject * obj0 = 0 ;
25506 PyObject * obj1 = 0 ;
25507 char *kwnames[] = {
25508 (char *) "self",(char *) "n", NULL
25509 };
25510
25511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25513 if (SWIG_arg_fail(1)) SWIG_fail;
25514 {
25515 arg2 = (int)(SWIG_As_int(obj1));
25516 if (SWIG_arg_fail(2)) SWIG_fail;
25517 }
25518 {
25519 PyThreadState* __tstate = wxPyBeginAllowThreads();
25520 {
25521 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25522 result = (wxDateSpan *) &_result_ref;
25523 }
25524
25525 wxPyEndAllowThreads(__tstate);
25526 if (PyErr_Occurred()) SWIG_fail;
25527 }
25528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25529 return resultobj;
25530 fail:
25531 return NULL;
25532 }
25533
25534
25535 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25536 PyObject *resultobj;
25537 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25538 int arg2 ;
25539 wxDateSpan *result;
25540 PyObject * obj0 = 0 ;
25541 PyObject * obj1 = 0 ;
25542 char *kwnames[] = {
25543 (char *) "self",(char *) "n", NULL
25544 };
25545
25546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25548 if (SWIG_arg_fail(1)) SWIG_fail;
25549 {
25550 arg2 = (int)(SWIG_As_int(obj1));
25551 if (SWIG_arg_fail(2)) SWIG_fail;
25552 }
25553 {
25554 PyThreadState* __tstate = wxPyBeginAllowThreads();
25555 {
25556 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25557 result = (wxDateSpan *) &_result_ref;
25558 }
25559
25560 wxPyEndAllowThreads(__tstate);
25561 if (PyErr_Occurred()) SWIG_fail;
25562 }
25563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25564 return resultobj;
25565 fail:
25566 return NULL;
25567 }
25568
25569
25570 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25571 PyObject *resultobj;
25572 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25573 int arg2 ;
25574 wxDateSpan *result;
25575 PyObject * obj0 = 0 ;
25576 PyObject * obj1 = 0 ;
25577 char *kwnames[] = {
25578 (char *) "self",(char *) "n", NULL
25579 };
25580
25581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25583 if (SWIG_arg_fail(1)) SWIG_fail;
25584 {
25585 arg2 = (int)(SWIG_As_int(obj1));
25586 if (SWIG_arg_fail(2)) SWIG_fail;
25587 }
25588 {
25589 PyThreadState* __tstate = wxPyBeginAllowThreads();
25590 {
25591 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25592 result = (wxDateSpan *) &_result_ref;
25593 }
25594
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25606 PyObject *resultobj;
25607 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25608 int arg2 ;
25609 wxDateSpan *result;
25610 PyObject * obj0 = 0 ;
25611 PyObject * obj1 = 0 ;
25612 char *kwnames[] = {
25613 (char *) "self",(char *) "n", NULL
25614 };
25615
25616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25618 if (SWIG_arg_fail(1)) SWIG_fail;
25619 {
25620 arg2 = (int)(SWIG_As_int(obj1));
25621 if (SWIG_arg_fail(2)) SWIG_fail;
25622 }
25623 {
25624 PyThreadState* __tstate = wxPyBeginAllowThreads();
25625 {
25626 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25627 result = (wxDateSpan *) &_result_ref;
25628 }
25629
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25634 return resultobj;
25635 fail:
25636 return NULL;
25637 }
25638
25639
25640 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25641 PyObject *resultobj;
25642 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25643 int result;
25644 PyObject * obj0 = 0 ;
25645 char *kwnames[] = {
25646 (char *) "self", NULL
25647 };
25648
25649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25651 if (SWIG_arg_fail(1)) SWIG_fail;
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = (int)((wxDateSpan const *)arg1)->GetYears();
25655
25656 wxPyEndAllowThreads(__tstate);
25657 if (PyErr_Occurred()) SWIG_fail;
25658 }
25659 {
25660 resultobj = SWIG_From_int((int)(result));
25661 }
25662 return resultobj;
25663 fail:
25664 return NULL;
25665 }
25666
25667
25668 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25669 PyObject *resultobj;
25670 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25671 int result;
25672 PyObject * obj0 = 0 ;
25673 char *kwnames[] = {
25674 (char *) "self", NULL
25675 };
25676
25677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25679 if (SWIG_arg_fail(1)) SWIG_fail;
25680 {
25681 PyThreadState* __tstate = wxPyBeginAllowThreads();
25682 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25683
25684 wxPyEndAllowThreads(__tstate);
25685 if (PyErr_Occurred()) SWIG_fail;
25686 }
25687 {
25688 resultobj = SWIG_From_int((int)(result));
25689 }
25690 return resultobj;
25691 fail:
25692 return NULL;
25693 }
25694
25695
25696 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj;
25698 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25699 int result;
25700 PyObject * obj0 = 0 ;
25701 char *kwnames[] = {
25702 (char *) "self", NULL
25703 };
25704
25705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25707 if (SWIG_arg_fail(1)) SWIG_fail;
25708 {
25709 PyThreadState* __tstate = wxPyBeginAllowThreads();
25710 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25711
25712 wxPyEndAllowThreads(__tstate);
25713 if (PyErr_Occurred()) SWIG_fail;
25714 }
25715 {
25716 resultobj = SWIG_From_int((int)(result));
25717 }
25718 return resultobj;
25719 fail:
25720 return NULL;
25721 }
25722
25723
25724 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25725 PyObject *resultobj;
25726 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25727 int result;
25728 PyObject * obj0 = 0 ;
25729 char *kwnames[] = {
25730 (char *) "self", NULL
25731 };
25732
25733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25735 if (SWIG_arg_fail(1)) SWIG_fail;
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 result = (int)((wxDateSpan const *)arg1)->GetDays();
25739
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 {
25744 resultobj = SWIG_From_int((int)(result));
25745 }
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25753 PyObject *resultobj;
25754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25755 int result;
25756 PyObject * obj0 = 0 ;
25757 char *kwnames[] = {
25758 (char *) "self", NULL
25759 };
25760
25761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25763 if (SWIG_arg_fail(1)) SWIG_fail;
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25767
25768 wxPyEndAllowThreads(__tstate);
25769 if (PyErr_Occurred()) SWIG_fail;
25770 }
25771 {
25772 resultobj = SWIG_From_int((int)(result));
25773 }
25774 return resultobj;
25775 fail:
25776 return NULL;
25777 }
25778
25779
25780 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25781 PyObject *resultobj;
25782 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25783 wxDateSpan *arg2 = 0 ;
25784 wxDateSpan *result;
25785 PyObject * obj0 = 0 ;
25786 PyObject * obj1 = 0 ;
25787 char *kwnames[] = {
25788 (char *) "self",(char *) "other", NULL
25789 };
25790
25791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25793 if (SWIG_arg_fail(1)) SWIG_fail;
25794 {
25795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25796 if (SWIG_arg_fail(2)) SWIG_fail;
25797 if (arg2 == NULL) {
25798 SWIG_null_ref("wxDateSpan");
25799 }
25800 if (SWIG_arg_fail(2)) SWIG_fail;
25801 }
25802 {
25803 PyThreadState* __tstate = wxPyBeginAllowThreads();
25804 {
25805 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25806 result = (wxDateSpan *) &_result_ref;
25807 }
25808
25809 wxPyEndAllowThreads(__tstate);
25810 if (PyErr_Occurred()) SWIG_fail;
25811 }
25812 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25813 return resultobj;
25814 fail:
25815 return NULL;
25816 }
25817
25818
25819 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25820 PyObject *resultobj;
25821 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25822 wxDateSpan *arg2 = 0 ;
25823 wxDateSpan *result;
25824 PyObject * obj0 = 0 ;
25825 PyObject * obj1 = 0 ;
25826 char *kwnames[] = {
25827 (char *) "self",(char *) "other", NULL
25828 };
25829
25830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25832 if (SWIG_arg_fail(1)) SWIG_fail;
25833 {
25834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25835 if (SWIG_arg_fail(2)) SWIG_fail;
25836 if (arg2 == NULL) {
25837 SWIG_null_ref("wxDateSpan");
25838 }
25839 if (SWIG_arg_fail(2)) SWIG_fail;
25840 }
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 {
25844 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25845 result = (wxDateSpan *) &_result_ref;
25846 }
25847
25848 wxPyEndAllowThreads(__tstate);
25849 if (PyErr_Occurred()) SWIG_fail;
25850 }
25851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25852 return resultobj;
25853 fail:
25854 return NULL;
25855 }
25856
25857
25858 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25859 PyObject *resultobj;
25860 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25861 wxDateSpan *result;
25862 PyObject * obj0 = 0 ;
25863 char *kwnames[] = {
25864 (char *) "self", NULL
25865 };
25866
25867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25869 if (SWIG_arg_fail(1)) SWIG_fail;
25870 {
25871 PyThreadState* __tstate = wxPyBeginAllowThreads();
25872 {
25873 wxDateSpan &_result_ref = (arg1)->Neg();
25874 result = (wxDateSpan *) &_result_ref;
25875 }
25876
25877 wxPyEndAllowThreads(__tstate);
25878 if (PyErr_Occurred()) SWIG_fail;
25879 }
25880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25881 return resultobj;
25882 fail:
25883 return NULL;
25884 }
25885
25886
25887 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25888 PyObject *resultobj;
25889 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25890 int arg2 ;
25891 wxDateSpan *result;
25892 PyObject * obj0 = 0 ;
25893 PyObject * obj1 = 0 ;
25894 char *kwnames[] = {
25895 (char *) "self",(char *) "factor", NULL
25896 };
25897
25898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25900 if (SWIG_arg_fail(1)) SWIG_fail;
25901 {
25902 arg2 = (int)(SWIG_As_int(obj1));
25903 if (SWIG_arg_fail(2)) SWIG_fail;
25904 }
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 {
25908 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25909 result = (wxDateSpan *) &_result_ref;
25910 }
25911
25912 wxPyEndAllowThreads(__tstate);
25913 if (PyErr_Occurred()) SWIG_fail;
25914 }
25915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25916 return resultobj;
25917 fail:
25918 return NULL;
25919 }
25920
25921
25922 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25923 PyObject *resultobj;
25924 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25925 wxDateSpan *arg2 = 0 ;
25926 wxDateSpan *result;
25927 PyObject * obj0 = 0 ;
25928 PyObject * obj1 = 0 ;
25929 char *kwnames[] = {
25930 (char *) "self",(char *) "other", NULL
25931 };
25932
25933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25935 if (SWIG_arg_fail(1)) SWIG_fail;
25936 {
25937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25938 if (SWIG_arg_fail(2)) SWIG_fail;
25939 if (arg2 == NULL) {
25940 SWIG_null_ref("wxDateSpan");
25941 }
25942 if (SWIG_arg_fail(2)) SWIG_fail;
25943 }
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 {
25947 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25948 result = (wxDateSpan *) &_result_ref;
25949 }
25950
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25955 return resultobj;
25956 fail:
25957 return NULL;
25958 }
25959
25960
25961 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25962 PyObject *resultobj;
25963 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25964 wxDateSpan *arg2 = 0 ;
25965 wxDateSpan *result;
25966 PyObject * obj0 = 0 ;
25967 PyObject * obj1 = 0 ;
25968 char *kwnames[] = {
25969 (char *) "self",(char *) "other", NULL
25970 };
25971
25972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25974 if (SWIG_arg_fail(1)) SWIG_fail;
25975 {
25976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25977 if (SWIG_arg_fail(2)) SWIG_fail;
25978 if (arg2 == NULL) {
25979 SWIG_null_ref("wxDateSpan");
25980 }
25981 if (SWIG_arg_fail(2)) SWIG_fail;
25982 }
25983 {
25984 PyThreadState* __tstate = wxPyBeginAllowThreads();
25985 {
25986 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25987 result = (wxDateSpan *) &_result_ref;
25988 }
25989
25990 wxPyEndAllowThreads(__tstate);
25991 if (PyErr_Occurred()) SWIG_fail;
25992 }
25993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25994 return resultobj;
25995 fail:
25996 return NULL;
25997 }
25998
25999
26000 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26001 PyObject *resultobj;
26002 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26003 wxDateSpan *result;
26004 PyObject * obj0 = 0 ;
26005 char *kwnames[] = {
26006 (char *) "self", NULL
26007 };
26008
26009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26011 if (SWIG_arg_fail(1)) SWIG_fail;
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 {
26015 wxDateSpan &_result_ref = (arg1)->operator -();
26016 result = (wxDateSpan *) &_result_ref;
26017 }
26018
26019 wxPyEndAllowThreads(__tstate);
26020 if (PyErr_Occurred()) SWIG_fail;
26021 }
26022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26030 PyObject *resultobj;
26031 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26032 int arg2 ;
26033 wxDateSpan *result;
26034 PyObject * obj0 = 0 ;
26035 PyObject * obj1 = 0 ;
26036 char *kwnames[] = {
26037 (char *) "self",(char *) "factor", NULL
26038 };
26039
26040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26042 if (SWIG_arg_fail(1)) SWIG_fail;
26043 {
26044 arg2 = (int)(SWIG_As_int(obj1));
26045 if (SWIG_arg_fail(2)) SWIG_fail;
26046 }
26047 {
26048 PyThreadState* __tstate = wxPyBeginAllowThreads();
26049 {
26050 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26051 result = (wxDateSpan *) &_result_ref;
26052 }
26053
26054 wxPyEndAllowThreads(__tstate);
26055 if (PyErr_Occurred()) SWIG_fail;
26056 }
26057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26058 return resultobj;
26059 fail:
26060 return NULL;
26061 }
26062
26063
26064 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26065 PyObject *resultobj;
26066 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26067 wxDateSpan *arg2 = 0 ;
26068 wxDateSpan result;
26069 PyObject * obj0 = 0 ;
26070 PyObject * obj1 = 0 ;
26071 char *kwnames[] = {
26072 (char *) "self",(char *) "other", NULL
26073 };
26074
26075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26077 if (SWIG_arg_fail(1)) SWIG_fail;
26078 {
26079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26080 if (SWIG_arg_fail(2)) SWIG_fail;
26081 if (arg2 == NULL) {
26082 SWIG_null_ref("wxDateSpan");
26083 }
26084 if (SWIG_arg_fail(2)) SWIG_fail;
26085 }
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26089
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 {
26094 wxDateSpan * resultptr;
26095 resultptr = new wxDateSpan((wxDateSpan &)(result));
26096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26097 }
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26105 PyObject *resultobj;
26106 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26107 wxDateSpan *arg2 = 0 ;
26108 wxDateSpan result;
26109 PyObject * obj0 = 0 ;
26110 PyObject * obj1 = 0 ;
26111 char *kwnames[] = {
26112 (char *) "self",(char *) "other", NULL
26113 };
26114
26115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26117 if (SWIG_arg_fail(1)) SWIG_fail;
26118 {
26119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26120 if (SWIG_arg_fail(2)) SWIG_fail;
26121 if (arg2 == NULL) {
26122 SWIG_null_ref("wxDateSpan");
26123 }
26124 if (SWIG_arg_fail(2)) SWIG_fail;
26125 }
26126 {
26127 PyThreadState* __tstate = wxPyBeginAllowThreads();
26128 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26129
26130 wxPyEndAllowThreads(__tstate);
26131 if (PyErr_Occurred()) SWIG_fail;
26132 }
26133 {
26134 wxDateSpan * resultptr;
26135 resultptr = new wxDateSpan((wxDateSpan &)(result));
26136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26137 }
26138 return resultobj;
26139 fail:
26140 return NULL;
26141 }
26142
26143
26144 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26145 PyObject *resultobj;
26146 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26147 int arg2 ;
26148 wxDateSpan result;
26149 PyObject * obj0 = 0 ;
26150 PyObject * obj1 = 0 ;
26151 char *kwnames[] = {
26152 (char *) "self",(char *) "n", NULL
26153 };
26154
26155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26157 if (SWIG_arg_fail(1)) SWIG_fail;
26158 {
26159 arg2 = (int)(SWIG_As_int(obj1));
26160 if (SWIG_arg_fail(2)) SWIG_fail;
26161 }
26162 {
26163 PyThreadState* __tstate = wxPyBeginAllowThreads();
26164 result = wxDateSpan___mul__(arg1,arg2);
26165
26166 wxPyEndAllowThreads(__tstate);
26167 if (PyErr_Occurred()) SWIG_fail;
26168 }
26169 {
26170 wxDateSpan * resultptr;
26171 resultptr = new wxDateSpan((wxDateSpan &)(result));
26172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26173 }
26174 return resultobj;
26175 fail:
26176 return NULL;
26177 }
26178
26179
26180 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26181 PyObject *resultobj;
26182 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26183 int arg2 ;
26184 wxDateSpan result;
26185 PyObject * obj0 = 0 ;
26186 PyObject * obj1 = 0 ;
26187 char *kwnames[] = {
26188 (char *) "self",(char *) "n", NULL
26189 };
26190
26191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26193 if (SWIG_arg_fail(1)) SWIG_fail;
26194 {
26195 arg2 = (int)(SWIG_As_int(obj1));
26196 if (SWIG_arg_fail(2)) SWIG_fail;
26197 }
26198 {
26199 PyThreadState* __tstate = wxPyBeginAllowThreads();
26200 result = wxDateSpan___rmul__(arg1,arg2);
26201
26202 wxPyEndAllowThreads(__tstate);
26203 if (PyErr_Occurred()) SWIG_fail;
26204 }
26205 {
26206 wxDateSpan * resultptr;
26207 resultptr = new wxDateSpan((wxDateSpan &)(result));
26208 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26209 }
26210 return resultobj;
26211 fail:
26212 return NULL;
26213 }
26214
26215
26216 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26217 PyObject *resultobj;
26218 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26219 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26220 bool result;
26221 PyObject * obj0 = 0 ;
26222 PyObject * obj1 = 0 ;
26223 char *kwnames[] = {
26224 (char *) "self",(char *) "other", NULL
26225 };
26226
26227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26229 if (SWIG_arg_fail(1)) SWIG_fail;
26230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26231 if (SWIG_arg_fail(2)) SWIG_fail;
26232 {
26233 PyThreadState* __tstate = wxPyBeginAllowThreads();
26234 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26235
26236 wxPyEndAllowThreads(__tstate);
26237 if (PyErr_Occurred()) SWIG_fail;
26238 }
26239 {
26240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26241 }
26242 return resultobj;
26243 fail:
26244 return NULL;
26245 }
26246
26247
26248 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26249 PyObject *resultobj;
26250 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26251 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26252 bool result;
26253 PyObject * obj0 = 0 ;
26254 PyObject * obj1 = 0 ;
26255 char *kwnames[] = {
26256 (char *) "self",(char *) "other", NULL
26257 };
26258
26259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26261 if (SWIG_arg_fail(1)) SWIG_fail;
26262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26263 if (SWIG_arg_fail(2)) SWIG_fail;
26264 {
26265 PyThreadState* __tstate = wxPyBeginAllowThreads();
26266 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26267
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 {
26272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26273 }
26274 return resultobj;
26275 fail:
26276 return NULL;
26277 }
26278
26279
26280 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26281 PyObject *obj;
26282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26283 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26284 Py_INCREF(obj);
26285 return Py_BuildValue((char *)"");
26286 }
26287 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26288 PyObject *resultobj;
26289 long result;
26290 char *kwnames[] = {
26291 NULL
26292 };
26293
26294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26295 {
26296 PyThreadState* __tstate = wxPyBeginAllowThreads();
26297 result = (long)wxGetLocalTime();
26298
26299 wxPyEndAllowThreads(__tstate);
26300 if (PyErr_Occurred()) SWIG_fail;
26301 }
26302 {
26303 resultobj = SWIG_From_long((long)(result));
26304 }
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26312 PyObject *resultobj;
26313 long result;
26314 char *kwnames[] = {
26315 NULL
26316 };
26317
26318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26319 {
26320 PyThreadState* __tstate = wxPyBeginAllowThreads();
26321 result = (long)wxGetUTCTime();
26322
26323 wxPyEndAllowThreads(__tstate);
26324 if (PyErr_Occurred()) SWIG_fail;
26325 }
26326 {
26327 resultobj = SWIG_From_long((long)(result));
26328 }
26329 return resultobj;
26330 fail:
26331 return NULL;
26332 }
26333
26334
26335 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26336 PyObject *resultobj;
26337 long result;
26338 char *kwnames[] = {
26339 NULL
26340 };
26341
26342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26343 {
26344 PyThreadState* __tstate = wxPyBeginAllowThreads();
26345 result = (long)wxGetCurrentTime();
26346
26347 wxPyEndAllowThreads(__tstate);
26348 if (PyErr_Occurred()) SWIG_fail;
26349 }
26350 {
26351 resultobj = SWIG_From_long((long)(result));
26352 }
26353 return resultobj;
26354 fail:
26355 return NULL;
26356 }
26357
26358
26359 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26360 PyObject *resultobj;
26361 wxLongLong result;
26362 char *kwnames[] = {
26363 NULL
26364 };
26365
26366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26367 {
26368 PyThreadState* __tstate = wxPyBeginAllowThreads();
26369 result = wxGetLocalTimeMillis();
26370
26371 wxPyEndAllowThreads(__tstate);
26372 if (PyErr_Occurred()) SWIG_fail;
26373 }
26374 {
26375 PyObject *hi, *lo, *shifter, *shifted;
26376 hi = PyLong_FromLong( (&result)->GetHi() );
26377 lo = PyLong_FromLong( (&result)->GetLo() );
26378 shifter = PyLong_FromLong(32);
26379 shifted = PyNumber_Lshift(hi, shifter);
26380 resultobj = PyNumber_Or(shifted, lo);
26381 Py_DECREF(hi);
26382 Py_DECREF(lo);
26383 Py_DECREF(shifter);
26384 Py_DECREF(shifted);
26385 }
26386 return resultobj;
26387 fail:
26388 return NULL;
26389 }
26390
26391
26392 static int _wrap_DefaultDateTime_set(PyObject *) {
26393 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26394 return 1;
26395 }
26396
26397
26398 static PyObject *_wrap_DefaultDateTime_get(void) {
26399 PyObject *pyobj;
26400
26401 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26402 return pyobj;
26403 }
26404
26405
26406 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26407 PyObject *resultobj;
26408 wxDataFormatId arg1 ;
26409 wxDataFormat *result;
26410 PyObject * obj0 = 0 ;
26411 char *kwnames[] = {
26412 (char *) "type", NULL
26413 };
26414
26415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26416 {
26417 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26418 if (SWIG_arg_fail(1)) SWIG_fail;
26419 }
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26423
26424 wxPyEndAllowThreads(__tstate);
26425 if (PyErr_Occurred()) SWIG_fail;
26426 }
26427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26428 return resultobj;
26429 fail:
26430 return NULL;
26431 }
26432
26433
26434 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26435 PyObject *resultobj;
26436 wxString *arg1 = 0 ;
26437 wxDataFormat *result;
26438 bool temp1 = false ;
26439 PyObject * obj0 = 0 ;
26440 char *kwnames[] = {
26441 (char *) "format", NULL
26442 };
26443
26444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26445 {
26446 arg1 = wxString_in_helper(obj0);
26447 if (arg1 == NULL) SWIG_fail;
26448 temp1 = true;
26449 }
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26453
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26458 {
26459 if (temp1)
26460 delete arg1;
26461 }
26462 return resultobj;
26463 fail:
26464 {
26465 if (temp1)
26466 delete arg1;
26467 }
26468 return NULL;
26469 }
26470
26471
26472 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26473 PyObject *resultobj;
26474 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26475 PyObject * obj0 = 0 ;
26476 char *kwnames[] = {
26477 (char *) "self", NULL
26478 };
26479
26480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26482 if (SWIG_arg_fail(1)) SWIG_fail;
26483 {
26484 PyThreadState* __tstate = wxPyBeginAllowThreads();
26485 delete arg1;
26486
26487 wxPyEndAllowThreads(__tstate);
26488 if (PyErr_Occurred()) SWIG_fail;
26489 }
26490 Py_INCREF(Py_None); resultobj = Py_None;
26491 return resultobj;
26492 fail:
26493 return NULL;
26494 }
26495
26496
26497 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26498 PyObject *resultobj;
26499 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26500 wxDataFormatId arg2 ;
26501 bool result;
26502 PyObject * obj0 = 0 ;
26503 PyObject * obj1 = 0 ;
26504
26505 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26507 if (SWIG_arg_fail(1)) SWIG_fail;
26508 {
26509 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26510 if (SWIG_arg_fail(2)) SWIG_fail;
26511 }
26512 {
26513 PyThreadState* __tstate = wxPyBeginAllowThreads();
26514 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26515
26516 wxPyEndAllowThreads(__tstate);
26517 if (PyErr_Occurred()) SWIG_fail;
26518 }
26519 {
26520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26521 }
26522 return resultobj;
26523 fail:
26524 return NULL;
26525 }
26526
26527
26528 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26529 PyObject *resultobj;
26530 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26531 wxDataFormatId arg2 ;
26532 bool result;
26533 PyObject * obj0 = 0 ;
26534 PyObject * obj1 = 0 ;
26535
26536 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26538 if (SWIG_arg_fail(1)) SWIG_fail;
26539 {
26540 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26541 if (SWIG_arg_fail(2)) SWIG_fail;
26542 }
26543 {
26544 PyThreadState* __tstate = wxPyBeginAllowThreads();
26545 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26546
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 {
26551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26552 }
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26560 PyObject *resultobj;
26561 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26562 wxDataFormat *arg2 = 0 ;
26563 bool result;
26564 PyObject * obj0 = 0 ;
26565 PyObject * obj1 = 0 ;
26566
26567 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26569 if (SWIG_arg_fail(1)) SWIG_fail;
26570 {
26571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26572 if (SWIG_arg_fail(2)) SWIG_fail;
26573 if (arg2 == NULL) {
26574 SWIG_null_ref("wxDataFormat");
26575 }
26576 if (SWIG_arg_fail(2)) SWIG_fail;
26577 }
26578 {
26579 PyThreadState* __tstate = wxPyBeginAllowThreads();
26580 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26581
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 {
26586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26587 }
26588 return resultobj;
26589 fail:
26590 return NULL;
26591 }
26592
26593
26594 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26595 int argc;
26596 PyObject *argv[3];
26597 int ii;
26598
26599 argc = PyObject_Length(args);
26600 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26601 argv[ii] = PyTuple_GetItem(args,ii);
26602 }
26603 if (argc == 2) {
26604 int _v;
26605 {
26606 void *ptr;
26607 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26608 _v = 0;
26609 PyErr_Clear();
26610 } else {
26611 _v = 1;
26612 }
26613 }
26614 if (_v) {
26615 {
26616 void *ptr = 0;
26617 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26618 _v = 0;
26619 PyErr_Clear();
26620 } else {
26621 _v = (ptr != 0);
26622 }
26623 }
26624 if (_v) {
26625 return _wrap_DataFormat___eq____SWIG_1(self,args);
26626 }
26627 }
26628 }
26629 if (argc == 2) {
26630 int _v;
26631 {
26632 void *ptr;
26633 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26634 _v = 0;
26635 PyErr_Clear();
26636 } else {
26637 _v = 1;
26638 }
26639 }
26640 if (_v) {
26641 _v = SWIG_Check_int(argv[1]);
26642 if (_v) {
26643 return _wrap_DataFormat___eq____SWIG_0(self,args);
26644 }
26645 }
26646 }
26647
26648 Py_INCREF(Py_NotImplemented);
26649 return Py_NotImplemented;
26650 }
26651
26652
26653 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26654 PyObject *resultobj;
26655 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26656 wxDataFormat *arg2 = 0 ;
26657 bool result;
26658 PyObject * obj0 = 0 ;
26659 PyObject * obj1 = 0 ;
26660
26661 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26663 if (SWIG_arg_fail(1)) SWIG_fail;
26664 {
26665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26666 if (SWIG_arg_fail(2)) SWIG_fail;
26667 if (arg2 == NULL) {
26668 SWIG_null_ref("wxDataFormat");
26669 }
26670 if (SWIG_arg_fail(2)) SWIG_fail;
26671 }
26672 {
26673 PyThreadState* __tstate = wxPyBeginAllowThreads();
26674 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26675
26676 wxPyEndAllowThreads(__tstate);
26677 if (PyErr_Occurred()) SWIG_fail;
26678 }
26679 {
26680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26681 }
26682 return resultobj;
26683 fail:
26684 return NULL;
26685 }
26686
26687
26688 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26689 int argc;
26690 PyObject *argv[3];
26691 int ii;
26692
26693 argc = PyObject_Length(args);
26694 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26695 argv[ii] = PyTuple_GetItem(args,ii);
26696 }
26697 if (argc == 2) {
26698 int _v;
26699 {
26700 void *ptr;
26701 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26702 _v = 0;
26703 PyErr_Clear();
26704 } else {
26705 _v = 1;
26706 }
26707 }
26708 if (_v) {
26709 {
26710 void *ptr = 0;
26711 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26712 _v = 0;
26713 PyErr_Clear();
26714 } else {
26715 _v = (ptr != 0);
26716 }
26717 }
26718 if (_v) {
26719 return _wrap_DataFormat___ne____SWIG_1(self,args);
26720 }
26721 }
26722 }
26723 if (argc == 2) {
26724 int _v;
26725 {
26726 void *ptr;
26727 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26728 _v = 0;
26729 PyErr_Clear();
26730 } else {
26731 _v = 1;
26732 }
26733 }
26734 if (_v) {
26735 _v = SWIG_Check_int(argv[1]);
26736 if (_v) {
26737 return _wrap_DataFormat___ne____SWIG_0(self,args);
26738 }
26739 }
26740 }
26741
26742 Py_INCREF(Py_NotImplemented);
26743 return Py_NotImplemented;
26744 }
26745
26746
26747 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26748 PyObject *resultobj;
26749 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26750 wxDataFormatId arg2 ;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753 char *kwnames[] = {
26754 (char *) "self",(char *) "format", NULL
26755 };
26756
26757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26759 if (SWIG_arg_fail(1)) SWIG_fail;
26760 {
26761 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26762 if (SWIG_arg_fail(2)) SWIG_fail;
26763 }
26764 {
26765 PyThreadState* __tstate = wxPyBeginAllowThreads();
26766 (arg1)->SetType((wxDataFormatId )arg2);
26767
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 Py_INCREF(Py_None); resultobj = Py_None;
26772 return resultobj;
26773 fail:
26774 return NULL;
26775 }
26776
26777
26778 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26779 PyObject *resultobj;
26780 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26781 wxDataFormatId result;
26782 PyObject * obj0 = 0 ;
26783 char *kwnames[] = {
26784 (char *) "self", NULL
26785 };
26786
26787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26789 if (SWIG_arg_fail(1)) SWIG_fail;
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26793
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 resultobj = SWIG_From_int((result));
26798 return resultobj;
26799 fail:
26800 return NULL;
26801 }
26802
26803
26804 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26805 PyObject *resultobj;
26806 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26807 wxString result;
26808 PyObject * obj0 = 0 ;
26809 char *kwnames[] = {
26810 (char *) "self", NULL
26811 };
26812
26813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26815 if (SWIG_arg_fail(1)) SWIG_fail;
26816 {
26817 PyThreadState* __tstate = wxPyBeginAllowThreads();
26818 result = ((wxDataFormat const *)arg1)->GetId();
26819
26820 wxPyEndAllowThreads(__tstate);
26821 if (PyErr_Occurred()) SWIG_fail;
26822 }
26823 {
26824 #if wxUSE_UNICODE
26825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26826 #else
26827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26828 #endif
26829 }
26830 return resultobj;
26831 fail:
26832 return NULL;
26833 }
26834
26835
26836 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26837 PyObject *resultobj;
26838 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26839 wxString *arg2 = 0 ;
26840 bool temp2 = false ;
26841 PyObject * obj0 = 0 ;
26842 PyObject * obj1 = 0 ;
26843 char *kwnames[] = {
26844 (char *) "self",(char *) "format", NULL
26845 };
26846
26847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26849 if (SWIG_arg_fail(1)) SWIG_fail;
26850 {
26851 arg2 = wxString_in_helper(obj1);
26852 if (arg2 == NULL) SWIG_fail;
26853 temp2 = true;
26854 }
26855 {
26856 PyThreadState* __tstate = wxPyBeginAllowThreads();
26857 (arg1)->SetId((wxString const &)*arg2);
26858
26859 wxPyEndAllowThreads(__tstate);
26860 if (PyErr_Occurred()) SWIG_fail;
26861 }
26862 Py_INCREF(Py_None); resultobj = Py_None;
26863 {
26864 if (temp2)
26865 delete arg2;
26866 }
26867 return resultobj;
26868 fail:
26869 {
26870 if (temp2)
26871 delete arg2;
26872 }
26873 return NULL;
26874 }
26875
26876
26877 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26878 PyObject *obj;
26879 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26880 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26881 Py_INCREF(obj);
26882 return Py_BuildValue((char *)"");
26883 }
26884 static int _wrap_FormatInvalid_set(PyObject *) {
26885 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26886 return 1;
26887 }
26888
26889
26890 static PyObject *_wrap_FormatInvalid_get(void) {
26891 PyObject *pyobj;
26892
26893 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26894 return pyobj;
26895 }
26896
26897
26898 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26899 PyObject *resultobj;
26900 wxDataObject *arg1 = (wxDataObject *) 0 ;
26901 PyObject * obj0 = 0 ;
26902 char *kwnames[] = {
26903 (char *) "self", NULL
26904 };
26905
26906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26908 if (SWIG_arg_fail(1)) SWIG_fail;
26909 {
26910 PyThreadState* __tstate = wxPyBeginAllowThreads();
26911 delete arg1;
26912
26913 wxPyEndAllowThreads(__tstate);
26914 if (PyErr_Occurred()) SWIG_fail;
26915 }
26916 Py_INCREF(Py_None); resultobj = Py_None;
26917 return resultobj;
26918 fail:
26919 return NULL;
26920 }
26921
26922
26923 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26924 PyObject *resultobj;
26925 wxDataObject *arg1 = (wxDataObject *) 0 ;
26926 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26927 SwigValueWrapper<wxDataFormat > result;
26928 PyObject * obj0 = 0 ;
26929 PyObject * obj1 = 0 ;
26930 char *kwnames[] = {
26931 (char *) "self",(char *) "dir", NULL
26932 };
26933
26934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26936 if (SWIG_arg_fail(1)) SWIG_fail;
26937 if (obj1) {
26938 {
26939 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26940 if (SWIG_arg_fail(2)) SWIG_fail;
26941 }
26942 }
26943 {
26944 PyThreadState* __tstate = wxPyBeginAllowThreads();
26945 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26946
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 {
26951 wxDataFormat * resultptr;
26952 resultptr = new wxDataFormat((wxDataFormat &)(result));
26953 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26954 }
26955 return resultobj;
26956 fail:
26957 return NULL;
26958 }
26959
26960
26961 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26962 PyObject *resultobj;
26963 wxDataObject *arg1 = (wxDataObject *) 0 ;
26964 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26965 size_t result;
26966 PyObject * obj0 = 0 ;
26967 PyObject * obj1 = 0 ;
26968 char *kwnames[] = {
26969 (char *) "self",(char *) "dir", NULL
26970 };
26971
26972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26974 if (SWIG_arg_fail(1)) SWIG_fail;
26975 if (obj1) {
26976 {
26977 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26978 if (SWIG_arg_fail(2)) SWIG_fail;
26979 }
26980 }
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26984
26985 wxPyEndAllowThreads(__tstate);
26986 if (PyErr_Occurred()) SWIG_fail;
26987 }
26988 {
26989 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26990 }
26991 return resultobj;
26992 fail:
26993 return NULL;
26994 }
26995
26996
26997 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26998 PyObject *resultobj;
26999 wxDataObject *arg1 = (wxDataObject *) 0 ;
27000 wxDataFormat *arg2 = 0 ;
27001 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27002 bool result;
27003 PyObject * obj0 = 0 ;
27004 PyObject * obj1 = 0 ;
27005 PyObject * obj2 = 0 ;
27006 char *kwnames[] = {
27007 (char *) "self",(char *) "format",(char *) "dir", NULL
27008 };
27009
27010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27012 if (SWIG_arg_fail(1)) SWIG_fail;
27013 {
27014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27015 if (SWIG_arg_fail(2)) SWIG_fail;
27016 if (arg2 == NULL) {
27017 SWIG_null_ref("wxDataFormat");
27018 }
27019 if (SWIG_arg_fail(2)) SWIG_fail;
27020 }
27021 if (obj2) {
27022 {
27023 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27024 if (SWIG_arg_fail(3)) SWIG_fail;
27025 }
27026 }
27027 {
27028 PyThreadState* __tstate = wxPyBeginAllowThreads();
27029 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27030
27031 wxPyEndAllowThreads(__tstate);
27032 if (PyErr_Occurred()) SWIG_fail;
27033 }
27034 {
27035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27036 }
27037 return resultobj;
27038 fail:
27039 return NULL;
27040 }
27041
27042
27043 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27044 PyObject *resultobj;
27045 wxDataObject *arg1 = (wxDataObject *) 0 ;
27046 wxDataFormat *arg2 = 0 ;
27047 size_t result;
27048 PyObject * obj0 = 0 ;
27049 PyObject * obj1 = 0 ;
27050 char *kwnames[] = {
27051 (char *) "self",(char *) "format", NULL
27052 };
27053
27054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27056 if (SWIG_arg_fail(1)) SWIG_fail;
27057 {
27058 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27059 if (SWIG_arg_fail(2)) SWIG_fail;
27060 if (arg2 == NULL) {
27061 SWIG_null_ref("wxDataFormat");
27062 }
27063 if (SWIG_arg_fail(2)) SWIG_fail;
27064 }
27065 {
27066 PyThreadState* __tstate = wxPyBeginAllowThreads();
27067 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27068
27069 wxPyEndAllowThreads(__tstate);
27070 if (PyErr_Occurred()) SWIG_fail;
27071 }
27072 {
27073 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27074 }
27075 return resultobj;
27076 fail:
27077 return NULL;
27078 }
27079
27080
27081 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27082 PyObject *resultobj;
27083 wxDataObject *arg1 = (wxDataObject *) 0 ;
27084 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27085 PyObject *result;
27086 PyObject * obj0 = 0 ;
27087 PyObject * obj1 = 0 ;
27088 char *kwnames[] = {
27089 (char *) "self",(char *) "dir", NULL
27090 };
27091
27092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27094 if (SWIG_arg_fail(1)) SWIG_fail;
27095 if (obj1) {
27096 {
27097 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27098 if (SWIG_arg_fail(2)) SWIG_fail;
27099 }
27100 }
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27104
27105 wxPyEndAllowThreads(__tstate);
27106 if (PyErr_Occurred()) SWIG_fail;
27107 }
27108 resultobj = result;
27109 return resultobj;
27110 fail:
27111 return NULL;
27112 }
27113
27114
27115 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27116 PyObject *resultobj;
27117 wxDataObject *arg1 = (wxDataObject *) 0 ;
27118 wxDataFormat *arg2 = 0 ;
27119 PyObject *result;
27120 PyObject * obj0 = 0 ;
27121 PyObject * obj1 = 0 ;
27122 char *kwnames[] = {
27123 (char *) "self",(char *) "format", NULL
27124 };
27125
27126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27128 if (SWIG_arg_fail(1)) SWIG_fail;
27129 {
27130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27131 if (SWIG_arg_fail(2)) SWIG_fail;
27132 if (arg2 == NULL) {
27133 SWIG_null_ref("wxDataFormat");
27134 }
27135 if (SWIG_arg_fail(2)) SWIG_fail;
27136 }
27137 {
27138 PyThreadState* __tstate = wxPyBeginAllowThreads();
27139 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27140
27141 wxPyEndAllowThreads(__tstate);
27142 if (PyErr_Occurred()) SWIG_fail;
27143 }
27144 resultobj = result;
27145 return resultobj;
27146 fail:
27147 return NULL;
27148 }
27149
27150
27151 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27152 PyObject *resultobj;
27153 wxDataObject *arg1 = (wxDataObject *) 0 ;
27154 wxDataFormat *arg2 = 0 ;
27155 PyObject *arg3 = (PyObject *) 0 ;
27156 bool result;
27157 PyObject * obj0 = 0 ;
27158 PyObject * obj1 = 0 ;
27159 PyObject * obj2 = 0 ;
27160 char *kwnames[] = {
27161 (char *) "self",(char *) "format",(char *) "data", NULL
27162 };
27163
27164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27166 if (SWIG_arg_fail(1)) SWIG_fail;
27167 {
27168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27169 if (SWIG_arg_fail(2)) SWIG_fail;
27170 if (arg2 == NULL) {
27171 SWIG_null_ref("wxDataFormat");
27172 }
27173 if (SWIG_arg_fail(2)) SWIG_fail;
27174 }
27175 arg3 = obj2;
27176 {
27177 PyThreadState* __tstate = wxPyBeginAllowThreads();
27178 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27179
27180 wxPyEndAllowThreads(__tstate);
27181 if (PyErr_Occurred()) SWIG_fail;
27182 }
27183 {
27184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27185 }
27186 return resultobj;
27187 fail:
27188 return NULL;
27189 }
27190
27191
27192 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27193 PyObject *obj;
27194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27195 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27196 Py_INCREF(obj);
27197 return Py_BuildValue((char *)"");
27198 }
27199 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27200 PyObject *resultobj;
27201 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27202 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27203 wxDataObjectSimple *result;
27204 PyObject * obj0 = 0 ;
27205 char *kwnames[] = {
27206 (char *) "format", NULL
27207 };
27208
27209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27210 if (obj0) {
27211 {
27212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27213 if (SWIG_arg_fail(1)) SWIG_fail;
27214 if (arg1 == NULL) {
27215 SWIG_null_ref("wxDataFormat");
27216 }
27217 if (SWIG_arg_fail(1)) SWIG_fail;
27218 }
27219 }
27220 {
27221 PyThreadState* __tstate = wxPyBeginAllowThreads();
27222 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27223
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27228 return resultobj;
27229 fail:
27230 return NULL;
27231 }
27232
27233
27234 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27235 PyObject *resultobj;
27236 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27237 wxDataFormat *result;
27238 PyObject * obj0 = 0 ;
27239 char *kwnames[] = {
27240 (char *) "self", NULL
27241 };
27242
27243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27245 if (SWIG_arg_fail(1)) SWIG_fail;
27246 {
27247 PyThreadState* __tstate = wxPyBeginAllowThreads();
27248 {
27249 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27250 result = (wxDataFormat *) &_result_ref;
27251 }
27252
27253 wxPyEndAllowThreads(__tstate);
27254 if (PyErr_Occurred()) SWIG_fail;
27255 }
27256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27257 return resultobj;
27258 fail:
27259 return NULL;
27260 }
27261
27262
27263 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27264 PyObject *resultobj;
27265 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27266 wxDataFormat *arg2 = 0 ;
27267 PyObject * obj0 = 0 ;
27268 PyObject * obj1 = 0 ;
27269 char *kwnames[] = {
27270 (char *) "self",(char *) "format", NULL
27271 };
27272
27273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27275 if (SWIG_arg_fail(1)) SWIG_fail;
27276 {
27277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27278 if (SWIG_arg_fail(2)) SWIG_fail;
27279 if (arg2 == NULL) {
27280 SWIG_null_ref("wxDataFormat");
27281 }
27282 if (SWIG_arg_fail(2)) SWIG_fail;
27283 }
27284 {
27285 PyThreadState* __tstate = wxPyBeginAllowThreads();
27286 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27287
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 Py_INCREF(Py_None); resultobj = Py_None;
27292 return resultobj;
27293 fail:
27294 return NULL;
27295 }
27296
27297
27298 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27299 PyObject *resultobj;
27300 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27301 size_t result;
27302 PyObject * obj0 = 0 ;
27303 char *kwnames[] = {
27304 (char *) "self", NULL
27305 };
27306
27307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27309 if (SWIG_arg_fail(1)) SWIG_fail;
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27313
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 {
27318 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27319 }
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj;
27328 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27329 PyObject *result;
27330 PyObject * obj0 = 0 ;
27331 char *kwnames[] = {
27332 (char *) "self", NULL
27333 };
27334
27335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27337 if (SWIG_arg_fail(1)) SWIG_fail;
27338 {
27339 PyThreadState* __tstate = wxPyBeginAllowThreads();
27340 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27341
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 resultobj = result;
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj;
27354 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27355 PyObject *arg2 = (PyObject *) 0 ;
27356 bool result;
27357 PyObject * obj0 = 0 ;
27358 PyObject * obj1 = 0 ;
27359 char *kwnames[] = {
27360 (char *) "self",(char *) "data", NULL
27361 };
27362
27363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27365 if (SWIG_arg_fail(1)) SWIG_fail;
27366 arg2 = obj1;
27367 {
27368 PyThreadState* __tstate = wxPyBeginAllowThreads();
27369 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27370
27371 wxPyEndAllowThreads(__tstate);
27372 if (PyErr_Occurred()) SWIG_fail;
27373 }
27374 {
27375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27376 }
27377 return resultobj;
27378 fail:
27379 return NULL;
27380 }
27381
27382
27383 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27384 PyObject *obj;
27385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27386 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27387 Py_INCREF(obj);
27388 return Py_BuildValue((char *)"");
27389 }
27390 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27391 PyObject *resultobj;
27392 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27393 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27394 wxPyDataObjectSimple *result;
27395 PyObject * obj0 = 0 ;
27396 char *kwnames[] = {
27397 (char *) "format", NULL
27398 };
27399
27400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27401 if (obj0) {
27402 {
27403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27404 if (SWIG_arg_fail(1)) SWIG_fail;
27405 if (arg1 == NULL) {
27406 SWIG_null_ref("wxDataFormat");
27407 }
27408 if (SWIG_arg_fail(1)) SWIG_fail;
27409 }
27410 }
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27414
27415 wxPyEndAllowThreads(__tstate);
27416 if (PyErr_Occurred()) SWIG_fail;
27417 }
27418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27419 return resultobj;
27420 fail:
27421 return NULL;
27422 }
27423
27424
27425 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27426 PyObject *resultobj;
27427 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27428 PyObject *arg2 = (PyObject *) 0 ;
27429 PyObject *arg3 = (PyObject *) 0 ;
27430 PyObject * obj0 = 0 ;
27431 PyObject * obj1 = 0 ;
27432 PyObject * obj2 = 0 ;
27433 char *kwnames[] = {
27434 (char *) "self",(char *) "self",(char *) "_class", NULL
27435 };
27436
27437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27439 if (SWIG_arg_fail(1)) SWIG_fail;
27440 arg2 = obj1;
27441 arg3 = obj2;
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 (arg1)->_setCallbackInfo(arg2,arg3);
27445
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 Py_INCREF(Py_None); resultobj = Py_None;
27450 return resultobj;
27451 fail:
27452 return NULL;
27453 }
27454
27455
27456 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27457 PyObject *obj;
27458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27459 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27460 Py_INCREF(obj);
27461 return Py_BuildValue((char *)"");
27462 }
27463 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27464 PyObject *resultobj;
27465 wxDataObjectComposite *result;
27466 char *kwnames[] = {
27467 NULL
27468 };
27469
27470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27474
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj;
27487 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27488 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27489 bool arg3 = (bool) false ;
27490 PyObject * obj0 = 0 ;
27491 PyObject * obj1 = 0 ;
27492 PyObject * obj2 = 0 ;
27493 char *kwnames[] = {
27494 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27495 };
27496
27497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27499 if (SWIG_arg_fail(1)) SWIG_fail;
27500 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27501 if (SWIG_arg_fail(2)) SWIG_fail;
27502 if (obj2) {
27503 {
27504 arg3 = (bool)(SWIG_As_bool(obj2));
27505 if (SWIG_arg_fail(3)) SWIG_fail;
27506 }
27507 }
27508 {
27509 PyThreadState* __tstate = wxPyBeginAllowThreads();
27510 (arg1)->Add(arg2,arg3);
27511
27512 wxPyEndAllowThreads(__tstate);
27513 if (PyErr_Occurred()) SWIG_fail;
27514 }
27515 Py_INCREF(Py_None); resultobj = Py_None;
27516 return resultobj;
27517 fail:
27518 return NULL;
27519 }
27520
27521
27522 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27523 PyObject *obj;
27524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27525 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27526 Py_INCREF(obj);
27527 return Py_BuildValue((char *)"");
27528 }
27529 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27530 PyObject *resultobj;
27531 wxString const &arg1_defvalue = wxPyEmptyString ;
27532 wxString *arg1 = (wxString *) &arg1_defvalue ;
27533 wxTextDataObject *result;
27534 bool temp1 = false ;
27535 PyObject * obj0 = 0 ;
27536 char *kwnames[] = {
27537 (char *) "text", NULL
27538 };
27539
27540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27541 if (obj0) {
27542 {
27543 arg1 = wxString_in_helper(obj0);
27544 if (arg1 == NULL) SWIG_fail;
27545 temp1 = true;
27546 }
27547 }
27548 {
27549 PyThreadState* __tstate = wxPyBeginAllowThreads();
27550 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27551
27552 wxPyEndAllowThreads(__tstate);
27553 if (PyErr_Occurred()) SWIG_fail;
27554 }
27555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27556 {
27557 if (temp1)
27558 delete arg1;
27559 }
27560 return resultobj;
27561 fail:
27562 {
27563 if (temp1)
27564 delete arg1;
27565 }
27566 return NULL;
27567 }
27568
27569
27570 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27571 PyObject *resultobj;
27572 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27573 size_t result;
27574 PyObject * obj0 = 0 ;
27575 char *kwnames[] = {
27576 (char *) "self", NULL
27577 };
27578
27579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27581 if (SWIG_arg_fail(1)) SWIG_fail;
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (size_t)(arg1)->GetTextLength();
27585
27586 wxPyEndAllowThreads(__tstate);
27587 if (PyErr_Occurred()) SWIG_fail;
27588 }
27589 {
27590 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27591 }
27592 return resultobj;
27593 fail:
27594 return NULL;
27595 }
27596
27597
27598 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27599 PyObject *resultobj;
27600 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27601 wxString result;
27602 PyObject * obj0 = 0 ;
27603 char *kwnames[] = {
27604 (char *) "self", NULL
27605 };
27606
27607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27609 if (SWIG_arg_fail(1)) SWIG_fail;
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = (arg1)->GetText();
27613
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 {
27618 #if wxUSE_UNICODE
27619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27620 #else
27621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27622 #endif
27623 }
27624 return resultobj;
27625 fail:
27626 return NULL;
27627 }
27628
27629
27630 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27631 PyObject *resultobj;
27632 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27633 wxString *arg2 = 0 ;
27634 bool temp2 = false ;
27635 PyObject * obj0 = 0 ;
27636 PyObject * obj1 = 0 ;
27637 char *kwnames[] = {
27638 (char *) "self",(char *) "text", NULL
27639 };
27640
27641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27643 if (SWIG_arg_fail(1)) SWIG_fail;
27644 {
27645 arg2 = wxString_in_helper(obj1);
27646 if (arg2 == NULL) SWIG_fail;
27647 temp2 = true;
27648 }
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 (arg1)->SetText((wxString const &)*arg2);
27652
27653 wxPyEndAllowThreads(__tstate);
27654 if (PyErr_Occurred()) SWIG_fail;
27655 }
27656 Py_INCREF(Py_None); resultobj = Py_None;
27657 {
27658 if (temp2)
27659 delete arg2;
27660 }
27661 return resultobj;
27662 fail:
27663 {
27664 if (temp2)
27665 delete arg2;
27666 }
27667 return NULL;
27668 }
27669
27670
27671 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27672 PyObject *obj;
27673 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27674 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27675 Py_INCREF(obj);
27676 return Py_BuildValue((char *)"");
27677 }
27678 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27679 PyObject *resultobj;
27680 wxString const &arg1_defvalue = wxPyEmptyString ;
27681 wxString *arg1 = (wxString *) &arg1_defvalue ;
27682 wxPyTextDataObject *result;
27683 bool temp1 = false ;
27684 PyObject * obj0 = 0 ;
27685 char *kwnames[] = {
27686 (char *) "text", NULL
27687 };
27688
27689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27690 if (obj0) {
27691 {
27692 arg1 = wxString_in_helper(obj0);
27693 if (arg1 == NULL) SWIG_fail;
27694 temp1 = true;
27695 }
27696 }
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27700
27701 wxPyEndAllowThreads(__tstate);
27702 if (PyErr_Occurred()) SWIG_fail;
27703 }
27704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27705 {
27706 if (temp1)
27707 delete arg1;
27708 }
27709 return resultobj;
27710 fail:
27711 {
27712 if (temp1)
27713 delete arg1;
27714 }
27715 return NULL;
27716 }
27717
27718
27719 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27720 PyObject *resultobj;
27721 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27722 PyObject *arg2 = (PyObject *) 0 ;
27723 PyObject *arg3 = (PyObject *) 0 ;
27724 PyObject * obj0 = 0 ;
27725 PyObject * obj1 = 0 ;
27726 PyObject * obj2 = 0 ;
27727 char *kwnames[] = {
27728 (char *) "self",(char *) "self",(char *) "_class", NULL
27729 };
27730
27731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27733 if (SWIG_arg_fail(1)) SWIG_fail;
27734 arg2 = obj1;
27735 arg3 = obj2;
27736 {
27737 PyThreadState* __tstate = wxPyBeginAllowThreads();
27738 (arg1)->_setCallbackInfo(arg2,arg3);
27739
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 Py_INCREF(Py_None); resultobj = Py_None;
27744 return resultobj;
27745 fail:
27746 return NULL;
27747 }
27748
27749
27750 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27751 PyObject *obj;
27752 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27753 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27754 Py_INCREF(obj);
27755 return Py_BuildValue((char *)"");
27756 }
27757 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27758 PyObject *resultobj;
27759 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27760 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27761 wxBitmapDataObject *result;
27762 PyObject * obj0 = 0 ;
27763 char *kwnames[] = {
27764 (char *) "bitmap", NULL
27765 };
27766
27767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27768 if (obj0) {
27769 {
27770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27771 if (SWIG_arg_fail(1)) SWIG_fail;
27772 if (arg1 == NULL) {
27773 SWIG_null_ref("wxBitmap");
27774 }
27775 if (SWIG_arg_fail(1)) SWIG_fail;
27776 }
27777 }
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27781
27782 wxPyEndAllowThreads(__tstate);
27783 if (PyErr_Occurred()) SWIG_fail;
27784 }
27785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27786 return resultobj;
27787 fail:
27788 return NULL;
27789 }
27790
27791
27792 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27793 PyObject *resultobj;
27794 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27795 wxBitmap result;
27796 PyObject * obj0 = 0 ;
27797 char *kwnames[] = {
27798 (char *) "self", NULL
27799 };
27800
27801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27803 if (SWIG_arg_fail(1)) SWIG_fail;
27804 {
27805 PyThreadState* __tstate = wxPyBeginAllowThreads();
27806 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27807
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 {
27812 wxBitmap * resultptr;
27813 resultptr = new wxBitmap((wxBitmap &)(result));
27814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27815 }
27816 return resultobj;
27817 fail:
27818 return NULL;
27819 }
27820
27821
27822 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27823 PyObject *resultobj;
27824 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27825 wxBitmap *arg2 = 0 ;
27826 PyObject * obj0 = 0 ;
27827 PyObject * obj1 = 0 ;
27828 char *kwnames[] = {
27829 (char *) "self",(char *) "bitmap", NULL
27830 };
27831
27832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27834 if (SWIG_arg_fail(1)) SWIG_fail;
27835 {
27836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27837 if (SWIG_arg_fail(2)) SWIG_fail;
27838 if (arg2 == NULL) {
27839 SWIG_null_ref("wxBitmap");
27840 }
27841 if (SWIG_arg_fail(2)) SWIG_fail;
27842 }
27843 {
27844 PyThreadState* __tstate = wxPyBeginAllowThreads();
27845 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27846
27847 wxPyEndAllowThreads(__tstate);
27848 if (PyErr_Occurred()) SWIG_fail;
27849 }
27850 Py_INCREF(Py_None); resultobj = Py_None;
27851 return resultobj;
27852 fail:
27853 return NULL;
27854 }
27855
27856
27857 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27858 PyObject *obj;
27859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27860 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27861 Py_INCREF(obj);
27862 return Py_BuildValue((char *)"");
27863 }
27864 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27865 PyObject *resultobj;
27866 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27867 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27868 wxPyBitmapDataObject *result;
27869 PyObject * obj0 = 0 ;
27870 char *kwnames[] = {
27871 (char *) "bitmap", NULL
27872 };
27873
27874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27875 if (obj0) {
27876 {
27877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27878 if (SWIG_arg_fail(1)) SWIG_fail;
27879 if (arg1 == NULL) {
27880 SWIG_null_ref("wxBitmap");
27881 }
27882 if (SWIG_arg_fail(1)) SWIG_fail;
27883 }
27884 }
27885 {
27886 PyThreadState* __tstate = wxPyBeginAllowThreads();
27887 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27888
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27900 PyObject *resultobj;
27901 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27902 PyObject *arg2 = (PyObject *) 0 ;
27903 PyObject *arg3 = (PyObject *) 0 ;
27904 PyObject * obj0 = 0 ;
27905 PyObject * obj1 = 0 ;
27906 PyObject * obj2 = 0 ;
27907 char *kwnames[] = {
27908 (char *) "self",(char *) "self",(char *) "_class", NULL
27909 };
27910
27911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27913 if (SWIG_arg_fail(1)) SWIG_fail;
27914 arg2 = obj1;
27915 arg3 = obj2;
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 (arg1)->_setCallbackInfo(arg2,arg3);
27919
27920 wxPyEndAllowThreads(__tstate);
27921 if (PyErr_Occurred()) SWIG_fail;
27922 }
27923 Py_INCREF(Py_None); resultobj = Py_None;
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27931 PyObject *obj;
27932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27933 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27934 Py_INCREF(obj);
27935 return Py_BuildValue((char *)"");
27936 }
27937 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27938 PyObject *resultobj;
27939 wxFileDataObject *result;
27940 char *kwnames[] = {
27941 NULL
27942 };
27943
27944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (wxFileDataObject *)new wxFileDataObject();
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj;
27961 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27962 wxArrayString *result;
27963 PyObject * obj0 = 0 ;
27964 char *kwnames[] = {
27965 (char *) "self", NULL
27966 };
27967
27968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27970 if (SWIG_arg_fail(1)) SWIG_fail;
27971 {
27972 PyThreadState* __tstate = wxPyBeginAllowThreads();
27973 {
27974 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27975 result = (wxArrayString *) &_result_ref;
27976 }
27977
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 {
27982 resultobj = wxArrayString2PyList_helper(*result);
27983 }
27984 return resultobj;
27985 fail:
27986 return NULL;
27987 }
27988
27989
27990 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27991 PyObject *resultobj;
27992 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27993 wxString *arg2 = 0 ;
27994 bool temp2 = false ;
27995 PyObject * obj0 = 0 ;
27996 PyObject * obj1 = 0 ;
27997 char *kwnames[] = {
27998 (char *) "self",(char *) "filename", NULL
27999 };
28000
28001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28003 if (SWIG_arg_fail(1)) SWIG_fail;
28004 {
28005 arg2 = wxString_in_helper(obj1);
28006 if (arg2 == NULL) SWIG_fail;
28007 temp2 = true;
28008 }
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 (arg1)->AddFile((wxString const &)*arg2);
28012
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 Py_INCREF(Py_None); resultobj = Py_None;
28017 {
28018 if (temp2)
28019 delete arg2;
28020 }
28021 return resultobj;
28022 fail:
28023 {
28024 if (temp2)
28025 delete arg2;
28026 }
28027 return NULL;
28028 }
28029
28030
28031 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28032 PyObject *obj;
28033 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28034 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28035 Py_INCREF(obj);
28036 return Py_BuildValue((char *)"");
28037 }
28038 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28039 PyObject *resultobj;
28040 wxDataFormat *arg1 = 0 ;
28041 wxCustomDataObject *result;
28042 PyObject * obj0 = 0 ;
28043
28044 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28045 {
28046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28047 if (SWIG_arg_fail(1)) SWIG_fail;
28048 if (arg1 == NULL) {
28049 SWIG_null_ref("wxDataFormat");
28050 }
28051 if (SWIG_arg_fail(1)) SWIG_fail;
28052 }
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28056
28057 wxPyEndAllowThreads(__tstate);
28058 if (PyErr_Occurred()) SWIG_fail;
28059 }
28060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28061 return resultobj;
28062 fail:
28063 return NULL;
28064 }
28065
28066
28067 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28068 PyObject *resultobj;
28069 wxString *arg1 = 0 ;
28070 wxCustomDataObject *result;
28071 bool temp1 = false ;
28072 PyObject * obj0 = 0 ;
28073
28074 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28075 {
28076 arg1 = wxString_in_helper(obj0);
28077 if (arg1 == NULL) SWIG_fail;
28078 temp1 = true;
28079 }
28080 {
28081 PyThreadState* __tstate = wxPyBeginAllowThreads();
28082 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28083
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28088 {
28089 if (temp1)
28090 delete arg1;
28091 }
28092 return resultobj;
28093 fail:
28094 {
28095 if (temp1)
28096 delete arg1;
28097 }
28098 return NULL;
28099 }
28100
28101
28102 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28103 PyObject *resultobj;
28104 wxCustomDataObject *result;
28105
28106 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28107 {
28108 PyThreadState* __tstate = wxPyBeginAllowThreads();
28109 result = (wxCustomDataObject *)new wxCustomDataObject();
28110
28111 wxPyEndAllowThreads(__tstate);
28112 if (PyErr_Occurred()) SWIG_fail;
28113 }
28114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28122 int argc;
28123 PyObject *argv[2];
28124 int ii;
28125
28126 argc = PyObject_Length(args);
28127 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28128 argv[ii] = PyTuple_GetItem(args,ii);
28129 }
28130 if (argc == 0) {
28131 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28132 }
28133 if (argc == 1) {
28134 int _v;
28135 {
28136 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28137 }
28138 if (_v) {
28139 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28140 }
28141 }
28142 if (argc == 1) {
28143 int _v;
28144 {
28145 void *ptr = 0;
28146 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28147 _v = 0;
28148 PyErr_Clear();
28149 } else {
28150 _v = (ptr != 0);
28151 }
28152 }
28153 if (_v) {
28154 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28155 }
28156 }
28157
28158 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28159 return NULL;
28160 }
28161
28162
28163 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28164 PyObject *resultobj;
28165 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28166 PyObject *arg2 = (PyObject *) 0 ;
28167 bool result;
28168 PyObject * obj0 = 0 ;
28169 PyObject * obj1 = 0 ;
28170 char *kwnames[] = {
28171 (char *) "self",(char *) "data", NULL
28172 };
28173
28174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28176 if (SWIG_arg_fail(1)) SWIG_fail;
28177 arg2 = obj1;
28178 {
28179 PyThreadState* __tstate = wxPyBeginAllowThreads();
28180 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28181
28182 wxPyEndAllowThreads(__tstate);
28183 if (PyErr_Occurred()) SWIG_fail;
28184 }
28185 {
28186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28187 }
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj;
28196 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28197 size_t result;
28198 PyObject * obj0 = 0 ;
28199 char *kwnames[] = {
28200 (char *) "self", NULL
28201 };
28202
28203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28205 if (SWIG_arg_fail(1)) SWIG_fail;
28206 {
28207 PyThreadState* __tstate = wxPyBeginAllowThreads();
28208 result = (size_t)(arg1)->GetSize();
28209
28210 wxPyEndAllowThreads(__tstate);
28211 if (PyErr_Occurred()) SWIG_fail;
28212 }
28213 {
28214 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28215 }
28216 return resultobj;
28217 fail:
28218 return NULL;
28219 }
28220
28221
28222 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28223 PyObject *resultobj;
28224 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28225 PyObject *result;
28226 PyObject * obj0 = 0 ;
28227 char *kwnames[] = {
28228 (char *) "self", NULL
28229 };
28230
28231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28233 if (SWIG_arg_fail(1)) SWIG_fail;
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28237
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 resultobj = result;
28242 return resultobj;
28243 fail:
28244 return NULL;
28245 }
28246
28247
28248 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28249 PyObject *obj;
28250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28251 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28252 Py_INCREF(obj);
28253 return Py_BuildValue((char *)"");
28254 }
28255 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28256 PyObject *resultobj;
28257 wxURLDataObject *result;
28258 char *kwnames[] = {
28259 NULL
28260 };
28261
28262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28263 {
28264 PyThreadState* __tstate = wxPyBeginAllowThreads();
28265 result = (wxURLDataObject *)new wxURLDataObject();
28266
28267 wxPyEndAllowThreads(__tstate);
28268 if (PyErr_Occurred()) SWIG_fail;
28269 }
28270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28271 return resultobj;
28272 fail:
28273 return NULL;
28274 }
28275
28276
28277 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28278 PyObject *resultobj;
28279 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28280 wxString result;
28281 PyObject * obj0 = 0 ;
28282 char *kwnames[] = {
28283 (char *) "self", NULL
28284 };
28285
28286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28288 if (SWIG_arg_fail(1)) SWIG_fail;
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 result = (arg1)->GetURL();
28292
28293 wxPyEndAllowThreads(__tstate);
28294 if (PyErr_Occurred()) SWIG_fail;
28295 }
28296 {
28297 #if wxUSE_UNICODE
28298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28299 #else
28300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28301 #endif
28302 }
28303 return resultobj;
28304 fail:
28305 return NULL;
28306 }
28307
28308
28309 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28310 PyObject *resultobj;
28311 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28312 wxString *arg2 = 0 ;
28313 bool temp2 = false ;
28314 PyObject * obj0 = 0 ;
28315 PyObject * obj1 = 0 ;
28316 char *kwnames[] = {
28317 (char *) "self",(char *) "url", NULL
28318 };
28319
28320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28322 if (SWIG_arg_fail(1)) SWIG_fail;
28323 {
28324 arg2 = wxString_in_helper(obj1);
28325 if (arg2 == NULL) SWIG_fail;
28326 temp2 = true;
28327 }
28328 {
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 (arg1)->SetURL((wxString const &)*arg2);
28331
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 Py_INCREF(Py_None); resultobj = Py_None;
28336 {
28337 if (temp2)
28338 delete arg2;
28339 }
28340 return resultobj;
28341 fail:
28342 {
28343 if (temp2)
28344 delete arg2;
28345 }
28346 return NULL;
28347 }
28348
28349
28350 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28351 PyObject *obj;
28352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28353 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28354 Py_INCREF(obj);
28355 return Py_BuildValue((char *)"");
28356 }
28357 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28358 PyObject *resultobj;
28359 wxMetafileDataObject *result;
28360 char *kwnames[] = {
28361 NULL
28362 };
28363
28364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28368
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28373 return resultobj;
28374 fail:
28375 return NULL;
28376 }
28377
28378
28379 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28380 PyObject *resultobj;
28381 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28382 wxMetafile *arg2 = 0 ;
28383 PyObject * obj0 = 0 ;
28384 PyObject * obj1 = 0 ;
28385 char *kwnames[] = {
28386 (char *) "self",(char *) "metafile", NULL
28387 };
28388
28389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28391 if (SWIG_arg_fail(1)) SWIG_fail;
28392 {
28393 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28394 if (SWIG_arg_fail(2)) SWIG_fail;
28395 if (arg2 == NULL) {
28396 SWIG_null_ref("wxMetafile");
28397 }
28398 if (SWIG_arg_fail(2)) SWIG_fail;
28399 }
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28403
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 Py_INCREF(Py_None); resultobj = Py_None;
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28415 PyObject *resultobj;
28416 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28417 wxMetafile result;
28418 PyObject * obj0 = 0 ;
28419 char *kwnames[] = {
28420 (char *) "self", NULL
28421 };
28422
28423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28425 if (SWIG_arg_fail(1)) SWIG_fail;
28426 {
28427 PyThreadState* __tstate = wxPyBeginAllowThreads();
28428 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28429
28430 wxPyEndAllowThreads(__tstate);
28431 if (PyErr_Occurred()) SWIG_fail;
28432 }
28433 {
28434 wxMetafile * resultptr;
28435 resultptr = new wxMetafile((wxMetafile &)(result));
28436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28437 }
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28445 PyObject *obj;
28446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28447 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28448 Py_INCREF(obj);
28449 return Py_BuildValue((char *)"");
28450 }
28451 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28452 PyObject *resultobj;
28453 wxDragResult arg1 ;
28454 bool result;
28455 PyObject * obj0 = 0 ;
28456 char *kwnames[] = {
28457 (char *) "res", NULL
28458 };
28459
28460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28461 {
28462 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28463 if (SWIG_arg_fail(1)) SWIG_fail;
28464 }
28465 {
28466 PyThreadState* __tstate = wxPyBeginAllowThreads();
28467 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28468
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 {
28473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28474 }
28475 return resultobj;
28476 fail:
28477 return NULL;
28478 }
28479
28480
28481 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28482 PyObject *resultobj;
28483 wxWindow *arg1 = (wxWindow *) 0 ;
28484 wxCursor const &arg2_defvalue = wxNullCursor ;
28485 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28486 wxCursor const &arg3_defvalue = wxNullCursor ;
28487 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28488 wxCursor const &arg4_defvalue = wxNullCursor ;
28489 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28490 wxPyDropSource *result;
28491 PyObject * obj0 = 0 ;
28492 PyObject * obj1 = 0 ;
28493 PyObject * obj2 = 0 ;
28494 PyObject * obj3 = 0 ;
28495 char *kwnames[] = {
28496 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28497 };
28498
28499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28501 if (SWIG_arg_fail(1)) SWIG_fail;
28502 if (obj1) {
28503 {
28504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28505 if (SWIG_arg_fail(2)) SWIG_fail;
28506 if (arg2 == NULL) {
28507 SWIG_null_ref("wxCursor");
28508 }
28509 if (SWIG_arg_fail(2)) SWIG_fail;
28510 }
28511 }
28512 if (obj2) {
28513 {
28514 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28515 if (SWIG_arg_fail(3)) SWIG_fail;
28516 if (arg3 == NULL) {
28517 SWIG_null_ref("wxCursor");
28518 }
28519 if (SWIG_arg_fail(3)) SWIG_fail;
28520 }
28521 }
28522 if (obj3) {
28523 {
28524 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28525 if (SWIG_arg_fail(4)) SWIG_fail;
28526 if (arg4 == NULL) {
28527 SWIG_null_ref("wxCursor");
28528 }
28529 if (SWIG_arg_fail(4)) SWIG_fail;
28530 }
28531 }
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28535
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj;
28548 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28549 PyObject *arg2 = (PyObject *) 0 ;
28550 PyObject *arg3 = (PyObject *) 0 ;
28551 int arg4 ;
28552 PyObject * obj0 = 0 ;
28553 PyObject * obj1 = 0 ;
28554 PyObject * obj2 = 0 ;
28555 PyObject * obj3 = 0 ;
28556 char *kwnames[] = {
28557 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28558 };
28559
28560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28562 if (SWIG_arg_fail(1)) SWIG_fail;
28563 arg2 = obj1;
28564 arg3 = obj2;
28565 {
28566 arg4 = (int)(SWIG_As_int(obj3));
28567 if (SWIG_arg_fail(4)) SWIG_fail;
28568 }
28569 {
28570 PyThreadState* __tstate = wxPyBeginAllowThreads();
28571 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28572
28573 wxPyEndAllowThreads(__tstate);
28574 if (PyErr_Occurred()) SWIG_fail;
28575 }
28576 Py_INCREF(Py_None); resultobj = Py_None;
28577 return resultobj;
28578 fail:
28579 return NULL;
28580 }
28581
28582
28583 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28584 PyObject *resultobj;
28585 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28586 PyObject * obj0 = 0 ;
28587 char *kwnames[] = {
28588 (char *) "self", NULL
28589 };
28590
28591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28593 if (SWIG_arg_fail(1)) SWIG_fail;
28594 {
28595 PyThreadState* __tstate = wxPyBeginAllowThreads();
28596 delete arg1;
28597
28598 wxPyEndAllowThreads(__tstate);
28599 if (PyErr_Occurred()) SWIG_fail;
28600 }
28601 Py_INCREF(Py_None); resultobj = Py_None;
28602 return resultobj;
28603 fail:
28604 return NULL;
28605 }
28606
28607
28608 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28609 PyObject *resultobj;
28610 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28611 wxDataObject *arg2 = 0 ;
28612 PyObject * obj0 = 0 ;
28613 PyObject * obj1 = 0 ;
28614 char *kwnames[] = {
28615 (char *) "self",(char *) "data", NULL
28616 };
28617
28618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28620 if (SWIG_arg_fail(1)) SWIG_fail;
28621 {
28622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28623 if (SWIG_arg_fail(2)) SWIG_fail;
28624 if (arg2 == NULL) {
28625 SWIG_null_ref("wxDataObject");
28626 }
28627 if (SWIG_arg_fail(2)) SWIG_fail;
28628 }
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 (arg1)->SetData(*arg2);
28632
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 Py_INCREF(Py_None); resultobj = Py_None;
28637 return resultobj;
28638 fail:
28639 return NULL;
28640 }
28641
28642
28643 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28644 PyObject *resultobj;
28645 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28646 wxDataObject *result;
28647 PyObject * obj0 = 0 ;
28648 char *kwnames[] = {
28649 (char *) "self", NULL
28650 };
28651
28652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(1)) SWIG_fail;
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 result = (wxDataObject *)(arg1)->GetDataObject();
28658
28659 wxPyEndAllowThreads(__tstate);
28660 if (PyErr_Occurred()) SWIG_fail;
28661 }
28662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28663 return resultobj;
28664 fail:
28665 return NULL;
28666 }
28667
28668
28669 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28670 PyObject *resultobj;
28671 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28672 wxDragResult arg2 ;
28673 wxCursor *arg3 = 0 ;
28674 PyObject * obj0 = 0 ;
28675 PyObject * obj1 = 0 ;
28676 PyObject * obj2 = 0 ;
28677 char *kwnames[] = {
28678 (char *) "self",(char *) "res",(char *) "cursor", NULL
28679 };
28680
28681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28683 if (SWIG_arg_fail(1)) SWIG_fail;
28684 {
28685 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28686 if (SWIG_arg_fail(2)) SWIG_fail;
28687 }
28688 {
28689 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28690 if (SWIG_arg_fail(3)) SWIG_fail;
28691 if (arg3 == NULL) {
28692 SWIG_null_ref("wxCursor");
28693 }
28694 if (SWIG_arg_fail(3)) SWIG_fail;
28695 }
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28699
28700 wxPyEndAllowThreads(__tstate);
28701 if (PyErr_Occurred()) SWIG_fail;
28702 }
28703 Py_INCREF(Py_None); resultobj = Py_None;
28704 return resultobj;
28705 fail:
28706 return NULL;
28707 }
28708
28709
28710 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28711 PyObject *resultobj;
28712 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28713 int arg2 = (int) wxDrag_CopyOnly ;
28714 wxDragResult result;
28715 PyObject * obj0 = 0 ;
28716 PyObject * obj1 = 0 ;
28717 char *kwnames[] = {
28718 (char *) "self",(char *) "flags", NULL
28719 };
28720
28721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28723 if (SWIG_arg_fail(1)) SWIG_fail;
28724 if (obj1) {
28725 {
28726 arg2 = (int)(SWIG_As_int(obj1));
28727 if (SWIG_arg_fail(2)) SWIG_fail;
28728 }
28729 }
28730 {
28731 PyThreadState* __tstate = wxPyBeginAllowThreads();
28732 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28733
28734 wxPyEndAllowThreads(__tstate);
28735 if (PyErr_Occurred()) SWIG_fail;
28736 }
28737 resultobj = SWIG_From_int((result));
28738 return resultobj;
28739 fail:
28740 return NULL;
28741 }
28742
28743
28744 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28745 PyObject *resultobj;
28746 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28747 wxDragResult arg2 ;
28748 bool result;
28749 PyObject * obj0 = 0 ;
28750 PyObject * obj1 = 0 ;
28751 char *kwnames[] = {
28752 (char *) "self",(char *) "effect", NULL
28753 };
28754
28755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28757 if (SWIG_arg_fail(1)) SWIG_fail;
28758 {
28759 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28760 if (SWIG_arg_fail(2)) SWIG_fail;
28761 }
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28765
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 {
28770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28771 }
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28779 PyObject *obj;
28780 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28781 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28782 Py_INCREF(obj);
28783 return Py_BuildValue((char *)"");
28784 }
28785 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28786 PyObject *resultobj;
28787 wxDataObject *arg1 = (wxDataObject *) NULL ;
28788 wxPyDropTarget *result;
28789 PyObject * obj0 = 0 ;
28790 char *kwnames[] = {
28791 (char *) "dataObject", NULL
28792 };
28793
28794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28795 if (obj0) {
28796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28797 if (SWIG_arg_fail(1)) SWIG_fail;
28798 }
28799 {
28800 PyThreadState* __tstate = wxPyBeginAllowThreads();
28801 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28802
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28814 PyObject *resultobj;
28815 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28816 PyObject *arg2 = (PyObject *) 0 ;
28817 PyObject *arg3 = (PyObject *) 0 ;
28818 PyObject * obj0 = 0 ;
28819 PyObject * obj1 = 0 ;
28820 PyObject * obj2 = 0 ;
28821 char *kwnames[] = {
28822 (char *) "self",(char *) "self",(char *) "_class", NULL
28823 };
28824
28825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28827 if (SWIG_arg_fail(1)) SWIG_fail;
28828 arg2 = obj1;
28829 arg3 = obj2;
28830 {
28831 PyThreadState* __tstate = wxPyBeginAllowThreads();
28832 (arg1)->_setCallbackInfo(arg2,arg3);
28833
28834 wxPyEndAllowThreads(__tstate);
28835 if (PyErr_Occurred()) SWIG_fail;
28836 }
28837 Py_INCREF(Py_None); resultobj = Py_None;
28838 return resultobj;
28839 fail:
28840 return NULL;
28841 }
28842
28843
28844 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28845 PyObject *resultobj;
28846 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28847 PyObject * obj0 = 0 ;
28848 char *kwnames[] = {
28849 (char *) "self", NULL
28850 };
28851
28852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28854 if (SWIG_arg_fail(1)) SWIG_fail;
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 delete arg1;
28858
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 Py_INCREF(Py_None); resultobj = Py_None;
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28870 PyObject *resultobj;
28871 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28872 wxDataObject *result;
28873 PyObject * obj0 = 0 ;
28874 char *kwnames[] = {
28875 (char *) "self", NULL
28876 };
28877
28878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28880 if (SWIG_arg_fail(1)) SWIG_fail;
28881 {
28882 PyThreadState* __tstate = wxPyBeginAllowThreads();
28883 result = (wxDataObject *)(arg1)->GetDataObject();
28884
28885 wxPyEndAllowThreads(__tstate);
28886 if (PyErr_Occurred()) SWIG_fail;
28887 }
28888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28889 return resultobj;
28890 fail:
28891 return NULL;
28892 }
28893
28894
28895 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28896 PyObject *resultobj;
28897 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28898 wxDataObject *arg2 = (wxDataObject *) 0 ;
28899 PyObject * obj0 = 0 ;
28900 PyObject * obj1 = 0 ;
28901 char *kwnames[] = {
28902 (char *) "self",(char *) "dataObject", NULL
28903 };
28904
28905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28907 if (SWIG_arg_fail(1)) SWIG_fail;
28908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28909 if (SWIG_arg_fail(2)) SWIG_fail;
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 (arg1)->SetDataObject(arg2);
28913
28914 wxPyEndAllowThreads(__tstate);
28915 if (PyErr_Occurred()) SWIG_fail;
28916 }
28917 Py_INCREF(Py_None); resultobj = Py_None;
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28925 PyObject *resultobj;
28926 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28927 int arg2 ;
28928 int arg3 ;
28929 wxDragResult arg4 ;
28930 wxDragResult result;
28931 PyObject * obj0 = 0 ;
28932 PyObject * obj1 = 0 ;
28933 PyObject * obj2 = 0 ;
28934 PyObject * obj3 = 0 ;
28935 char *kwnames[] = {
28936 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28937 };
28938
28939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28941 if (SWIG_arg_fail(1)) SWIG_fail;
28942 {
28943 arg2 = (int)(SWIG_As_int(obj1));
28944 if (SWIG_arg_fail(2)) SWIG_fail;
28945 }
28946 {
28947 arg3 = (int)(SWIG_As_int(obj2));
28948 if (SWIG_arg_fail(3)) SWIG_fail;
28949 }
28950 {
28951 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28952 if (SWIG_arg_fail(4)) SWIG_fail;
28953 }
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28957
28958 wxPyEndAllowThreads(__tstate);
28959 if (PyErr_Occurred()) SWIG_fail;
28960 }
28961 resultobj = SWIG_From_int((result));
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28969 PyObject *resultobj;
28970 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28971 int arg2 ;
28972 int arg3 ;
28973 wxDragResult arg4 ;
28974 wxDragResult result;
28975 PyObject * obj0 = 0 ;
28976 PyObject * obj1 = 0 ;
28977 PyObject * obj2 = 0 ;
28978 PyObject * obj3 = 0 ;
28979 char *kwnames[] = {
28980 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28981 };
28982
28983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28985 if (SWIG_arg_fail(1)) SWIG_fail;
28986 {
28987 arg2 = (int)(SWIG_As_int(obj1));
28988 if (SWIG_arg_fail(2)) SWIG_fail;
28989 }
28990 {
28991 arg3 = (int)(SWIG_As_int(obj2));
28992 if (SWIG_arg_fail(3)) SWIG_fail;
28993 }
28994 {
28995 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28996 if (SWIG_arg_fail(4)) SWIG_fail;
28997 }
28998 {
28999 PyThreadState* __tstate = wxPyBeginAllowThreads();
29000 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29001
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 resultobj = SWIG_From_int((result));
29006 return resultobj;
29007 fail:
29008 return NULL;
29009 }
29010
29011
29012 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29013 PyObject *resultobj;
29014 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29015 PyObject * obj0 = 0 ;
29016 char *kwnames[] = {
29017 (char *) "self", NULL
29018 };
29019
29020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29022 if (SWIG_arg_fail(1)) SWIG_fail;
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 (arg1)->base_OnLeave();
29026
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 Py_INCREF(Py_None); resultobj = Py_None;
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29038 PyObject *resultobj;
29039 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29040 int arg2 ;
29041 int arg3 ;
29042 bool result;
29043 PyObject * obj0 = 0 ;
29044 PyObject * obj1 = 0 ;
29045 PyObject * obj2 = 0 ;
29046 char *kwnames[] = {
29047 (char *) "self",(char *) "x",(char *) "y", NULL
29048 };
29049
29050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29052 if (SWIG_arg_fail(1)) SWIG_fail;
29053 {
29054 arg2 = (int)(SWIG_As_int(obj1));
29055 if (SWIG_arg_fail(2)) SWIG_fail;
29056 }
29057 {
29058 arg3 = (int)(SWIG_As_int(obj2));
29059 if (SWIG_arg_fail(3)) SWIG_fail;
29060 }
29061 {
29062 PyThreadState* __tstate = wxPyBeginAllowThreads();
29063 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29064
29065 wxPyEndAllowThreads(__tstate);
29066 if (PyErr_Occurred()) SWIG_fail;
29067 }
29068 {
29069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29070 }
29071 return resultobj;
29072 fail:
29073 return NULL;
29074 }
29075
29076
29077 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj;
29079 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29080 bool result;
29081 PyObject * obj0 = 0 ;
29082 char *kwnames[] = {
29083 (char *) "self", NULL
29084 };
29085
29086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29088 if (SWIG_arg_fail(1)) SWIG_fail;
29089 {
29090 PyThreadState* __tstate = wxPyBeginAllowThreads();
29091 result = (bool)(arg1)->GetData();
29092
29093 wxPyEndAllowThreads(__tstate);
29094 if (PyErr_Occurred()) SWIG_fail;
29095 }
29096 {
29097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29098 }
29099 return resultobj;
29100 fail:
29101 return NULL;
29102 }
29103
29104
29105 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29106 PyObject *obj;
29107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29108 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29109 Py_INCREF(obj);
29110 return Py_BuildValue((char *)"");
29111 }
29112 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29113 PyObject *resultobj;
29114 wxPyTextDropTarget *result;
29115 char *kwnames[] = {
29116 NULL
29117 };
29118
29119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29123
29124 wxPyEndAllowThreads(__tstate);
29125 if (PyErr_Occurred()) SWIG_fail;
29126 }
29127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29128 return resultobj;
29129 fail:
29130 return NULL;
29131 }
29132
29133
29134 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29135 PyObject *resultobj;
29136 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29137 PyObject *arg2 = (PyObject *) 0 ;
29138 PyObject *arg3 = (PyObject *) 0 ;
29139 PyObject * obj0 = 0 ;
29140 PyObject * obj1 = 0 ;
29141 PyObject * obj2 = 0 ;
29142 char *kwnames[] = {
29143 (char *) "self",(char *) "self",(char *) "_class", NULL
29144 };
29145
29146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29148 if (SWIG_arg_fail(1)) SWIG_fail;
29149 arg2 = obj1;
29150 arg3 = obj2;
29151 {
29152 PyThreadState* __tstate = wxPyBeginAllowThreads();
29153 (arg1)->_setCallbackInfo(arg2,arg3);
29154
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 Py_INCREF(Py_None); resultobj = Py_None;
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29166 PyObject *resultobj;
29167 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29168 int arg2 ;
29169 int arg3 ;
29170 wxDragResult arg4 ;
29171 wxDragResult result;
29172 PyObject * obj0 = 0 ;
29173 PyObject * obj1 = 0 ;
29174 PyObject * obj2 = 0 ;
29175 PyObject * obj3 = 0 ;
29176 char *kwnames[] = {
29177 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29178 };
29179
29180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29182 if (SWIG_arg_fail(1)) SWIG_fail;
29183 {
29184 arg2 = (int)(SWIG_As_int(obj1));
29185 if (SWIG_arg_fail(2)) SWIG_fail;
29186 }
29187 {
29188 arg3 = (int)(SWIG_As_int(obj2));
29189 if (SWIG_arg_fail(3)) SWIG_fail;
29190 }
29191 {
29192 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29193 if (SWIG_arg_fail(4)) SWIG_fail;
29194 }
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29198
29199 wxPyEndAllowThreads(__tstate);
29200 if (PyErr_Occurred()) SWIG_fail;
29201 }
29202 resultobj = SWIG_From_int((result));
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29210 PyObject *resultobj;
29211 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29212 int arg2 ;
29213 int arg3 ;
29214 wxDragResult arg4 ;
29215 wxDragResult result;
29216 PyObject * obj0 = 0 ;
29217 PyObject * obj1 = 0 ;
29218 PyObject * obj2 = 0 ;
29219 PyObject * obj3 = 0 ;
29220 char *kwnames[] = {
29221 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29222 };
29223
29224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29226 if (SWIG_arg_fail(1)) SWIG_fail;
29227 {
29228 arg2 = (int)(SWIG_As_int(obj1));
29229 if (SWIG_arg_fail(2)) SWIG_fail;
29230 }
29231 {
29232 arg3 = (int)(SWIG_As_int(obj2));
29233 if (SWIG_arg_fail(3)) SWIG_fail;
29234 }
29235 {
29236 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29237 if (SWIG_arg_fail(4)) SWIG_fail;
29238 }
29239 {
29240 PyThreadState* __tstate = wxPyBeginAllowThreads();
29241 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29242
29243 wxPyEndAllowThreads(__tstate);
29244 if (PyErr_Occurred()) SWIG_fail;
29245 }
29246 resultobj = SWIG_From_int((result));
29247 return resultobj;
29248 fail:
29249 return NULL;
29250 }
29251
29252
29253 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29254 PyObject *resultobj;
29255 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29256 PyObject * obj0 = 0 ;
29257 char *kwnames[] = {
29258 (char *) "self", NULL
29259 };
29260
29261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29263 if (SWIG_arg_fail(1)) SWIG_fail;
29264 {
29265 PyThreadState* __tstate = wxPyBeginAllowThreads();
29266 (arg1)->base_OnLeave();
29267
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 Py_INCREF(Py_None); resultobj = Py_None;
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29279 PyObject *resultobj;
29280 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29281 int arg2 ;
29282 int arg3 ;
29283 bool result;
29284 PyObject * obj0 = 0 ;
29285 PyObject * obj1 = 0 ;
29286 PyObject * obj2 = 0 ;
29287 char *kwnames[] = {
29288 (char *) "self",(char *) "x",(char *) "y", NULL
29289 };
29290
29291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29293 if (SWIG_arg_fail(1)) SWIG_fail;
29294 {
29295 arg2 = (int)(SWIG_As_int(obj1));
29296 if (SWIG_arg_fail(2)) SWIG_fail;
29297 }
29298 {
29299 arg3 = (int)(SWIG_As_int(obj2));
29300 if (SWIG_arg_fail(3)) SWIG_fail;
29301 }
29302 {
29303 PyThreadState* __tstate = wxPyBeginAllowThreads();
29304 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29305
29306 wxPyEndAllowThreads(__tstate);
29307 if (PyErr_Occurred()) SWIG_fail;
29308 }
29309 {
29310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29311 }
29312 return resultobj;
29313 fail:
29314 return NULL;
29315 }
29316
29317
29318 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29319 PyObject *resultobj;
29320 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29321 int arg2 ;
29322 int arg3 ;
29323 wxDragResult arg4 ;
29324 wxDragResult result;
29325 PyObject * obj0 = 0 ;
29326 PyObject * obj1 = 0 ;
29327 PyObject * obj2 = 0 ;
29328 PyObject * obj3 = 0 ;
29329 char *kwnames[] = {
29330 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29331 };
29332
29333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29335 if (SWIG_arg_fail(1)) SWIG_fail;
29336 {
29337 arg2 = (int)(SWIG_As_int(obj1));
29338 if (SWIG_arg_fail(2)) SWIG_fail;
29339 }
29340 {
29341 arg3 = (int)(SWIG_As_int(obj2));
29342 if (SWIG_arg_fail(3)) SWIG_fail;
29343 }
29344 {
29345 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29346 if (SWIG_arg_fail(4)) SWIG_fail;
29347 }
29348 {
29349 PyThreadState* __tstate = wxPyBeginAllowThreads();
29350 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29351
29352 wxPyEndAllowThreads(__tstate);
29353 if (PyErr_Occurred()) SWIG_fail;
29354 }
29355 resultobj = SWIG_From_int((result));
29356 return resultobj;
29357 fail:
29358 return NULL;
29359 }
29360
29361
29362 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29363 PyObject *obj;
29364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29365 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29366 Py_INCREF(obj);
29367 return Py_BuildValue((char *)"");
29368 }
29369 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29370 PyObject *resultobj;
29371 wxPyFileDropTarget *result;
29372 char *kwnames[] = {
29373 NULL
29374 };
29375
29376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29377 {
29378 PyThreadState* __tstate = wxPyBeginAllowThreads();
29379 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29380
29381 wxPyEndAllowThreads(__tstate);
29382 if (PyErr_Occurred()) SWIG_fail;
29383 }
29384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29385 return resultobj;
29386 fail:
29387 return NULL;
29388 }
29389
29390
29391 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29392 PyObject *resultobj;
29393 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29394 PyObject *arg2 = (PyObject *) 0 ;
29395 PyObject *arg3 = (PyObject *) 0 ;
29396 PyObject * obj0 = 0 ;
29397 PyObject * obj1 = 0 ;
29398 PyObject * obj2 = 0 ;
29399 char *kwnames[] = {
29400 (char *) "self",(char *) "self",(char *) "_class", NULL
29401 };
29402
29403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29405 if (SWIG_arg_fail(1)) SWIG_fail;
29406 arg2 = obj1;
29407 arg3 = obj2;
29408 {
29409 PyThreadState* __tstate = wxPyBeginAllowThreads();
29410 (arg1)->_setCallbackInfo(arg2,arg3);
29411
29412 wxPyEndAllowThreads(__tstate);
29413 if (PyErr_Occurred()) SWIG_fail;
29414 }
29415 Py_INCREF(Py_None); resultobj = Py_None;
29416 return resultobj;
29417 fail:
29418 return NULL;
29419 }
29420
29421
29422 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29423 PyObject *resultobj;
29424 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29425 int arg2 ;
29426 int arg3 ;
29427 wxDragResult arg4 ;
29428 wxDragResult result;
29429 PyObject * obj0 = 0 ;
29430 PyObject * obj1 = 0 ;
29431 PyObject * obj2 = 0 ;
29432 PyObject * obj3 = 0 ;
29433 char *kwnames[] = {
29434 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29435 };
29436
29437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29439 if (SWIG_arg_fail(1)) SWIG_fail;
29440 {
29441 arg2 = (int)(SWIG_As_int(obj1));
29442 if (SWIG_arg_fail(2)) SWIG_fail;
29443 }
29444 {
29445 arg3 = (int)(SWIG_As_int(obj2));
29446 if (SWIG_arg_fail(3)) SWIG_fail;
29447 }
29448 {
29449 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29450 if (SWIG_arg_fail(4)) SWIG_fail;
29451 }
29452 {
29453 PyThreadState* __tstate = wxPyBeginAllowThreads();
29454 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29455
29456 wxPyEndAllowThreads(__tstate);
29457 if (PyErr_Occurred()) SWIG_fail;
29458 }
29459 resultobj = SWIG_From_int((result));
29460 return resultobj;
29461 fail:
29462 return NULL;
29463 }
29464
29465
29466 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29467 PyObject *resultobj;
29468 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29469 int arg2 ;
29470 int arg3 ;
29471 wxDragResult arg4 ;
29472 wxDragResult result;
29473 PyObject * obj0 = 0 ;
29474 PyObject * obj1 = 0 ;
29475 PyObject * obj2 = 0 ;
29476 PyObject * obj3 = 0 ;
29477 char *kwnames[] = {
29478 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29479 };
29480
29481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29483 if (SWIG_arg_fail(1)) SWIG_fail;
29484 {
29485 arg2 = (int)(SWIG_As_int(obj1));
29486 if (SWIG_arg_fail(2)) SWIG_fail;
29487 }
29488 {
29489 arg3 = (int)(SWIG_As_int(obj2));
29490 if (SWIG_arg_fail(3)) SWIG_fail;
29491 }
29492 {
29493 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29494 if (SWIG_arg_fail(4)) SWIG_fail;
29495 }
29496 {
29497 PyThreadState* __tstate = wxPyBeginAllowThreads();
29498 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29499
29500 wxPyEndAllowThreads(__tstate);
29501 if (PyErr_Occurred()) SWIG_fail;
29502 }
29503 resultobj = SWIG_From_int((result));
29504 return resultobj;
29505 fail:
29506 return NULL;
29507 }
29508
29509
29510 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29511 PyObject *resultobj;
29512 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29513 PyObject * obj0 = 0 ;
29514 char *kwnames[] = {
29515 (char *) "self", NULL
29516 };
29517
29518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29520 if (SWIG_arg_fail(1)) SWIG_fail;
29521 {
29522 PyThreadState* __tstate = wxPyBeginAllowThreads();
29523 (arg1)->base_OnLeave();
29524
29525 wxPyEndAllowThreads(__tstate);
29526 if (PyErr_Occurred()) SWIG_fail;
29527 }
29528 Py_INCREF(Py_None); resultobj = Py_None;
29529 return resultobj;
29530 fail:
29531 return NULL;
29532 }
29533
29534
29535 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29536 PyObject *resultobj;
29537 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29538 int arg2 ;
29539 int arg3 ;
29540 bool result;
29541 PyObject * obj0 = 0 ;
29542 PyObject * obj1 = 0 ;
29543 PyObject * obj2 = 0 ;
29544 char *kwnames[] = {
29545 (char *) "self",(char *) "x",(char *) "y", NULL
29546 };
29547
29548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29550 if (SWIG_arg_fail(1)) SWIG_fail;
29551 {
29552 arg2 = (int)(SWIG_As_int(obj1));
29553 if (SWIG_arg_fail(2)) SWIG_fail;
29554 }
29555 {
29556 arg3 = (int)(SWIG_As_int(obj2));
29557 if (SWIG_arg_fail(3)) SWIG_fail;
29558 }
29559 {
29560 PyThreadState* __tstate = wxPyBeginAllowThreads();
29561 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29562
29563 wxPyEndAllowThreads(__tstate);
29564 if (PyErr_Occurred()) SWIG_fail;
29565 }
29566 {
29567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29568 }
29569 return resultobj;
29570 fail:
29571 return NULL;
29572 }
29573
29574
29575 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29576 PyObject *resultobj;
29577 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29578 int arg2 ;
29579 int arg3 ;
29580 wxDragResult arg4 ;
29581 wxDragResult result;
29582 PyObject * obj0 = 0 ;
29583 PyObject * obj1 = 0 ;
29584 PyObject * obj2 = 0 ;
29585 PyObject * obj3 = 0 ;
29586 char *kwnames[] = {
29587 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29588 };
29589
29590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29592 if (SWIG_arg_fail(1)) SWIG_fail;
29593 {
29594 arg2 = (int)(SWIG_As_int(obj1));
29595 if (SWIG_arg_fail(2)) SWIG_fail;
29596 }
29597 {
29598 arg3 = (int)(SWIG_As_int(obj2));
29599 if (SWIG_arg_fail(3)) SWIG_fail;
29600 }
29601 {
29602 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29603 if (SWIG_arg_fail(4)) SWIG_fail;
29604 }
29605 {
29606 PyThreadState* __tstate = wxPyBeginAllowThreads();
29607 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29608
29609 wxPyEndAllowThreads(__tstate);
29610 if (PyErr_Occurred()) SWIG_fail;
29611 }
29612 resultobj = SWIG_From_int((result));
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29620 PyObject *obj;
29621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29622 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29623 Py_INCREF(obj);
29624 return Py_BuildValue((char *)"");
29625 }
29626 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29627 PyObject *resultobj;
29628 wxClipboard *result;
29629 char *kwnames[] = {
29630 NULL
29631 };
29632
29633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 result = (wxClipboard *)new wxClipboard();
29637
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29649 PyObject *resultobj;
29650 wxClipboard *arg1 = (wxClipboard *) 0 ;
29651 PyObject * obj0 = 0 ;
29652 char *kwnames[] = {
29653 (char *) "self", NULL
29654 };
29655
29656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29658 if (SWIG_arg_fail(1)) SWIG_fail;
29659 {
29660 PyThreadState* __tstate = wxPyBeginAllowThreads();
29661 delete arg1;
29662
29663 wxPyEndAllowThreads(__tstate);
29664 if (PyErr_Occurred()) SWIG_fail;
29665 }
29666 Py_INCREF(Py_None); resultobj = Py_None;
29667 return resultobj;
29668 fail:
29669 return NULL;
29670 }
29671
29672
29673 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29674 PyObject *resultobj;
29675 wxClipboard *arg1 = (wxClipboard *) 0 ;
29676 bool result;
29677 PyObject * obj0 = 0 ;
29678 char *kwnames[] = {
29679 (char *) "self", NULL
29680 };
29681
29682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29684 if (SWIG_arg_fail(1)) SWIG_fail;
29685 {
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 result = (bool)(arg1)->Open();
29688
29689 wxPyEndAllowThreads(__tstate);
29690 if (PyErr_Occurred()) SWIG_fail;
29691 }
29692 {
29693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29694 }
29695 return resultobj;
29696 fail:
29697 return NULL;
29698 }
29699
29700
29701 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29702 PyObject *resultobj;
29703 wxClipboard *arg1 = (wxClipboard *) 0 ;
29704 PyObject * obj0 = 0 ;
29705 char *kwnames[] = {
29706 (char *) "self", NULL
29707 };
29708
29709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29711 if (SWIG_arg_fail(1)) SWIG_fail;
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 (arg1)->Close();
29715
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 Py_INCREF(Py_None); resultobj = Py_None;
29720 return resultobj;
29721 fail:
29722 return NULL;
29723 }
29724
29725
29726 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29727 PyObject *resultobj;
29728 wxClipboard *arg1 = (wxClipboard *) 0 ;
29729 bool result;
29730 PyObject * obj0 = 0 ;
29731 char *kwnames[] = {
29732 (char *) "self", NULL
29733 };
29734
29735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29737 if (SWIG_arg_fail(1)) SWIG_fail;
29738 {
29739 PyThreadState* __tstate = wxPyBeginAllowThreads();
29740 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29741
29742 wxPyEndAllowThreads(__tstate);
29743 if (PyErr_Occurred()) SWIG_fail;
29744 }
29745 {
29746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29747 }
29748 return resultobj;
29749 fail:
29750 return NULL;
29751 }
29752
29753
29754 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29755 PyObject *resultobj;
29756 wxClipboard *arg1 = (wxClipboard *) 0 ;
29757 wxDataObject *arg2 = (wxDataObject *) 0 ;
29758 bool result;
29759 PyObject * obj0 = 0 ;
29760 PyObject * obj1 = 0 ;
29761 char *kwnames[] = {
29762 (char *) "self",(char *) "data", NULL
29763 };
29764
29765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29767 if (SWIG_arg_fail(1)) SWIG_fail;
29768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29769 if (SWIG_arg_fail(2)) SWIG_fail;
29770 {
29771 PyThreadState* __tstate = wxPyBeginAllowThreads();
29772 result = (bool)(arg1)->AddData(arg2);
29773
29774 wxPyEndAllowThreads(__tstate);
29775 if (PyErr_Occurred()) SWIG_fail;
29776 }
29777 {
29778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29779 }
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29787 PyObject *resultobj;
29788 wxClipboard *arg1 = (wxClipboard *) 0 ;
29789 wxDataObject *arg2 = (wxDataObject *) 0 ;
29790 bool result;
29791 PyObject * obj0 = 0 ;
29792 PyObject * obj1 = 0 ;
29793 char *kwnames[] = {
29794 (char *) "self",(char *) "data", NULL
29795 };
29796
29797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29799 if (SWIG_arg_fail(1)) SWIG_fail;
29800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29801 if (SWIG_arg_fail(2)) SWIG_fail;
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 result = (bool)(arg1)->SetData(arg2);
29805
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 {
29810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29811 }
29812 return resultobj;
29813 fail:
29814 return NULL;
29815 }
29816
29817
29818 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29819 PyObject *resultobj;
29820 wxClipboard *arg1 = (wxClipboard *) 0 ;
29821 wxDataFormat *arg2 = 0 ;
29822 bool result;
29823 PyObject * obj0 = 0 ;
29824 PyObject * obj1 = 0 ;
29825 char *kwnames[] = {
29826 (char *) "self",(char *) "format", NULL
29827 };
29828
29829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29831 if (SWIG_arg_fail(1)) SWIG_fail;
29832 {
29833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29834 if (SWIG_arg_fail(2)) SWIG_fail;
29835 if (arg2 == NULL) {
29836 SWIG_null_ref("wxDataFormat");
29837 }
29838 if (SWIG_arg_fail(2)) SWIG_fail;
29839 }
29840 {
29841 PyThreadState* __tstate = wxPyBeginAllowThreads();
29842 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29843
29844 wxPyEndAllowThreads(__tstate);
29845 if (PyErr_Occurred()) SWIG_fail;
29846 }
29847 {
29848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29849 }
29850 return resultobj;
29851 fail:
29852 return NULL;
29853 }
29854
29855
29856 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29857 PyObject *resultobj;
29858 wxClipboard *arg1 = (wxClipboard *) 0 ;
29859 wxDataObject *arg2 = 0 ;
29860 bool result;
29861 PyObject * obj0 = 0 ;
29862 PyObject * obj1 = 0 ;
29863 char *kwnames[] = {
29864 (char *) "self",(char *) "data", NULL
29865 };
29866
29867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29869 if (SWIG_arg_fail(1)) SWIG_fail;
29870 {
29871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29872 if (SWIG_arg_fail(2)) SWIG_fail;
29873 if (arg2 == NULL) {
29874 SWIG_null_ref("wxDataObject");
29875 }
29876 if (SWIG_arg_fail(2)) SWIG_fail;
29877 }
29878 {
29879 PyThreadState* __tstate = wxPyBeginAllowThreads();
29880 result = (bool)(arg1)->GetData(*arg2);
29881
29882 wxPyEndAllowThreads(__tstate);
29883 if (PyErr_Occurred()) SWIG_fail;
29884 }
29885 {
29886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29887 }
29888 return resultobj;
29889 fail:
29890 return NULL;
29891 }
29892
29893
29894 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29895 PyObject *resultobj;
29896 wxClipboard *arg1 = (wxClipboard *) 0 ;
29897 PyObject * obj0 = 0 ;
29898 char *kwnames[] = {
29899 (char *) "self", NULL
29900 };
29901
29902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29904 if (SWIG_arg_fail(1)) SWIG_fail;
29905 {
29906 PyThreadState* __tstate = wxPyBeginAllowThreads();
29907 (arg1)->Clear();
29908
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 Py_INCREF(Py_None); resultobj = Py_None;
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29920 PyObject *resultobj;
29921 wxClipboard *arg1 = (wxClipboard *) 0 ;
29922 bool result;
29923 PyObject * obj0 = 0 ;
29924 char *kwnames[] = {
29925 (char *) "self", NULL
29926 };
29927
29928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29930 if (SWIG_arg_fail(1)) SWIG_fail;
29931 {
29932 PyThreadState* __tstate = wxPyBeginAllowThreads();
29933 result = (bool)(arg1)->Flush();
29934
29935 wxPyEndAllowThreads(__tstate);
29936 if (PyErr_Occurred()) SWIG_fail;
29937 }
29938 {
29939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29940 }
29941 return resultobj;
29942 fail:
29943 return NULL;
29944 }
29945
29946
29947 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29948 PyObject *resultobj;
29949 wxClipboard *arg1 = (wxClipboard *) 0 ;
29950 bool arg2 = (bool) true ;
29951 PyObject * obj0 = 0 ;
29952 PyObject * obj1 = 0 ;
29953 char *kwnames[] = {
29954 (char *) "self",(char *) "primary", NULL
29955 };
29956
29957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29959 if (SWIG_arg_fail(1)) SWIG_fail;
29960 if (obj1) {
29961 {
29962 arg2 = (bool)(SWIG_As_bool(obj1));
29963 if (SWIG_arg_fail(2)) SWIG_fail;
29964 }
29965 }
29966 {
29967 PyThreadState* __tstate = wxPyBeginAllowThreads();
29968 (arg1)->UsePrimarySelection(arg2);
29969
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 Py_INCREF(Py_None); resultobj = Py_None;
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29981 PyObject *resultobj;
29982 wxClipboard *result;
29983 char *kwnames[] = {
29984 NULL
29985 };
29986
29987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29988 {
29989 PyThreadState* __tstate = wxPyBeginAllowThreads();
29990 result = (wxClipboard *)wxClipboard::Get();
29991
29992 wxPyEndAllowThreads(__tstate);
29993 if (PyErr_Occurred()) SWIG_fail;
29994 }
29995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29996 return resultobj;
29997 fail:
29998 return NULL;
29999 }
30000
30001
30002 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30003 PyObject *obj;
30004 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30005 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30006 Py_INCREF(obj);
30007 return Py_BuildValue((char *)"");
30008 }
30009 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30010 PyObject *resultobj;
30011 wxClipboard *arg1 = (wxClipboard *) NULL ;
30012 wxClipboardLocker *result;
30013 PyObject * obj0 = 0 ;
30014 char *kwnames[] = {
30015 (char *) "clipboard", NULL
30016 };
30017
30018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30019 if (obj0) {
30020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30021 if (SWIG_arg_fail(1)) SWIG_fail;
30022 }
30023 {
30024 PyThreadState* __tstate = wxPyBeginAllowThreads();
30025 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30026
30027 wxPyEndAllowThreads(__tstate);
30028 if (PyErr_Occurred()) SWIG_fail;
30029 }
30030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30031 return resultobj;
30032 fail:
30033 return NULL;
30034 }
30035
30036
30037 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30038 PyObject *resultobj;
30039 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30040 PyObject * obj0 = 0 ;
30041 char *kwnames[] = {
30042 (char *) "self", NULL
30043 };
30044
30045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30047 if (SWIG_arg_fail(1)) SWIG_fail;
30048 {
30049 PyThreadState* __tstate = wxPyBeginAllowThreads();
30050 delete arg1;
30051
30052 wxPyEndAllowThreads(__tstate);
30053 if (PyErr_Occurred()) SWIG_fail;
30054 }
30055 Py_INCREF(Py_None); resultobj = Py_None;
30056 return resultobj;
30057 fail:
30058 return NULL;
30059 }
30060
30061
30062 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30063 PyObject *resultobj;
30064 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30065 bool result;
30066 PyObject * obj0 = 0 ;
30067 char *kwnames[] = {
30068 (char *) "self", NULL
30069 };
30070
30071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30073 if (SWIG_arg_fail(1)) SWIG_fail;
30074 {
30075 PyThreadState* __tstate = wxPyBeginAllowThreads();
30076 result = (bool)wxClipboardLocker___nonzero__(arg1);
30077
30078 wxPyEndAllowThreads(__tstate);
30079 if (PyErr_Occurred()) SWIG_fail;
30080 }
30081 {
30082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30083 }
30084 return resultobj;
30085 fail:
30086 return NULL;
30087 }
30088
30089
30090 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30091 PyObject *obj;
30092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30093 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30094 Py_INCREF(obj);
30095 return Py_BuildValue((char *)"");
30096 }
30097 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30098 PyObject *resultobj;
30099 int arg1 = (int) 0 ;
30100 int arg2 = (int) 0 ;
30101 int arg3 = (int) 0 ;
30102 int arg4 = (int) 0 ;
30103 wxVideoMode *result;
30104 PyObject * obj0 = 0 ;
30105 PyObject * obj1 = 0 ;
30106 PyObject * obj2 = 0 ;
30107 PyObject * obj3 = 0 ;
30108 char *kwnames[] = {
30109 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30110 };
30111
30112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30113 if (obj0) {
30114 {
30115 arg1 = (int)(SWIG_As_int(obj0));
30116 if (SWIG_arg_fail(1)) SWIG_fail;
30117 }
30118 }
30119 if (obj1) {
30120 {
30121 arg2 = (int)(SWIG_As_int(obj1));
30122 if (SWIG_arg_fail(2)) SWIG_fail;
30123 }
30124 }
30125 if (obj2) {
30126 {
30127 arg3 = (int)(SWIG_As_int(obj2));
30128 if (SWIG_arg_fail(3)) SWIG_fail;
30129 }
30130 }
30131 if (obj3) {
30132 {
30133 arg4 = (int)(SWIG_As_int(obj3));
30134 if (SWIG_arg_fail(4)) SWIG_fail;
30135 }
30136 }
30137 {
30138 PyThreadState* __tstate = wxPyBeginAllowThreads();
30139 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30140
30141 wxPyEndAllowThreads(__tstate);
30142 if (PyErr_Occurred()) SWIG_fail;
30143 }
30144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30145 return resultobj;
30146 fail:
30147 return NULL;
30148 }
30149
30150
30151 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30152 PyObject *resultobj;
30153 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30154 PyObject * obj0 = 0 ;
30155 char *kwnames[] = {
30156 (char *) "self", NULL
30157 };
30158
30159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30161 if (SWIG_arg_fail(1)) SWIG_fail;
30162 {
30163 PyThreadState* __tstate = wxPyBeginAllowThreads();
30164 delete arg1;
30165
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 Py_INCREF(Py_None); resultobj = Py_None;
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj;
30178 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30179 wxVideoMode *arg2 = 0 ;
30180 bool result;
30181 PyObject * obj0 = 0 ;
30182 PyObject * obj1 = 0 ;
30183 char *kwnames[] = {
30184 (char *) "self",(char *) "other", NULL
30185 };
30186
30187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30189 if (SWIG_arg_fail(1)) SWIG_fail;
30190 {
30191 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30192 if (SWIG_arg_fail(2)) SWIG_fail;
30193 if (arg2 == NULL) {
30194 SWIG_null_ref("wxVideoMode");
30195 }
30196 if (SWIG_arg_fail(2)) SWIG_fail;
30197 }
30198 {
30199 PyThreadState* __tstate = wxPyBeginAllowThreads();
30200 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30201
30202 wxPyEndAllowThreads(__tstate);
30203 if (PyErr_Occurred()) SWIG_fail;
30204 }
30205 {
30206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30207 }
30208 return resultobj;
30209 fail:
30210 return NULL;
30211 }
30212
30213
30214 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30215 PyObject *resultobj;
30216 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30217 int result;
30218 PyObject * obj0 = 0 ;
30219 char *kwnames[] = {
30220 (char *) "self", NULL
30221 };
30222
30223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30225 if (SWIG_arg_fail(1)) SWIG_fail;
30226 {
30227 PyThreadState* __tstate = wxPyBeginAllowThreads();
30228 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30229
30230 wxPyEndAllowThreads(__tstate);
30231 if (PyErr_Occurred()) SWIG_fail;
30232 }
30233 {
30234 resultobj = SWIG_From_int((int)(result));
30235 }
30236 return resultobj;
30237 fail:
30238 return NULL;
30239 }
30240
30241
30242 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30243 PyObject *resultobj;
30244 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30245 int result;
30246 PyObject * obj0 = 0 ;
30247 char *kwnames[] = {
30248 (char *) "self", NULL
30249 };
30250
30251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30253 if (SWIG_arg_fail(1)) SWIG_fail;
30254 {
30255 PyThreadState* __tstate = wxPyBeginAllowThreads();
30256 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30257
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 {
30262 resultobj = SWIG_From_int((int)(result));
30263 }
30264 return resultobj;
30265 fail:
30266 return NULL;
30267 }
30268
30269
30270 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30271 PyObject *resultobj;
30272 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30273 int result;
30274 PyObject * obj0 = 0 ;
30275 char *kwnames[] = {
30276 (char *) "self", NULL
30277 };
30278
30279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30281 if (SWIG_arg_fail(1)) SWIG_fail;
30282 {
30283 PyThreadState* __tstate = wxPyBeginAllowThreads();
30284 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30285
30286 wxPyEndAllowThreads(__tstate);
30287 if (PyErr_Occurred()) SWIG_fail;
30288 }
30289 {
30290 resultobj = SWIG_From_int((int)(result));
30291 }
30292 return resultobj;
30293 fail:
30294 return NULL;
30295 }
30296
30297
30298 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30299 PyObject *resultobj;
30300 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30301 bool result;
30302 PyObject * obj0 = 0 ;
30303 char *kwnames[] = {
30304 (char *) "self", NULL
30305 };
30306
30307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30309 if (SWIG_arg_fail(1)) SWIG_fail;
30310 {
30311 PyThreadState* __tstate = wxPyBeginAllowThreads();
30312 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30313
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 {
30318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30319 }
30320 return resultobj;
30321 fail:
30322 return NULL;
30323 }
30324
30325
30326 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30327 PyObject *resultobj;
30328 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30329 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30330 bool result;
30331 PyObject * obj0 = 0 ;
30332 PyObject * obj1 = 0 ;
30333 char *kwnames[] = {
30334 (char *) "self",(char *) "other", NULL
30335 };
30336
30337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30339 if (SWIG_arg_fail(1)) SWIG_fail;
30340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30341 if (SWIG_arg_fail(2)) SWIG_fail;
30342 {
30343 PyThreadState* __tstate = wxPyBeginAllowThreads();
30344 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30345
30346 wxPyEndAllowThreads(__tstate);
30347 if (PyErr_Occurred()) SWIG_fail;
30348 }
30349 {
30350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30351 }
30352 return resultobj;
30353 fail:
30354 return NULL;
30355 }
30356
30357
30358 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30359 PyObject *resultobj;
30360 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30361 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30362 bool result;
30363 PyObject * obj0 = 0 ;
30364 PyObject * obj1 = 0 ;
30365 char *kwnames[] = {
30366 (char *) "self",(char *) "other", NULL
30367 };
30368
30369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30371 if (SWIG_arg_fail(1)) SWIG_fail;
30372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30373 if (SWIG_arg_fail(2)) SWIG_fail;
30374 {
30375 PyThreadState* __tstate = wxPyBeginAllowThreads();
30376 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30377
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 {
30382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30383 }
30384 return resultobj;
30385 fail:
30386 return NULL;
30387 }
30388
30389
30390 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30391 PyObject *resultobj;
30392 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30393 int arg2 ;
30394 PyObject * obj0 = 0 ;
30395 PyObject * obj1 = 0 ;
30396 char *kwnames[] = {
30397 (char *) "self",(char *) "w", NULL
30398 };
30399
30400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30402 if (SWIG_arg_fail(1)) SWIG_fail;
30403 {
30404 arg2 = (int)(SWIG_As_int(obj1));
30405 if (SWIG_arg_fail(2)) SWIG_fail;
30406 }
30407 if (arg1) (arg1)->w = arg2;
30408
30409 Py_INCREF(Py_None); resultobj = Py_None;
30410 return resultobj;
30411 fail:
30412 return NULL;
30413 }
30414
30415
30416 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30417 PyObject *resultobj;
30418 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30419 int result;
30420 PyObject * obj0 = 0 ;
30421 char *kwnames[] = {
30422 (char *) "self", NULL
30423 };
30424
30425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30427 if (SWIG_arg_fail(1)) SWIG_fail;
30428 result = (int) ((arg1)->w);
30429
30430 {
30431 resultobj = SWIG_From_int((int)(result));
30432 }
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30440 PyObject *resultobj;
30441 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30442 int arg2 ;
30443 PyObject * obj0 = 0 ;
30444 PyObject * obj1 = 0 ;
30445 char *kwnames[] = {
30446 (char *) "self",(char *) "h", NULL
30447 };
30448
30449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30451 if (SWIG_arg_fail(1)) SWIG_fail;
30452 {
30453 arg2 = (int)(SWIG_As_int(obj1));
30454 if (SWIG_arg_fail(2)) SWIG_fail;
30455 }
30456 if (arg1) (arg1)->h = arg2;
30457
30458 Py_INCREF(Py_None); resultobj = Py_None;
30459 return resultobj;
30460 fail:
30461 return NULL;
30462 }
30463
30464
30465 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30466 PyObject *resultobj;
30467 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30468 int result;
30469 PyObject * obj0 = 0 ;
30470 char *kwnames[] = {
30471 (char *) "self", NULL
30472 };
30473
30474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30476 if (SWIG_arg_fail(1)) SWIG_fail;
30477 result = (int) ((arg1)->h);
30478
30479 {
30480 resultobj = SWIG_From_int((int)(result));
30481 }
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj;
30490 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30491 int arg2 ;
30492 PyObject * obj0 = 0 ;
30493 PyObject * obj1 = 0 ;
30494 char *kwnames[] = {
30495 (char *) "self",(char *) "bpp", NULL
30496 };
30497
30498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30500 if (SWIG_arg_fail(1)) SWIG_fail;
30501 {
30502 arg2 = (int)(SWIG_As_int(obj1));
30503 if (SWIG_arg_fail(2)) SWIG_fail;
30504 }
30505 if (arg1) (arg1)->bpp = arg2;
30506
30507 Py_INCREF(Py_None); resultobj = Py_None;
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30515 PyObject *resultobj;
30516 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30517 int result;
30518 PyObject * obj0 = 0 ;
30519 char *kwnames[] = {
30520 (char *) "self", NULL
30521 };
30522
30523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30525 if (SWIG_arg_fail(1)) SWIG_fail;
30526 result = (int) ((arg1)->bpp);
30527
30528 {
30529 resultobj = SWIG_From_int((int)(result));
30530 }
30531 return resultobj;
30532 fail:
30533 return NULL;
30534 }
30535
30536
30537 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30538 PyObject *resultobj;
30539 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30540 int arg2 ;
30541 PyObject * obj0 = 0 ;
30542 PyObject * obj1 = 0 ;
30543 char *kwnames[] = {
30544 (char *) "self",(char *) "refresh", NULL
30545 };
30546
30547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30549 if (SWIG_arg_fail(1)) SWIG_fail;
30550 {
30551 arg2 = (int)(SWIG_As_int(obj1));
30552 if (SWIG_arg_fail(2)) SWIG_fail;
30553 }
30554 if (arg1) (arg1)->refresh = arg2;
30555
30556 Py_INCREF(Py_None); resultobj = Py_None;
30557 return resultobj;
30558 fail:
30559 return NULL;
30560 }
30561
30562
30563 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30564 PyObject *resultobj;
30565 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30566 int result;
30567 PyObject * obj0 = 0 ;
30568 char *kwnames[] = {
30569 (char *) "self", NULL
30570 };
30571
30572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30574 if (SWIG_arg_fail(1)) SWIG_fail;
30575 result = (int) ((arg1)->refresh);
30576
30577 {
30578 resultobj = SWIG_From_int((int)(result));
30579 }
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30587 PyObject *obj;
30588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30589 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30590 Py_INCREF(obj);
30591 return Py_BuildValue((char *)"");
30592 }
30593 static int _wrap_DefaultVideoMode_set(PyObject *) {
30594 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30595 return 1;
30596 }
30597
30598
30599 static PyObject *_wrap_DefaultVideoMode_get(void) {
30600 PyObject *pyobj;
30601
30602 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30603 return pyobj;
30604 }
30605
30606
30607 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30608 PyObject *resultobj;
30609 size_t arg1 = (size_t) 0 ;
30610 wxDisplay *result;
30611 PyObject * obj0 = 0 ;
30612 char *kwnames[] = {
30613 (char *) "index", NULL
30614 };
30615
30616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30617 if (obj0) {
30618 {
30619 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30620 if (SWIG_arg_fail(1)) SWIG_fail;
30621 }
30622 }
30623 {
30624 PyThreadState* __tstate = wxPyBeginAllowThreads();
30625 result = (wxDisplay *)new wxDisplay(arg1);
30626
30627 wxPyEndAllowThreads(__tstate);
30628 if (PyErr_Occurred()) SWIG_fail;
30629 }
30630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30631 return resultobj;
30632 fail:
30633 return NULL;
30634 }
30635
30636
30637 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30638 PyObject *resultobj;
30639 wxDisplay *arg1 = (wxDisplay *) 0 ;
30640 PyObject * obj0 = 0 ;
30641 char *kwnames[] = {
30642 (char *) "self", NULL
30643 };
30644
30645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30647 if (SWIG_arg_fail(1)) SWIG_fail;
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 delete arg1;
30651
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 Py_INCREF(Py_None); resultobj = Py_None;
30656 return resultobj;
30657 fail:
30658 return NULL;
30659 }
30660
30661
30662 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30663 PyObject *resultobj;
30664 size_t result;
30665 char *kwnames[] = {
30666 NULL
30667 };
30668
30669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30670 {
30671 PyThreadState* __tstate = wxPyBeginAllowThreads();
30672 result = (size_t)wxDisplay::GetCount();
30673
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 {
30678 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30679 }
30680 return resultobj;
30681 fail:
30682 return NULL;
30683 }
30684
30685
30686 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30687 PyObject *resultobj;
30688 wxPoint *arg1 = 0 ;
30689 int result;
30690 wxPoint temp1 ;
30691 PyObject * obj0 = 0 ;
30692 char *kwnames[] = {
30693 (char *) "pt", NULL
30694 };
30695
30696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30697 {
30698 arg1 = &temp1;
30699 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30700 }
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30704
30705 wxPyEndAllowThreads(__tstate);
30706 if (PyErr_Occurred()) SWIG_fail;
30707 }
30708 {
30709 resultobj = SWIG_From_int((int)(result));
30710 }
30711 return resultobj;
30712 fail:
30713 return NULL;
30714 }
30715
30716
30717 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30718 PyObject *resultobj;
30719 wxWindow *arg1 = (wxWindow *) 0 ;
30720 int result;
30721 PyObject * obj0 = 0 ;
30722 char *kwnames[] = {
30723 (char *) "window", NULL
30724 };
30725
30726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30728 if (SWIG_arg_fail(1)) SWIG_fail;
30729 {
30730 PyThreadState* __tstate = wxPyBeginAllowThreads();
30731 result = (int)Display_GetFromWindow(arg1);
30732
30733 wxPyEndAllowThreads(__tstate);
30734 if (PyErr_Occurred()) SWIG_fail;
30735 }
30736 {
30737 resultobj = SWIG_From_int((int)(result));
30738 }
30739 return resultobj;
30740 fail:
30741 return NULL;
30742 }
30743
30744
30745 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30746 PyObject *resultobj;
30747 wxDisplay *arg1 = (wxDisplay *) 0 ;
30748 bool result;
30749 PyObject * obj0 = 0 ;
30750 char *kwnames[] = {
30751 (char *) "self", NULL
30752 };
30753
30754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30756 if (SWIG_arg_fail(1)) SWIG_fail;
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = (bool)((wxDisplay const *)arg1)->IsOk();
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 {
30765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30766 }
30767 return resultobj;
30768 fail:
30769 return NULL;
30770 }
30771
30772
30773 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30774 PyObject *resultobj;
30775 wxDisplay *arg1 = (wxDisplay *) 0 ;
30776 wxRect result;
30777 PyObject * obj0 = 0 ;
30778 char *kwnames[] = {
30779 (char *) "self", NULL
30780 };
30781
30782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30784 if (SWIG_arg_fail(1)) SWIG_fail;
30785 {
30786 PyThreadState* __tstate = wxPyBeginAllowThreads();
30787 result = ((wxDisplay const *)arg1)->GetGeometry();
30788
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 {
30793 wxRect * resultptr;
30794 resultptr = new wxRect((wxRect &)(result));
30795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30796 }
30797 return resultobj;
30798 fail:
30799 return NULL;
30800 }
30801
30802
30803 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30804 PyObject *resultobj;
30805 wxDisplay *arg1 = (wxDisplay *) 0 ;
30806 wxString result;
30807 PyObject * obj0 = 0 ;
30808 char *kwnames[] = {
30809 (char *) "self", NULL
30810 };
30811
30812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30814 if (SWIG_arg_fail(1)) SWIG_fail;
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 result = ((wxDisplay const *)arg1)->GetName();
30818
30819 wxPyEndAllowThreads(__tstate);
30820 if (PyErr_Occurred()) SWIG_fail;
30821 }
30822 {
30823 #if wxUSE_UNICODE
30824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30825 #else
30826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30827 #endif
30828 }
30829 return resultobj;
30830 fail:
30831 return NULL;
30832 }
30833
30834
30835 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30836 PyObject *resultobj;
30837 wxDisplay *arg1 = (wxDisplay *) 0 ;
30838 bool result;
30839 PyObject * obj0 = 0 ;
30840 char *kwnames[] = {
30841 (char *) "self", NULL
30842 };
30843
30844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30846 if (SWIG_arg_fail(1)) SWIG_fail;
30847 {
30848 PyThreadState* __tstate = wxPyBeginAllowThreads();
30849 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30850
30851 wxPyEndAllowThreads(__tstate);
30852 if (PyErr_Occurred()) SWIG_fail;
30853 }
30854 {
30855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30856 }
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30864 PyObject *resultobj;
30865 wxDisplay *arg1 = (wxDisplay *) 0 ;
30866 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30867 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30868 PyObject *result;
30869 PyObject * obj0 = 0 ;
30870 PyObject * obj1 = 0 ;
30871 char *kwnames[] = {
30872 (char *) "self",(char *) "mode", NULL
30873 };
30874
30875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30877 if (SWIG_arg_fail(1)) SWIG_fail;
30878 if (obj1) {
30879 {
30880 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30881 if (SWIG_arg_fail(2)) SWIG_fail;
30882 if (arg2 == NULL) {
30883 SWIG_null_ref("wxVideoMode");
30884 }
30885 if (SWIG_arg_fail(2)) SWIG_fail;
30886 }
30887 }
30888 {
30889 PyThreadState* __tstate = wxPyBeginAllowThreads();
30890 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30891
30892 wxPyEndAllowThreads(__tstate);
30893 if (PyErr_Occurred()) SWIG_fail;
30894 }
30895 resultobj = result;
30896 return resultobj;
30897 fail:
30898 return NULL;
30899 }
30900
30901
30902 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30903 PyObject *resultobj;
30904 wxDisplay *arg1 = (wxDisplay *) 0 ;
30905 wxVideoMode result;
30906 PyObject * obj0 = 0 ;
30907 char *kwnames[] = {
30908 (char *) "self", NULL
30909 };
30910
30911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30913 if (SWIG_arg_fail(1)) SWIG_fail;
30914 {
30915 PyThreadState* __tstate = wxPyBeginAllowThreads();
30916 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30917
30918 wxPyEndAllowThreads(__tstate);
30919 if (PyErr_Occurred()) SWIG_fail;
30920 }
30921 {
30922 wxVideoMode * resultptr;
30923 resultptr = new wxVideoMode((wxVideoMode &)(result));
30924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30925 }
30926 return resultobj;
30927 fail:
30928 return NULL;
30929 }
30930
30931
30932 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30933 PyObject *resultobj;
30934 wxDisplay *arg1 = (wxDisplay *) 0 ;
30935 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30936 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30937 bool result;
30938 PyObject * obj0 = 0 ;
30939 PyObject * obj1 = 0 ;
30940 char *kwnames[] = {
30941 (char *) "self",(char *) "mode", NULL
30942 };
30943
30944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30946 if (SWIG_arg_fail(1)) SWIG_fail;
30947 if (obj1) {
30948 {
30949 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30950 if (SWIG_arg_fail(2)) SWIG_fail;
30951 if (arg2 == NULL) {
30952 SWIG_null_ref("wxVideoMode");
30953 }
30954 if (SWIG_arg_fail(2)) SWIG_fail;
30955 }
30956 }
30957 {
30958 PyThreadState* __tstate = wxPyBeginAllowThreads();
30959 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30960
30961 wxPyEndAllowThreads(__tstate);
30962 if (PyErr_Occurred()) SWIG_fail;
30963 }
30964 {
30965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30966 }
30967 return resultobj;
30968 fail:
30969 return NULL;
30970 }
30971
30972
30973 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30974 PyObject *resultobj;
30975 wxDisplay *arg1 = (wxDisplay *) 0 ;
30976 PyObject * obj0 = 0 ;
30977 char *kwnames[] = {
30978 (char *) "self", NULL
30979 };
30980
30981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30983 if (SWIG_arg_fail(1)) SWIG_fail;
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 (arg1)->ResetMode();
30987
30988 wxPyEndAllowThreads(__tstate);
30989 if (PyErr_Occurred()) SWIG_fail;
30990 }
30991 Py_INCREF(Py_None); resultobj = Py_None;
30992 return resultobj;
30993 fail:
30994 return NULL;
30995 }
30996
30997
30998 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30999 PyObject *obj;
31000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31001 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31002 Py_INCREF(obj);
31003 return Py_BuildValue((char *)"");
31004 }
31005 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31006 PyObject *resultobj;
31007 wxStandardPaths *result;
31008 char *kwnames[] = {
31009 NULL
31010 };
31011
31012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31013 {
31014 PyThreadState* __tstate = wxPyBeginAllowThreads();
31015 result = (wxStandardPaths *)StandardPaths_Get();
31016
31017 wxPyEndAllowThreads(__tstate);
31018 if (PyErr_Occurred()) SWIG_fail;
31019 }
31020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31021 return resultobj;
31022 fail:
31023 return NULL;
31024 }
31025
31026
31027 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31028 PyObject *resultobj;
31029 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31030 wxString result;
31031 PyObject * obj0 = 0 ;
31032 char *kwnames[] = {
31033 (char *) "self", NULL
31034 };
31035
31036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31038 if (SWIG_arg_fail(1)) SWIG_fail;
31039 {
31040 PyThreadState* __tstate = wxPyBeginAllowThreads();
31041 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31042
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 {
31047 #if wxUSE_UNICODE
31048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31049 #else
31050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31051 #endif
31052 }
31053 return resultobj;
31054 fail:
31055 return NULL;
31056 }
31057
31058
31059 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31060 PyObject *resultobj;
31061 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31062 wxString result;
31063 PyObject * obj0 = 0 ;
31064 char *kwnames[] = {
31065 (char *) "self", NULL
31066 };
31067
31068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31070 if (SWIG_arg_fail(1)) SWIG_fail;
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31074
31075 wxPyEndAllowThreads(__tstate);
31076 if (PyErr_Occurred()) SWIG_fail;
31077 }
31078 {
31079 #if wxUSE_UNICODE
31080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31081 #else
31082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31083 #endif
31084 }
31085 return resultobj;
31086 fail:
31087 return NULL;
31088 }
31089
31090
31091 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31092 PyObject *resultobj;
31093 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31094 wxString result;
31095 PyObject * obj0 = 0 ;
31096 char *kwnames[] = {
31097 (char *) "self", NULL
31098 };
31099
31100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31102 if (SWIG_arg_fail(1)) SWIG_fail;
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31106
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 {
31111 #if wxUSE_UNICODE
31112 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31113 #else
31114 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31115 #endif
31116 }
31117 return resultobj;
31118 fail:
31119 return NULL;
31120 }
31121
31122
31123 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31124 PyObject *resultobj;
31125 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31126 wxString result;
31127 PyObject * obj0 = 0 ;
31128 char *kwnames[] = {
31129 (char *) "self", NULL
31130 };
31131
31132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31134 if (SWIG_arg_fail(1)) SWIG_fail;
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31138
31139 wxPyEndAllowThreads(__tstate);
31140 if (PyErr_Occurred()) SWIG_fail;
31141 }
31142 {
31143 #if wxUSE_UNICODE
31144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31145 #else
31146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31147 #endif
31148 }
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj;
31157 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31158 wxString result;
31159 PyObject * obj0 = 0 ;
31160 char *kwnames[] = {
31161 (char *) "self", NULL
31162 };
31163
31164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31166 if (SWIG_arg_fail(1)) SWIG_fail;
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31170
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 {
31175 #if wxUSE_UNICODE
31176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31177 #else
31178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31179 #endif
31180 }
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31188 PyObject *resultobj;
31189 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31190 wxString result;
31191 PyObject * obj0 = 0 ;
31192 char *kwnames[] = {
31193 (char *) "self", NULL
31194 };
31195
31196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31198 if (SWIG_arg_fail(1)) SWIG_fail;
31199 {
31200 PyThreadState* __tstate = wxPyBeginAllowThreads();
31201 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31202
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 {
31207 #if wxUSE_UNICODE
31208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31209 #else
31210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31211 #endif
31212 }
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31220 PyObject *resultobj;
31221 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31222 wxString result;
31223 PyObject * obj0 = 0 ;
31224 char *kwnames[] = {
31225 (char *) "self", NULL
31226 };
31227
31228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31230 if (SWIG_arg_fail(1)) SWIG_fail;
31231 {
31232 PyThreadState* __tstate = wxPyBeginAllowThreads();
31233 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31234
31235 wxPyEndAllowThreads(__tstate);
31236 if (PyErr_Occurred()) SWIG_fail;
31237 }
31238 {
31239 #if wxUSE_UNICODE
31240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31241 #else
31242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31243 #endif
31244 }
31245 return resultobj;
31246 fail:
31247 return NULL;
31248 }
31249
31250
31251 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31252 PyObject *resultobj;
31253 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31254 wxString *arg2 = 0 ;
31255 bool temp2 = false ;
31256 PyObject * obj0 = 0 ;
31257 PyObject * obj1 = 0 ;
31258 char *kwnames[] = {
31259 (char *) "self",(char *) "prefix", NULL
31260 };
31261
31262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31264 if (SWIG_arg_fail(1)) SWIG_fail;
31265 {
31266 arg2 = wxString_in_helper(obj1);
31267 if (arg2 == NULL) SWIG_fail;
31268 temp2 = true;
31269 }
31270 {
31271 PyThreadState* __tstate = wxPyBeginAllowThreads();
31272 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31273
31274 wxPyEndAllowThreads(__tstate);
31275 if (PyErr_Occurred()) SWIG_fail;
31276 }
31277 Py_INCREF(Py_None); resultobj = Py_None;
31278 {
31279 if (temp2)
31280 delete arg2;
31281 }
31282 return resultobj;
31283 fail:
31284 {
31285 if (temp2)
31286 delete arg2;
31287 }
31288 return NULL;
31289 }
31290
31291
31292 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31293 PyObject *resultobj;
31294 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31295 wxString result;
31296 PyObject * obj0 = 0 ;
31297 char *kwnames[] = {
31298 (char *) "self", NULL
31299 };
31300
31301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31303 if (SWIG_arg_fail(1)) SWIG_fail;
31304 {
31305 PyThreadState* __tstate = wxPyBeginAllowThreads();
31306 result = wxStandardPaths_GetInstallPrefix(arg1);
31307
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 {
31312 #if wxUSE_UNICODE
31313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31314 #else
31315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31316 #endif
31317 }
31318 return resultobj;
31319 fail:
31320 return NULL;
31321 }
31322
31323
31324 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31325 PyObject *obj;
31326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31327 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31328 Py_INCREF(obj);
31329 return Py_BuildValue((char *)"");
31330 }
31331 static PyMethodDef SwigMethods[] = {
31332 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31339 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31346 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31410 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31418 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31436 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31439 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31442 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31445 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31451 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31465 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31471 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31477 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31480 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31494 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31497 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31498 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31501 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31528 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31530 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31532 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31534 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31541 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31547 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31561 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31565 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31568 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31585 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31593 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31640 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31658 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31668 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31684 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31700 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31714 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31723 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31766 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31769 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31772 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31776 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31869 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31870 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31871 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31872 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31889 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31934 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31968 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31976 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31977 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31982 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31991 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31998 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32001 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32004 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32009 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32012 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32016 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32019 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32023 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32024 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32028 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32032 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32036 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32046 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32057 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32065 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32073 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32087 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32091 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32109 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32123 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32134 { NULL, NULL, 0, NULL }
32135 };
32136
32137
32138 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32139
32140 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32141 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32142 }
32143 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32144 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32145 }
32146 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32147 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32148 }
32149 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32150 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32151 }
32152 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32153 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32154 }
32155 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32156 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32157 }
32158 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32159 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32160 }
32161 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32162 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32163 }
32164 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32165 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32166 }
32167 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32168 return (void *)((wxEvent *) ((wxPyEvent *) x));
32169 }
32170 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32171 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32172 }
32173 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32174 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32175 }
32176 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32177 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32178 }
32179 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32180 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32181 }
32182 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32183 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32184 }
32185 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32186 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32187 }
32188 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32189 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32190 }
32191 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32192 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32193 }
32194 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32195 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32196 }
32197 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32198 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32199 }
32200 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32201 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32202 }
32203 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32204 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32205 }
32206 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32207 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32208 }
32209 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32210 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32211 }
32212 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32213 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32214 }
32215 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32216 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32217 }
32218 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32219 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32220 }
32221 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32222 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32223 }
32224 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32225 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32226 }
32227 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32228 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32229 }
32230 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32231 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32232 }
32233 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32234 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32235 }
32236 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32237 return (void *)((wxEvent *) ((wxShowEvent *) x));
32238 }
32239 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32240 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32241 }
32242 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32243 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32244 }
32245 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32246 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32247 }
32248 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32249 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32250 }
32251 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32252 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32253 }
32254 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32255 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32256 }
32257 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32258 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32259 }
32260 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32261 return (void *)((wxConfigBase *) ((wxConfig *) x));
32262 }
32263 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32264 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32265 }
32266 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32267 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32268 }
32269 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32270 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32271 }
32272 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32273 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32274 }
32275 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32276 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32277 }
32278 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32279 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32280 }
32281 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32282 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32283 }
32284 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32285 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32286 }
32287 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32288 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32289 }
32290 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32291 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32292 }
32293 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32294 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32295 }
32296 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32297 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32298 }
32299 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32300 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32301 }
32302 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32303 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32304 }
32305 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32306 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32307 }
32308 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32309 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32310 }
32311 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32312 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32313 }
32314 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32315 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32316 }
32317 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32318 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32319 }
32320 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32321 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32322 }
32323 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32324 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32325 }
32326 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32327 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32328 }
32329 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32330 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32331 }
32332 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32333 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32334 }
32335 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32336 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32337 }
32338 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32339 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32340 }
32341 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32342 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32343 }
32344 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32345 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32346 }
32347 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32348 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32349 }
32350 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32351 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32352 }
32353 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32354 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32355 }
32356 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32357 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32358 }
32359 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32360 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32361 }
32362 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32363 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32364 }
32365 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32366 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32367 }
32368 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32369 return (void *)((wxObject *) ((wxSizerItem *) x));
32370 }
32371 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32372 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32373 }
32374 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32375 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32376 }
32377 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32378 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32379 }
32380 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32381 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32382 }
32383 static void *_p_wxSizerTo_p_wxObject(void *x) {
32384 return (void *)((wxObject *) ((wxSizer *) x));
32385 }
32386 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32387 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32388 }
32389 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32390 return (void *)((wxObject *) ((wxFileHistory *) x));
32391 }
32392 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32393 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32394 }
32395 static void *_p_wxEventTo_p_wxObject(void *x) {
32396 return (void *)((wxObject *) ((wxEvent *) x));
32397 }
32398 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32399 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32400 }
32401 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32402 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32403 }
32404 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32405 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32406 }
32407 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32408 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32409 }
32410 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32411 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32412 }
32413 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32414 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32415 }
32416 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32417 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32418 }
32419 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32420 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32421 }
32422 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32423 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32424 }
32425 static void *_p_wxControlTo_p_wxObject(void *x) {
32426 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32427 }
32428 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32429 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32430 }
32431 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32432 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32433 }
32434 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32435 return (void *)((wxObject *) ((wxFSFile *) x));
32436 }
32437 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32438 return (void *)((wxObject *) ((wxClipboard *) x));
32439 }
32440 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32441 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32442 }
32443 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32444 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32445 }
32446 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32447 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32448 }
32449 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32450 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32451 }
32452 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32453 return (void *)((wxObject *) ((wxToolTip *) x));
32454 }
32455 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32456 return (void *)((wxObject *) ((wxMenuItem *) x));
32457 }
32458 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32459 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32460 }
32461 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32462 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32463 }
32464 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32465 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32466 }
32467 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32468 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32469 }
32470 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32471 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32472 }
32473 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32474 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32475 }
32476 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32477 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32478 }
32479 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32480 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32481 }
32482 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32483 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32484 }
32485 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32486 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32487 }
32488 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32489 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32490 }
32491 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32492 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32493 }
32494 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32495 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32496 }
32497 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32498 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32499 }
32500 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32501 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32502 }
32503 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32504 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32505 }
32506 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32507 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32508 }
32509 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32510 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32511 }
32512 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32513 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32514 }
32515 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32516 return (void *)((wxObject *) ((wxImageHandler *) x));
32517 }
32518 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32519 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32520 }
32521 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32522 return (void *)((wxObject *) ((wxEvtHandler *) x));
32523 }
32524 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32525 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32526 }
32527 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32528 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32529 }
32530 static void *_p_wxImageTo_p_wxObject(void *x) {
32531 return (void *)((wxObject *) ((wxImage *) x));
32532 }
32533 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32534 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32535 }
32536 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32537 return (void *)((wxObject *) ((wxSystemOptions *) x));
32538 }
32539 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32540 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32541 }
32542 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32543 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32544 }
32545 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32546 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32547 }
32548 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32549 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32550 }
32551 static void *_p_wxWindowTo_p_wxObject(void *x) {
32552 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32553 }
32554 static void *_p_wxMenuTo_p_wxObject(void *x) {
32555 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32556 }
32557 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32559 }
32560 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32562 }
32563 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) ((wxFileSystem *) x));
32565 }
32566 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32568 }
32569 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32571 }
32572 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32574 }
32575 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32577 }
32578 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32579 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32580 }
32581 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32582 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32583 }
32584 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32585 return (void *)((wxObject *) ((wxBusyInfo *) x));
32586 }
32587 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32588 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32589 }
32590 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32591 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32592 }
32593 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32594 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32595 }
32596 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32597 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32598 }
32599 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32600 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32601 }
32602 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32603 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32604 }
32605 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32606 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32607 }
32608 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32609 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32610 }
32611 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32612 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32613 }
32614 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32615 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32616 }
32617 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32618 return (void *)((wxLog *) ((wxLogStderr *) x));
32619 }
32620 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32621 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32622 }
32623 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32624 return (void *)((wxLog *) ((wxLogWindow *) x));
32625 }
32626 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32627 return (void *)((wxLog *) ((wxLogChain *) x));
32628 }
32629 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32630 return (void *)((wxLog *) ((wxLogGui *) x));
32631 }
32632 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32633 return (void *)((wxLog *) ((wxPyLog *) x));
32634 }
32635 static void *_p_wxControlTo_p_wxWindow(void *x) {
32636 return (void *)((wxWindow *) ((wxControl *) x));
32637 }
32638 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32639 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32640 }
32641 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32642 return (void *)((wxWindow *) ((wxMenuBar *) x));
32643 }
32644 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32645 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32646 }
32647 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32648 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32649 }
32650 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}};
32651 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}};
32652 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}};
32653 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}};
32654 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}};
32655 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}};
32656 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32657 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}};
32658 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}};
32659 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}};
32660 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}};
32661 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}};
32662 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}};
32663 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}};
32664 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}};
32665 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}};
32666 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}};
32667 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}};
32668 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}};
32669 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}};
32670 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}};
32671 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}};
32672 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}};
32673 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}};
32674 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}};
32675 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}};
32676 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}};
32677 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}};
32678 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}};
32679 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}};
32680 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}};
32681 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}};
32682 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}};
32683 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}};
32684 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}};
32685 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}};
32686 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}};
32687 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}};
32688 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}};
32689 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}};
32690 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}};
32691 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}};
32692 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}};
32693 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}};
32694 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}};
32695 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}};
32696 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}};
32697 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}};
32698 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}};
32699 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}};
32700 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}};
32701 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}};
32702 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}};
32703 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}};
32704 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}};
32705 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}};
32706 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}};
32707 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}};
32708 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}};
32709 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}};
32710 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}};
32711 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}};
32712 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}};
32713 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}};
32714 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}};
32715 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}};
32716 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}};
32717 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}};
32718 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}};
32719 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}};
32720 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}};
32721 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32722 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}};
32723 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}};
32724 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}};
32725 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}};
32726 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}};
32727 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}};
32728 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}};
32729 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}};
32730 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}};
32731 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}};
32732 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}};
32733 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}};
32734 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}};
32735 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}};
32736 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}};
32737 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}};
32738 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}};
32739 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}};
32740 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}};
32741 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}};
32742 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}};
32743 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}};
32744 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}};
32745 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}};
32746 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}};
32747
32748 static swig_type_info *swig_types_initial[] = {
32749 _swigt__p_wxLogChain,
32750 _swigt__p_wxMutexGuiLocker,
32751 _swigt__p_wxMetafile,
32752 _swigt__p_wxFileHistory,
32753 _swigt__p_wxLog,
32754 _swigt__p_wxMenu,
32755 _swigt__p_wxEvent,
32756 _swigt__p_wxDateTime__TimeZone,
32757 _swigt__p_wxConfigBase,
32758 _swigt__p_wxDisplay,
32759 _swigt__p_wxFileType,
32760 _swigt__p_wxLogGui,
32761 _swigt__p_wxFont,
32762 _swigt__p_wxDataFormat,
32763 _swigt__p_wxTimerEvent,
32764 _swigt__p_wxCaret,
32765 _swigt__ptrdiff_t,
32766 _swigt__std__ptrdiff_t,
32767 _swigt__p_int,
32768 _swigt__p_wxSize,
32769 _swigt__p_wxClipboard,
32770 _swigt__p_wxStopWatch,
32771 _swigt__p_wxDC,
32772 _swigt__p_wxClipboardLocker,
32773 _swigt__p_wxIcon,
32774 _swigt__p_wxLogStderr,
32775 _swigt__p_wxLogTextCtrl,
32776 _swigt__p_wxTextCtrl,
32777 _swigt__p_wxBusyCursor,
32778 _swigt__p_wxBitmapDataObject,
32779 _swigt__p_wxTextDataObject,
32780 _swigt__p_wxDataObject,
32781 _swigt__p_wxPyTextDataObject,
32782 _swigt__p_wxPyBitmapDataObject,
32783 _swigt__p_wxFileDataObject,
32784 _swigt__p_wxCustomDataObject,
32785 _swigt__p_wxURLDataObject,
32786 _swigt__p_wxMetafileDataObject,
32787 _swigt__p_wxSound,
32788 _swigt__p_wxTimerRunner,
32789 _swigt__p_wxLogWindow,
32790 _swigt__p_wxTimeSpan,
32791 _swigt__p_wxArrayString,
32792 _swigt__p_wxWindowDisabler,
32793 _swigt__p_form_ops_t,
32794 _swigt__p_wxToolTip,
32795 _swigt__p_wxDataObjectComposite,
32796 _swigt__p_wxSystemSettings,
32797 _swigt__p_wxFileConfig,
32798 _swigt__p_wxVideoMode,
32799 _swigt__p_wxDataObjectSimple,
32800 _swigt__p_wxPyDataObjectSimple,
32801 _swigt__p_wxDuplexMode,
32802 _swigt__p_wxEvtHandler,
32803 _swigt__p_wxRect,
32804 _swigt__p_char,
32805 _swigt__p_wxSingleInstanceChecker,
32806 _swigt__p_wxStandardPaths,
32807 _swigt__p_wxFileTypeInfo,
32808 _swigt__p_wxFrame,
32809 _swigt__p_wxTimer,
32810 _swigt__p_wxPaperSize,
32811 _swigt__p_wxMimeTypesManager,
32812 _swigt__p_wxPyArtProvider,
32813 _swigt__p_wxPyTipProvider,
32814 _swigt__p_wxTipProvider,
32815 _swigt__p_wxJoystick,
32816 _swigt__p_wxSystemOptions,
32817 _swigt__p_wxPoint,
32818 _swigt__p_wxJoystickEvent,
32819 _swigt__p_wxCursor,
32820 _swigt__p_wxObject,
32821 _swigt__p_wxOutputStream,
32822 _swigt__p_wxDateTime,
32823 _swigt__p_wxPyDropSource,
32824 _swigt__p_unsigned_long,
32825 _swigt__p_wxKillError,
32826 _swigt__p_wxWindow,
32827 _swigt__p_wxString,
32828 _swigt__p_wxPyProcess,
32829 _swigt__p_wxBitmap,
32830 _swigt__p_wxConfig,
32831 _swigt__unsigned_int,
32832 _swigt__p_unsigned_int,
32833 _swigt__p_unsigned_char,
32834 _swigt__p_wxChar,
32835 _swigt__p_wxBusyInfo,
32836 _swigt__p_wxPyDropTarget,
32837 _swigt__p_wxPyTextDropTarget,
32838 _swigt__p_wxPyFileDropTarget,
32839 _swigt__p_wxProcessEvent,
32840 _swigt__p_wxPyLog,
32841 _swigt__p_wxLogNull,
32842 _swigt__p_wxColour,
32843 _swigt__p_wxPyTimer,
32844 _swigt__p_wxConfigPathChanger,
32845 _swigt__p_wxDateSpan,
32846 0
32847 };
32848
32849
32850 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32851
32852 static swig_const_info swig_const_table[] = {
32853 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32854 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32855 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32856 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32857 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32858 {0, 0, 0, 0.0, 0, 0}};
32859
32860 #ifdef __cplusplus
32861 }
32862 #endif
32863
32864
32865 #ifdef __cplusplus
32866 extern "C" {
32867 #endif
32868
32869 /* Python-specific SWIG API */
32870 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32871 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32872 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32873
32874 /* -----------------------------------------------------------------------------
32875 * global variable support code.
32876 * ----------------------------------------------------------------------------- */
32877
32878 typedef struct swig_globalvar {
32879 char *name; /* Name of global variable */
32880 PyObject *(*get_attr)(); /* Return the current value */
32881 int (*set_attr)(PyObject *); /* Set the value */
32882 struct swig_globalvar *next;
32883 } swig_globalvar;
32884
32885 typedef struct swig_varlinkobject {
32886 PyObject_HEAD
32887 swig_globalvar *vars;
32888 } swig_varlinkobject;
32889
32890 static PyObject *
32891 swig_varlink_repr(swig_varlinkobject *v) {
32892 v = v;
32893 return PyString_FromString("<Swig global variables>");
32894 }
32895
32896 static int
32897 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32898 swig_globalvar *var;
32899 flags = flags;
32900 fprintf(fp,"Swig global variables { ");
32901 for (var = v->vars; var; var=var->next) {
32902 fprintf(fp,"%s", var->name);
32903 if (var->next) fprintf(fp,", ");
32904 }
32905 fprintf(fp," }\n");
32906 return 0;
32907 }
32908
32909 static PyObject *
32910 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32911 swig_globalvar *var = v->vars;
32912 while (var) {
32913 if (strcmp(var->name,n) == 0) {
32914 return (*var->get_attr)();
32915 }
32916 var = var->next;
32917 }
32918 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32919 return NULL;
32920 }
32921
32922 static int
32923 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32924 swig_globalvar *var = v->vars;
32925 while (var) {
32926 if (strcmp(var->name,n) == 0) {
32927 return (*var->set_attr)(p);
32928 }
32929 var = var->next;
32930 }
32931 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32932 return 1;
32933 }
32934
32935 static PyTypeObject varlinktype = {
32936 PyObject_HEAD_INIT(0)
32937 0, /* Number of items in variable part (ob_size) */
32938 (char *)"swigvarlink", /* Type name (tp_name) */
32939 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32940 0, /* Itemsize (tp_itemsize) */
32941 0, /* Deallocator (tp_dealloc) */
32942 (printfunc) swig_varlink_print, /* Print (tp_print) */
32943 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32944 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32945 0, /* tp_compare */
32946 (reprfunc) swig_varlink_repr, /* tp_repr */
32947 0, /* tp_as_number */
32948 0, /* tp_as_sequence */
32949 0, /* tp_as_mapping */
32950 0, /* tp_hash */
32951 0, /* tp_call */
32952 0, /* tp_str */
32953 0, /* tp_getattro */
32954 0, /* tp_setattro */
32955 0, /* tp_as_buffer */
32956 0, /* tp_flags */
32957 0, /* tp_doc */
32958 #if PY_VERSION_HEX >= 0x02000000
32959 0, /* tp_traverse */
32960 0, /* tp_clear */
32961 #endif
32962 #if PY_VERSION_HEX >= 0x02010000
32963 0, /* tp_richcompare */
32964 0, /* tp_weaklistoffset */
32965 #endif
32966 #if PY_VERSION_HEX >= 0x02020000
32967 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32968 #endif
32969 #if PY_VERSION_HEX >= 0x02030000
32970 0, /* tp_del */
32971 #endif
32972 #ifdef COUNT_ALLOCS
32973 0,0,0,0 /* tp_alloc -> tp_next */
32974 #endif
32975 };
32976
32977 /* Create a variable linking object for use later */
32978 static PyObject *
32979 SWIG_Python_newvarlink(void) {
32980 swig_varlinkobject *result = 0;
32981 result = PyMem_NEW(swig_varlinkobject,1);
32982 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32983 result->ob_type = &varlinktype;
32984 result->vars = 0;
32985 result->ob_refcnt = 0;
32986 Py_XINCREF((PyObject *) result);
32987 return ((PyObject*) result);
32988 }
32989
32990 static void
32991 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32992 swig_varlinkobject *v;
32993 swig_globalvar *gv;
32994 v= (swig_varlinkobject *) p;
32995 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32996 gv->name = (char *) malloc(strlen(name)+1);
32997 strcpy(gv->name,name);
32998 gv->get_attr = get_attr;
32999 gv->set_attr = set_attr;
33000 gv->next = v->vars;
33001 v->vars = gv;
33002 }
33003
33004 /* -----------------------------------------------------------------------------
33005 * constants/methods manipulation
33006 * ----------------------------------------------------------------------------- */
33007
33008 /* Install Constants */
33009 static void
33010 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33011 PyObject *obj = 0;
33012 size_t i;
33013 for (i = 0; constants[i].type; i++) {
33014 switch(constants[i].type) {
33015 case SWIG_PY_INT:
33016 obj = PyInt_FromLong(constants[i].lvalue);
33017 break;
33018 case SWIG_PY_FLOAT:
33019 obj = PyFloat_FromDouble(constants[i].dvalue);
33020 break;
33021 case SWIG_PY_STRING:
33022 if (constants[i].pvalue) {
33023 obj = PyString_FromString((char *) constants[i].pvalue);
33024 } else {
33025 Py_INCREF(Py_None);
33026 obj = Py_None;
33027 }
33028 break;
33029 case SWIG_PY_POINTER:
33030 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33031 break;
33032 case SWIG_PY_BINARY:
33033 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33034 break;
33035 default:
33036 obj = 0;
33037 break;
33038 }
33039 if (obj) {
33040 PyDict_SetItemString(d,constants[i].name,obj);
33041 Py_DECREF(obj);
33042 }
33043 }
33044 }
33045
33046 /* -----------------------------------------------------------------------------*/
33047 /* Fix SwigMethods to carry the callback ptrs when needed */
33048 /* -----------------------------------------------------------------------------*/
33049
33050 static void
33051 SWIG_Python_FixMethods(PyMethodDef *methods,
33052 swig_const_info *const_table,
33053 swig_type_info **types,
33054 swig_type_info **types_initial) {
33055 size_t i;
33056 for (i = 0; methods[i].ml_name; ++i) {
33057 char *c = methods[i].ml_doc;
33058 if (c && (c = strstr(c, "swig_ptr: "))) {
33059 int j;
33060 swig_const_info *ci = 0;
33061 char *name = c + 10;
33062 for (j = 0; const_table[j].type; j++) {
33063 if (strncmp(const_table[j].name, name,
33064 strlen(const_table[j].name)) == 0) {
33065 ci = &(const_table[j]);
33066 break;
33067 }
33068 }
33069 if (ci) {
33070 size_t shift = (ci->ptype) - types;
33071 swig_type_info *ty = types_initial[shift];
33072 size_t ldoc = (c - methods[i].ml_doc);
33073 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33074 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33075 char *buff = ndoc;
33076 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33077 strncpy(buff, methods[i].ml_doc, ldoc);
33078 buff += ldoc;
33079 strncpy(buff, "swig_ptr: ", 10);
33080 buff += 10;
33081 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33082 methods[i].ml_doc = ndoc;
33083 }
33084 }
33085 }
33086 }
33087
33088 /* -----------------------------------------------------------------------------*
33089 * Initialize type list
33090 * -----------------------------------------------------------------------------*/
33091
33092 #if PY_MAJOR_VERSION < 2
33093 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33094 is copied out of Python/modsupport.c in python version 2.3.4 */
33095 static int
33096 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33097 {
33098 PyObject *dict;
33099 if (!PyModule_Check(m)) {
33100 PyErr_SetString(PyExc_TypeError,
33101 "PyModule_AddObject() needs module as first arg");
33102 return -1;
33103 }
33104 if (!o) {
33105 PyErr_SetString(PyExc_TypeError,
33106 "PyModule_AddObject() needs non-NULL value");
33107 return -1;
33108 }
33109
33110 dict = PyModule_GetDict(m);
33111 if (dict == NULL) {
33112 /* Internal error -- modules must have a dict! */
33113 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33114 PyModule_GetName(m));
33115 return -1;
33116 }
33117 if (PyDict_SetItemString(dict, name, o))
33118 return -1;
33119 Py_DECREF(o);
33120 return 0;
33121 }
33122 #endif
33123
33124 static swig_type_info **
33125 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33126 static PyMethodDef swig_empty_runtime_method_table[] = {
33127 {
33128 NULL, NULL, 0, NULL
33129 }
33130 };/* Sentinel */
33131
33132 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33133 swig_empty_runtime_method_table);
33134 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33135 if (pointer && module) {
33136 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33137 }
33138 return type_list_handle;
33139 }
33140
33141 static swig_type_info **
33142 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33143 swig_type_info **type_pointer;
33144
33145 /* first check if module already created */
33146 type_pointer = SWIG_Python_GetTypeListHandle();
33147 if (type_pointer) {
33148 return type_pointer;
33149 } else {
33150 /* create a new module and variable */
33151 return SWIG_Python_SetTypeListHandle(type_list_handle);
33152 }
33153 }
33154
33155 #ifdef __cplusplus
33156 }
33157 #endif
33158
33159 /* -----------------------------------------------------------------------------*
33160 * Partial Init method
33161 * -----------------------------------------------------------------------------*/
33162
33163 #ifdef SWIG_LINK_RUNTIME
33164 #ifdef __cplusplus
33165 extern "C"
33166 #endif
33167 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33168 #endif
33169
33170 #ifdef __cplusplus
33171 extern "C"
33172 #endif
33173 SWIGEXPORT(void) SWIG_init(void) {
33174 static PyObject *SWIG_globals = 0;
33175 static int typeinit = 0;
33176 PyObject *m, *d;
33177 int i;
33178 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33179
33180 /* Fix SwigMethods to carry the callback ptrs when needed */
33181 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33182
33183 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33184 d = PyModule_GetDict(m);
33185
33186 if (!typeinit) {
33187 #ifdef SWIG_LINK_RUNTIME
33188 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33189 #else
33190 # ifndef SWIG_STATIC_RUNTIME
33191 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33192 # endif
33193 #endif
33194 for (i = 0; swig_types_initial[i]; i++) {
33195 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33196 }
33197 typeinit = 1;
33198 }
33199 SWIG_InstallConstants(d,swig_const_table);
33200
33201 {
33202 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33203 }
33204 {
33205 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33206 }
33207 {
33208 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33209 }
33210 {
33211 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33212 }
33213 {
33214 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33215 }
33216 {
33217 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33218 }
33219 {
33220 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33221 }
33222 {
33223 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33224 }
33225 {
33226 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33227 }
33228 {
33229 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33230 }
33231 {
33232 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33233 }
33234 {
33235 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33236 }
33237 {
33238 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33239 }
33240 {
33241 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33242 }
33243 {
33244 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33245 }
33246 {
33247 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33248 }
33249 {
33250 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33251 }
33252 {
33253 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33254 }
33255 {
33256 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33257 }
33258 {
33259 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33260 }
33261 {
33262 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33263 }
33264 {
33265 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33266 }
33267 {
33268 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33269 }
33270 {
33271 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33272 }
33273 {
33274 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33275 }
33276 {
33277 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33278 }
33279 {
33280 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33281 }
33282 {
33283 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33284 }
33285 {
33286 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33287 }
33288 {
33289 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33290 }
33291 {
33292 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33293 }
33294 {
33295 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33296 }
33297 {
33298 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33299 }
33300 {
33301 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33302 }
33303 {
33304 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33305 }
33306 {
33307 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33308 }
33309 {
33310 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33311 }
33312 {
33313 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33314 }
33315 {
33316 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33317 }
33318 {
33319 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33320 }
33321 {
33322 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33323 }
33324 {
33325 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33326 }
33327 {
33328 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33329 }
33330 {
33331 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33332 }
33333 {
33334 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33338 }
33339 {
33340 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33344 }
33345 {
33346 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33347 }
33348 {
33349 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33350 }
33351 {
33352 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33353 }
33354 {
33355 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33356 }
33357 {
33358 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33359 }
33360 {
33361 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33362 }
33363 {
33364 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33365 }
33366 {
33367 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33368 }
33369 {
33370 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33371 }
33372 {
33373 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33374 }
33375 {
33376 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33377 }
33378 {
33379 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33380 }
33381 {
33382 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33383 }
33384 {
33385 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33386 }
33387 {
33388 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33389 }
33390 {
33391 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33392 }
33393 {
33394 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33419 }
33420 {
33421 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33422 }
33423 {
33424 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33473 }
33474 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33475 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33476 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33477 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33478 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33479 {
33480 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33490 }
33491 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33492
33493 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33494
33495 {
33496 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33527 }
33528 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33529 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33530 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33531 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33532 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33533 {
33534 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33625 }
33626 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33627 {
33628 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33641 }
33642
33643 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33644
33645 {
33646 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33665 }
33666 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33667 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33668 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33669 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33670 {
33671 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33693 }
33694 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33695 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33696 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33697 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33698 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33699 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33700 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33701 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33702 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33703 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33704 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33705 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33706 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33707 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33708 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33709 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33710 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33711 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33712 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33713 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33714 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33715 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33716 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33717 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33718 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33719 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33720 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33721 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33722 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33723 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33724 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33725 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33726 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33727 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33728 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33729 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33730 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33731 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33732 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33733 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33734 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33735 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33736 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33737 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33738 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33739 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33740 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33741 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33742 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33743 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33744 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33745 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33746 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33747 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33748 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33749 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33750
33751 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33752
33753 {
33754 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33779 }
33780 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33781 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33782 {
33783 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33829 }
33830 {
33831 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33832 }
33833 {
33834 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33859 }
33860 {
33861 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33862 }
33863 {
33864 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33865 }
33866 {
33867 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33868 }
33869 {
33870 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33895 }
33896 {
33897 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33898 }
33899 {
33900 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33901 }
33902 {
33903 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33937 }
33938 {
33939 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33946 }
33947 {
33948 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33949 }
33950 {
33951 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33994 }
33995 {
33996 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33997 }
33998 {
33999 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34132 }
34133 {
34134 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34135 }
34136 {
34137 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34138 }
34139 {
34140 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34141 }
34142 {
34143 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34144 }
34145 {
34146 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34147 }
34148 {
34149 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34150 }
34151 {
34152 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34153 }
34154 {
34155 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34156 }
34157 {
34158 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34159 }
34160 {
34161 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34162 }
34163 {
34164 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34165 }
34166 {
34167 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34168 }
34169 {
34170 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34171 }
34172 {
34173 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34174 }
34175 {
34176 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34177 }
34178 {
34179 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34180 }
34181 {
34182 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34183 }
34184 {
34185 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34186 }
34187 {
34188 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34189 }
34190 {
34191 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34192 }
34193 {
34194 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34195 }
34196 {
34197 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34231 }
34232 {
34233 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34234 }
34235 {
34236 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34237 }
34238 {
34239 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34246 }
34247 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34248 {
34249 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34307 }
34308 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34309 {
34310 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34326 }
34327 {
34328 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34329 }
34330 {
34331 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34332 }
34333 {
34334 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34335 }
34336 {
34337 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34338 }
34339 {
34340 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34341 }
34342 {
34343 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34344 }
34345
34346 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34347 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34348 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34349 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34350
34351 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34352 }
34353
wxWidgets (Impactor)