]> 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 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLogChain swig_types[0]
1343 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1344 #define SWIGTYPE_p_wxMetafile swig_types[2]
1345 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1346 #define SWIGTYPE_p_wxLog swig_types[4]
1347 #define SWIGTYPE_p_wxMenu swig_types[5]
1348 #define SWIGTYPE_p_wxEvent swig_types[6]
1349 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1350 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1351 #define SWIGTYPE_p_wxDisplay swig_types[9]
1352 #define SWIGTYPE_p_wxFileType swig_types[10]
1353 #define SWIGTYPE_p_wxLogGui swig_types[11]
1354 #define SWIGTYPE_p_wxMemorySize swig_types[12]
1355 #define SWIGTYPE_p_wxFont swig_types[13]
1356 #define SWIGTYPE_p_wxDataFormat swig_types[14]
1357 #define SWIGTYPE_p_wxTimerEvent swig_types[15]
1358 #define SWIGTYPE_p_wxCaret swig_types[16]
1359 #define SWIGTYPE_ptrdiff_t swig_types[17]
1360 #define SWIGTYPE_std__ptrdiff_t swig_types[18]
1361 #define SWIGTYPE_p_void swig_types[19]
1362 #define SWIGTYPE_p_int swig_types[20]
1363 #define SWIGTYPE_p_wxSize swig_types[21]
1364 #define SWIGTYPE_p_wxClipboard swig_types[22]
1365 #define SWIGTYPE_p_wxStopWatch swig_types[23]
1366 #define SWIGTYPE_p_wxDC swig_types[24]
1367 #define SWIGTYPE_p_wxClipboardLocker swig_types[25]
1368 #define SWIGTYPE_p_wxIcon swig_types[26]
1369 #define SWIGTYPE_p_wxLogStderr swig_types[27]
1370 #define SWIGTYPE_p_wxLogTextCtrl swig_types[28]
1371 #define SWIGTYPE_p_wxTextCtrl swig_types[29]
1372 #define SWIGTYPE_p_wxBusyCursor swig_types[30]
1373 #define SWIGTYPE_p_wxBitmapDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxTextDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxPyTextDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxFileDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxCustomDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxURLDataObject swig_types[38]
1381 #define SWIGTYPE_p_wxMetafileDataObject swig_types[39]
1382 #define SWIGTYPE_p_wxSound swig_types[40]
1383 #define SWIGTYPE_p_wxTimerRunner swig_types[41]
1384 #define SWIGTYPE_p_wxLogWindow swig_types[42]
1385 #define SWIGTYPE_p_wxTimeSpan swig_types[43]
1386 #define SWIGTYPE_p_wxArrayString swig_types[44]
1387 #define SWIGTYPE_p_wxWindowDisabler swig_types[45]
1388 #define SWIGTYPE_p_form_ops_t swig_types[46]
1389 #define SWIGTYPE_p_wxToolTip swig_types[47]
1390 #define SWIGTYPE_p_wxDataObjectComposite swig_types[48]
1391 #define SWIGTYPE_p_wxSystemSettings swig_types[49]
1392 #define SWIGTYPE_p_wxFileConfig swig_types[50]
1393 #define SWIGTYPE_p_wxVideoMode swig_types[51]
1394 #define SWIGTYPE_p_wxDataObjectSimple swig_types[52]
1395 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[53]
1396 #define SWIGTYPE_p_wxDuplexMode swig_types[54]
1397 #define SWIGTYPE_p_wxEvtHandler swig_types[55]
1398 #define SWIGTYPE_p_wxRect swig_types[56]
1399 #define SWIGTYPE_p_char swig_types[57]
1400 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[58]
1401 #define SWIGTYPE_p_wxStandardPaths swig_types[59]
1402 #define SWIGTYPE_p_wxFileTypeInfo swig_types[60]
1403 #define SWIGTYPE_p_wxFrame swig_types[61]
1404 #define SWIGTYPE_p_wxTimer swig_types[62]
1405 #define SWIGTYPE_p_wxPaperSize swig_types[63]
1406 #define SWIGTYPE_p_wxMimeTypesManager swig_types[64]
1407 #define SWIGTYPE_p_wxPyTipProvider swig_types[65]
1408 #define SWIGTYPE_p_wxTipProvider swig_types[66]
1409 #define SWIGTYPE_p_wxJoystick swig_types[67]
1410 #define SWIGTYPE_p_wxSystemOptions swig_types[68]
1411 #define SWIGTYPE_p_wxPyArtProvider swig_types[69]
1412 #define SWIGTYPE_p_wxPoint swig_types[70]
1413 #define SWIGTYPE_p_wxJoystickEvent swig_types[71]
1414 #define SWIGTYPE_p_wxCursor swig_types[72]
1415 #define SWIGTYPE_p_wxObject swig_types[73]
1416 #define SWIGTYPE_p_wxOutputStream swig_types[74]
1417 #define SWIGTYPE_p_wxDateTime swig_types[75]
1418 #define SWIGTYPE_p_wxPyDropSource swig_types[76]
1419 #define SWIGTYPE_p_unsigned_long swig_types[77]
1420 #define SWIGTYPE_p_wxLogBuffer swig_types[78]
1421 #define SWIGTYPE_p_wxKillError swig_types[79]
1422 #define SWIGTYPE_p_wxWindow swig_types[80]
1423 #define SWIGTYPE_p_wxString swig_types[81]
1424 #define SWIGTYPE_p_wxPyProcess swig_types[82]
1425 #define SWIGTYPE_p_wxBitmap swig_types[83]
1426 #define SWIGTYPE_unsigned_int swig_types[84]
1427 #define SWIGTYPE_p_unsigned_int swig_types[85]
1428 #define SWIGTYPE_p_wxConfig swig_types[86]
1429 #define SWIGTYPE_p_unsigned_char swig_types[87]
1430 #define SWIGTYPE_p_wxChar swig_types[88]
1431 #define SWIGTYPE_p_wxBusyInfo swig_types[89]
1432 #define SWIGTYPE_p_wxPyDropTarget swig_types[90]
1433 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[91]
1434 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[92]
1435 #define SWIGTYPE_p_wxProcessEvent swig_types[93]
1436 #define SWIGTYPE_p_wxPyLog swig_types[94]
1437 #define SWIGTYPE_p_wxLogNull swig_types[95]
1438 #define SWIGTYPE_p_wxColour swig_types[96]
1439 #define SWIGTYPE_p_wxPyTimer swig_types[97]
1440 #define SWIGTYPE_p_wxConfigPathChanger swig_types[98]
1441 #define SWIGTYPE_p_wxDateSpan swig_types[99]
1442 static swig_type_info *swig_types[101];
1443
1444 /* -------- TYPES TABLE (END) -------- */
1445
1446
1447 /*-----------------------------------------------
1448 @(target):= _misc_.so
1449 ------------------------------------------------*/
1450 #define SWIG_init init_misc_
1451
1452 #define SWIG_name "_misc_"
1453
1454 #include "wx/wxPython/wxPython.h"
1455 #include "wx/wxPython/pyclasses.h"
1456 #include "wx/wxPython/pyistream.h"
1457
1458 static const wxString wxPyEmptyString(wxEmptyString);
1459
1460
1461
1462 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1463 #define SWIG_From_int PyInt_FromLong
1464 /*@@*/
1465
1466
1467 #include <limits.h>
1468
1469
1470 SWIGINTERN int
1471 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1472 const char *errmsg)
1473 {
1474 if (value < min_value) {
1475 if (errmsg) {
1476 PyErr_Format(PyExc_OverflowError,
1477 "value %ld is less than '%s' minimum %ld",
1478 value, errmsg, min_value);
1479 }
1480 return 0;
1481 } else if (value > max_value) {
1482 if (errmsg) {
1483 PyErr_Format(PyExc_OverflowError,
1484 "value %ld is greater than '%s' maximum %ld",
1485 value, errmsg, max_value);
1486 }
1487 return 0;
1488 }
1489 return 1;
1490 }
1491
1492
1493 SWIGINTERN int
1494 SWIG_AsVal_long(PyObject* obj, long* val)
1495 {
1496 if (PyNumber_Check(obj)) {
1497 if (val) *val = PyInt_AsLong(obj);
1498 return 1;
1499 }
1500 else {
1501 SWIG_type_error("number", obj);
1502 }
1503 return 0;
1504 }
1505
1506
1507 #if INT_MAX != LONG_MAX
1508 SWIGINTERN int
1509 SWIG_AsVal_int(PyObject *obj, int *val)
1510 {
1511 const char* errmsg = val ? "int" : (char*)0;
1512 long v;
1513 if (SWIG_AsVal_long(obj, &v)) {
1514 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1515 if (val) *val = (int)(v);
1516 return 1;
1517 } else {
1518 return 0;
1519 }
1520 } else {
1521 PyErr_Clear();
1522 }
1523 if (val) {
1524 SWIG_type_error(errmsg, obj);
1525 }
1526 return 0;
1527 }
1528 #else
1529 SWIGINTERNSHORT int
1530 SWIG_AsVal_int(PyObject *obj, int *val)
1531 {
1532 return SWIG_AsVal_long(obj,(long*)val);
1533 }
1534 #endif
1535
1536
1537 SWIGINTERNSHORT int
1538 SWIG_As_int(PyObject* obj)
1539 {
1540 int v;
1541 if (!SWIG_AsVal_int(obj, &v)) {
1542 /*
1543 this is needed to make valgrind/purify happier.
1544 */
1545 memset((void*)&v, 0, sizeof(int));
1546 }
1547 return v;
1548 }
1549
1550
1551 SWIGINTERNSHORT int
1552 SWIG_Check_int(PyObject* obj)
1553 {
1554 return SWIG_AsVal_int(obj, (int*)0);
1555 }
1556
1557 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1558
1559 #include <wx/stockitem.h>
1560
1561 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1562 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1563 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1564
1565 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1566 #define SWIG_From_long PyInt_FromLong
1567 /*@@*/
1568
1569
1570 SWIGINTERNSHORT long
1571 SWIG_As_long(PyObject* obj)
1572 {
1573 long v;
1574 if (!SWIG_AsVal_long(obj, &v)) {
1575 /*
1576 this is needed to make valgrind/purify happier.
1577 */
1578 memset((void*)&v, 0, sizeof(long));
1579 }
1580 return v;
1581 }
1582
1583
1584 SWIGINTERNSHORT int
1585 SWIG_Check_long(PyObject* obj)
1586 {
1587 return SWIG_AsVal_long(obj, (long*)0);
1588 }
1589
1590
1591 SWIGINTERN int
1592 SWIG_AsVal_bool(PyObject *obj, bool *val)
1593 {
1594 if (obj == Py_True) {
1595 if (val) *val = true;
1596 return 1;
1597 }
1598 if (obj == Py_False) {
1599 if (val) *val = false;
1600 return 1;
1601 }
1602 int res = 0;
1603 if (SWIG_AsVal_int(obj, &res)) {
1604 if (val) *val = res ? true : false;
1605 return 1;
1606 } else {
1607 PyErr_Clear();
1608 }
1609 if (val) {
1610 SWIG_type_error("bool", obj);
1611 }
1612 return 0;
1613 }
1614
1615
1616 SWIGINTERNSHORT bool
1617 SWIG_As_bool(PyObject* obj)
1618 {
1619 bool v;
1620 if (!SWIG_AsVal_bool(obj, &v)) {
1621 /*
1622 this is needed to make valgrind/purify happier.
1623 */
1624 memset((void*)&v, 0, sizeof(bool));
1625 }
1626 return v;
1627 }
1628
1629
1630 SWIGINTERNSHORT int
1631 SWIG_Check_bool(PyObject* obj)
1632 {
1633 return SWIG_AsVal_bool(obj, (bool*)0);
1634 }
1635
1636
1637 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1638 PyObject* o2;
1639 PyObject* o3;
1640
1641 if (!target) {
1642 target = o;
1643 } else if (target == Py_None) {
1644 Py_DECREF(Py_None);
1645 target = o;
1646 } else {
1647 if (!PyTuple_Check(target)) {
1648 o2 = target;
1649 target = PyTuple_New(1);
1650 PyTuple_SetItem(target, 0, o2);
1651 }
1652 o3 = PyTuple_New(1);
1653 PyTuple_SetItem(o3, 0, o);
1654
1655 o2 = target;
1656 target = PySequence_Concat(o2, o3);
1657 Py_DECREF(o2);
1658 Py_DECREF(o3);
1659 }
1660 return target;
1661 }
1662
1663
1664
1665 SWIGINTERN int
1666 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1667 {
1668 long v = 0;
1669 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1670 SWIG_type_error("unsigned number", obj);
1671 }
1672 else if (val)
1673 *val = (unsigned long)v;
1674 return 1;
1675 }
1676
1677
1678 SWIGINTERNSHORT unsigned long
1679 SWIG_As_unsigned_SS_long(PyObject* obj)
1680 {
1681 unsigned long v;
1682 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1683 /*
1684 this is needed to make valgrind/purify happier.
1685 */
1686 memset((void*)&v, 0, sizeof(unsigned long));
1687 }
1688 return v;
1689 }
1690
1691
1692 SWIGINTERNSHORT int
1693 SWIG_Check_unsigned_SS_long(PyObject* obj)
1694 {
1695 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1696 }
1697
1698
1699 SWIGINTERNSHORT PyObject*
1700 SWIG_From_unsigned_SS_long(unsigned long value)
1701 {
1702 return (value > LONG_MAX) ?
1703 PyLong_FromUnsignedLong(value)
1704 : PyInt_FromLong((long)(value));
1705 }
1706
1707
1708 void* wxGetXDisplay()
1709 {
1710 #ifdef __WXGTK__
1711 return wxGetDisplay();
1712 #else
1713 return NULL;
1714 #endif
1715 }
1716
1717
1718 bool wxThread_IsMain() {
1719 #ifdef WXP_WITH_THREAD
1720 return wxThread::IsMain();
1721 #else
1722 return true;
1723 #endif
1724 }
1725
1726 static void wxCaret_Destroy(wxCaret *self){
1727 delete self;
1728 }
1729
1730 #include <wx/snglinst.h>
1731
1732
1733 #ifdef __WXMSW__
1734 #include <wx/msw/private.h>
1735 #include <wx/dynload.h>
1736 #endif
1737
1738
1739
1740 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1741 #if 0
1742 , int method
1743 #endif
1744 )
1745 {
1746 #ifdef __WXMSW__
1747 #if 0
1748 switch (method)
1749 {
1750 case 1:
1751 // This one only partially works. Appears to be an undocumented
1752 // "standard" convention that not all widgets adhear to. For
1753 // example, for some widgets backgrounds or non-client areas may
1754 // not be painted.
1755 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1756 break;
1757
1758 case 2:
1759 #endif
1760 // This one works much better, nearly all widgets and their
1761 // children are captured correctly[**]. Prior to the big
1762 // background erase changes that Vadim did in 2004-2005 this
1763 // method failed badly on XP with Themes activated, most native
1764 // widgets draw only partially, if at all. Without themes it
1765 // worked just like on Win2k. After those changes this method
1766 // works very well.
1767 //
1768 // ** For example the radio buttons in a wxRadioBox are not its
1769 // children by default, but you can capture it via the panel
1770 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1771 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1772 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1773 PRF_ERASEBKGND | PRF_OWNED );
1774 return true;
1775 #if 0
1776 break;
1777
1778 case 3:
1779 // This one is only defined in the latest SDK and is only
1780 // available on XP. MSDN says it is similar to sending WM_PRINT
1781 // so I expect that it will work similar to the above. Since it
1782 // is avaialble only on XP, it can't be compiled like this and
1783 // will have to be loaded dynamically.
1784 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1785
1786 // fall through
1787
1788 case 4:
1789 // Use PrintWindow if available, or fallback to WM_PRINT
1790 // otherwise. Unfortunately using PrintWindow is even worse than
1791 // WM_PRINT. For most native widgets nothing is drawn to the dc
1792 // at all, with or without Themes.
1793 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1794 static bool s_triedToLoad = false;
1795 static PrintWindow_t pfnPrintWindow = NULL;
1796 if ( !s_triedToLoad )
1797 {
1798
1799 s_triedToLoad = true;
1800 wxDynamicLibrary dllUser32(_T("user32.dll"));
1801 if ( dllUser32.IsLoaded() )
1802 {
1803 wxLogNull nolog; // Don't report errors here
1804 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1805 }
1806 }
1807 if (pfnPrintWindow)
1808 {
1809 //printf("Using PrintWindow\n");
1810 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1811 }
1812 else
1813 {
1814 //printf("Using WM_PRINT\n");
1815 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1816 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1817 PRF_ERASEBKGND | PRF_OWNED );
1818 }
1819 }
1820 #endif // 0
1821 #else
1822 return false;
1823 #endif // __WXMSW__
1824 }
1825
1826
1827
1828 #include <wx/tipdlg.h>
1829
1830
1831 class wxPyTipProvider : public wxTipProvider {
1832 public:
1833 wxPyTipProvider(size_t currentTip)
1834 : wxTipProvider(currentTip) {}
1835
1836 DEC_PYCALLBACK_STRING__pure(GetTip);
1837 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1838 PYPRIVATE;
1839 };
1840
1841 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1842 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1843
1844
1845 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1846
1847 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1848
1849 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1850 : wxTimer(owner, id)
1851 {
1852 if (owner == NULL) SetOwner(this);
1853 }
1854
1855
1856 void wxPyTimer::Notify() {
1857 bool found;
1858 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1859 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1860 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1861 wxPyEndBlockThreads(blocked);
1862 if (! found)
1863 wxTimer::Notify();
1864 }
1865 void wxPyTimer::base_Notify() {
1866 wxTimer::Notify();
1867 }
1868
1869
1870
1871 SWIGINTERN PyObject *
1872 SWIG_FromCharPtr(const char* cptr)
1873 {
1874 if (cptr) {
1875 size_t size = strlen(cptr);
1876 if (size > INT_MAX) {
1877 return SWIG_NewPointerObj((char*)(cptr),
1878 SWIG_TypeQuery("char *"), 0);
1879 } else {
1880 if (size != 0) {
1881 return PyString_FromStringAndSize(cptr, size);
1882 } else {
1883 return PyString_FromString(cptr);
1884 }
1885 }
1886 }
1887 Py_INCREF(Py_None);
1888 return Py_None;
1889 }
1890
1891
1892 SWIGINTERNSHORT int
1893 SWIG_CheckUnsignedLongInRange(unsigned long value,
1894 unsigned long max_value,
1895 const char *errmsg)
1896 {
1897 if (value > max_value) {
1898 if (errmsg) {
1899 PyErr_Format(PyExc_OverflowError,
1900 "value %lu is greater than '%s' minimum %lu",
1901 value, errmsg, max_value);
1902 }
1903 return 0;
1904 }
1905 return 1;
1906 }
1907
1908
1909 #if UINT_MAX != ULONG_MAX
1910 SWIGINTERN int
1911 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1912 {
1913 const char* errmsg = val ? "unsigned int" : (char*)0;
1914 unsigned long v;
1915 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1916 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1917 if (val) *val = (unsigned int)(v);
1918 return 1;
1919 }
1920 } else {
1921 PyErr_Clear();
1922 }
1923 if (val) {
1924 SWIG_type_error(errmsg, obj);
1925 }
1926 return 0;
1927 }
1928 #else
1929 SWIGINTERNSHORT unsigned int
1930 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1931 {
1932 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1933 }
1934 #endif
1935
1936
1937 SWIGINTERNSHORT unsigned int
1938 SWIG_As_unsigned_SS_int(PyObject* obj)
1939 {
1940 unsigned int v;
1941 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1942 /*
1943 this is needed to make valgrind/purify happier.
1944 */
1945 memset((void*)&v, 0, sizeof(unsigned int));
1946 }
1947 return v;
1948 }
1949
1950
1951 SWIGINTERNSHORT int
1952 SWIG_Check_unsigned_SS_int(PyObject* obj)
1953 {
1954 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1955 }
1956
1957 static wxString Log_TimeStamp(){
1958 wxString msg;
1959 wxLog::TimeStamp(&msg);
1960 return msg;
1961 }
1962 static void wxLog_Destroy(wxLog *self){ delete self; }
1963 // Make somce wrappers that double any % signs so they are 'escaped'
1964 void wxPyLogFatalError(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogFatalError(m);
1969 }
1970
1971 void wxPyLogError(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogError(m);
1976 }
1977
1978 void wxPyLogWarning(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogWarning(m);
1983 }
1984
1985 void wxPyLogMessage(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogMessage(m);
1990 }
1991
1992 void wxPyLogInfo(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogInfo(m);
1997 }
1998
1999 void wxPyLogDebug(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogDebug(m);
2004 }
2005
2006 void wxPyLogVerbose(const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogVerbose(m);
2011 }
2012
2013 void wxPyLogStatus(const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogStatus(m);
2018 }
2019
2020 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogStatus(pFrame, m);
2025 }
2026
2027 void wxPyLogSysError(const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogSysError(m);
2032 }
2033
2034 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogGeneric(level, m);
2039 }
2040
2041 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2042 {
2043 wxString m(msg);
2044 m.Replace(wxT("%"), wxT("%%"));
2045 wxLogTrace(mask, m);
2046 }
2047
2048 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2049 {
2050 wxString m(msg);
2051 m.Replace(wxT("%"), wxT("%%"));
2052 wxLogTrace(mask, m);
2053 }
2054
2055
2056
2057 // A wxLog class that can be derived from in wxPython
2058 class wxPyLog : public wxLog {
2059 public:
2060 wxPyLog() : wxLog() {}
2061
2062 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2063 bool found;
2064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2065 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2066 PyObject* s = wx2PyString(szString);
2067 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2068 Py_DECREF(s);
2069 }
2070 wxPyEndBlockThreads(blocked);
2071 if (! found)
2072 wxLog::DoLog(level, szString, t);
2073 }
2074
2075 virtual void DoLogString(const wxChar *szString, time_t t) {
2076 bool found;
2077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2078 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2079 PyObject* s = wx2PyString(szString);
2080 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2081 Py_DECREF(s);
2082 }
2083 wxPyEndBlockThreads(blocked);
2084 if (! found)
2085 wxLog::DoLogString(szString, t);
2086 }
2087
2088 PYPRIVATE;
2089 };
2090
2091
2092
2093
2094 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2095
2096
2097 #include <wx/joystick.h>
2098
2099
2100 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2101 // A C++ stub class for wxJoystick for platforms that don't have it.
2102 class wxJoystick : public wxObject {
2103 public:
2104 wxJoystick(int joystick = wxJOYSTICK1) {
2105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2106 PyErr_SetString(PyExc_NotImplementedError,
2107 "wxJoystick is not available on this platform.");
2108 wxPyEndBlockThreads(blocked);
2109 }
2110 wxPoint GetPosition() { return wxPoint(-1,-1); }
2111 int GetZPosition() { return -1; }
2112 int GetButtonState() { return -1; }
2113 int GetPOVPosition() { return -1; }
2114 int GetPOVCTSPosition() { return -1; }
2115 int GetRudderPosition() { return -1; }
2116 int GetUPosition() { return -1; }
2117 int GetVPosition() { return -1; }
2118 int GetMovementThreshold() { return -1; }
2119 void SetMovementThreshold(int threshold) {}
2120
2121 bool IsOk(void) { return false; }
2122 int GetNumberJoysticks() { return -1; }
2123 int GetManufacturerId() { return -1; }
2124 int GetProductId() { return -1; }
2125 wxString GetProductName() { return wxEmptyString; }
2126 int GetXMin() { return -1; }
2127 int GetYMin() { return -1; }
2128 int GetZMin() { return -1; }
2129 int GetXMax() { return -1; }
2130 int GetYMax() { return -1; }
2131 int GetZMax() { return -1; }
2132 int GetNumberButtons() { return -1; }
2133 int GetNumberAxes() { return -1; }
2134 int GetMaxButtons() { return -1; }
2135 int GetMaxAxes() { return -1; }
2136 int GetPollingMin() { return -1; }
2137 int GetPollingMax() { return -1; }
2138 int GetRudderMin() { return -1; }
2139 int GetRudderMax() { return -1; }
2140 int GetUMin() { return -1; }
2141 int GetUMax() { return -1; }
2142 int GetVMin() { return -1; }
2143 int GetVMax() { return -1; }
2144
2145 bool HasRudder() { return false; }
2146 bool HasZ() { return false; }
2147 bool HasU() { return false; }
2148 bool HasV() { return false; }
2149 bool HasPOV() { return false; }
2150 bool HasPOV4Dir() { return false; }
2151 bool HasPOVCTS() { return false; }
2152
2153 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2154 bool ReleaseCapture() { return false; }
2155 };
2156 #endif
2157
2158
2159 #include <wx/sound.h>
2160
2161
2162 #if !wxUSE_SOUND
2163 // A C++ stub class for wxWave for platforms that don't have it.
2164 class wxSound : public wxObject
2165 {
2166 public:
2167 wxSound() {
2168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2169 PyErr_SetString(PyExc_NotImplementedError,
2170 "wxSound is not available on this platform.");
2171 wxPyEndBlockThreads(blocked);
2172 }
2173 wxSound(const wxString&/*, bool*/) {
2174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2175 PyErr_SetString(PyExc_NotImplementedError,
2176 "wxSound is not available on this platform.");
2177 wxPyEndBlockThreads(blocked);
2178 }
2179 wxSound(int, const wxByte*) {
2180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2181 PyErr_SetString(PyExc_NotImplementedError,
2182 "wxSound is not available on this platform.");
2183 wxPyEndBlockThreads(blocked);
2184 }
2185
2186 ~wxSound() {};
2187
2188 bool Create(const wxString&/*, bool*/) { return false; }
2189 bool Create(int, const wxByte*) { return false; };
2190 bool IsOk() { return false; };
2191 bool Play(unsigned) const { return false; }
2192 static bool Play(const wxString&, unsigned) { return false; }
2193 static void Stop() {}
2194 };
2195
2196 #endif
2197
2198 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2199 if (fileName.Length() == 0)
2200 return new wxSound;
2201 else
2202 return new wxSound(fileName);
2203 }
2204 static wxSound *new_wxSound(PyObject *data){
2205 unsigned char* buffer; int size;
2206 wxSound *sound = NULL;
2207
2208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2209 if (!PyArg_Parse(data, "t#", &buffer, &size))
2210 goto done;
2211 sound = new wxSound(size, buffer);
2212 done:
2213 wxPyEndBlockThreads(blocked);
2214 return sound;
2215 }
2216 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2217 #ifndef __WXMAC__
2218 unsigned char* buffer;
2219 int size;
2220 bool rv = false;
2221
2222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2223 if (!PyArg_Parse(data, "t#", &buffer, &size))
2224 goto done;
2225 rv = self->Create(size, buffer);
2226 done:
2227 wxPyEndBlockThreads(blocked);
2228 return rv;
2229 #else
2230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2231 PyErr_SetString(PyExc_NotImplementedError,
2232 "Create from data is not available on this platform.");
2233 wxPyEndBlockThreads(blocked);
2234 return false;
2235 #endif
2236 }
2237
2238 #include <wx/mimetype.h>
2239
2240 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2241 wxString str;
2242 if (self->GetMimeType(&str))
2243 return wx2PyString(str);
2244 else
2245 RETURN_NONE();
2246 }
2247 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2248 wxArrayString arr;
2249 if (self->GetMimeTypes(arr))
2250 return wxArrayString2PyList_helper(arr);
2251 else
2252 RETURN_NONE();
2253 }
2254 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2255 wxArrayString arr;
2256 if (self->GetExtensions(arr))
2257 return wxArrayString2PyList_helper(arr);
2258 else
2259 RETURN_NONE();
2260 }
2261 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2262 wxIconLocation loc;
2263 if (self->GetIcon(&loc))
2264 return new wxIcon(loc);
2265 else
2266 return NULL;
2267 }
2268 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2269 wxIconLocation loc;
2270 if (self->GetIcon(&loc)) {
2271 wxString iconFile = loc.GetFileName();
2272 int iconIndex = -1;
2273
2274
2275
2276 // Make a tuple and put the values in it
2277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2278 PyObject* tuple = PyTuple_New(3);
2279 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2280 wxT("wxIcon"), true));
2281 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2282 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2283 wxPyEndBlockThreads(blocked);
2284 return tuple;
2285 }
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetDescription(wxFileType *self){
2290 wxString str;
2291 if (self->GetDescription(&str))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxString str;
2298 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2299 return wx2PyString(str);
2300 else
2301 RETURN_NONE();
2302 }
2303 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2304 wxString str;
2305 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2306 return wx2PyString(str);
2307 else
2308 RETURN_NONE();
2309 }
2310 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2311 wxArrayString verbs;
2312 wxArrayString commands;
2313 if (self->GetAllCommands(&verbs, &commands,
2314 wxFileType::MessageParameters(filename, mimetype))) {
2315 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2316 PyObject* tuple = PyTuple_New(2);
2317 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2318 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2319 wxPyEndBlockThreads(blocked);
2320 return tuple;
2321 }
2322 else
2323 RETURN_NONE();
2324 }
2325 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2326 return wxFileType::ExpandCommand(command,
2327 wxFileType::MessageParameters(filename, mimetype));
2328 }
2329 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2330 wxArrayString arr;
2331 self->EnumAllFileTypes(arr);
2332 return wxArrayString2PyList_helper(arr);
2333 }
2334
2335 #include <wx/artprov.h>
2336
2337 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2338 static const wxString wxPyART_MENU(wxART_MENU);
2339 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2340 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2341 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2342 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2343 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2344 static const wxString wxPyART_OTHER(wxART_OTHER);
2345 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2346 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2347 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2348 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2349 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2350 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2351 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2352 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2353 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2354 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2355 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2356 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2357 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2358 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2359 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2360 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2361 static const wxString wxPyART_PRINT(wxART_PRINT);
2362 static const wxString wxPyART_HELP(wxART_HELP);
2363 static const wxString wxPyART_TIP(wxART_TIP);
2364 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2365 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2366 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2367 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2368 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2369 static const wxString wxPyART_CDROM(wxART_CDROM);
2370 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2371 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2372 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2373 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2374 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2375 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2376 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2377 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2378 static const wxString wxPyART_ERROR(wxART_ERROR);
2379 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2380 static const wxString wxPyART_WARNING(wxART_WARNING);
2381 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2382 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2383 static const wxString wxPyART_COPY(wxART_COPY);
2384 static const wxString wxPyART_CUT(wxART_CUT);
2385 static const wxString wxPyART_PASTE(wxART_PASTE);
2386 static const wxString wxPyART_DELETE(wxART_DELETE);
2387 static const wxString wxPyART_NEW(wxART_NEW);
2388 static const wxString wxPyART_UNDO(wxART_UNDO);
2389 static const wxString wxPyART_REDO(wxART_REDO);
2390 static const wxString wxPyART_QUIT(wxART_QUIT);
2391 static const wxString wxPyART_FIND(wxART_FIND);
2392 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2393 // Python aware wxArtProvider
2394 class wxPyArtProvider : public wxArtProvider {
2395 public:
2396
2397 virtual wxBitmap CreateBitmap(const wxArtID& id,
2398 const wxArtClient& client,
2399 const wxSize& size) {
2400 wxBitmap rval = wxNullBitmap;
2401 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2402 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2403 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2404 PyObject* ro;
2405 wxBitmap* ptr;
2406 PyObject* s1, *s2;
2407 s1 = wx2PyString(id);
2408 s2 = wx2PyString(client);
2409 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2410 Py_DECREF(so);
2411 Py_DECREF(s1);
2412 Py_DECREF(s2);
2413 if (ro) {
2414 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2415 rval = *ptr;
2416 Py_DECREF(ro);
2417 }
2418 }
2419 wxPyEndBlockThreads(blocked);
2420 return rval;
2421 }
2422
2423 PYPRIVATE;
2424 };
2425
2426 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2427
2428
2429
2430 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2431 PyObject* ret = PyTuple_New(3);
2432 if (ret) {
2433 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2434 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2435 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2436 }
2437 return ret;
2438 }
2439
2440 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2441 bool cont;
2442 long index = 0;
2443 wxString value;
2444
2445 cont = self->GetFirstGroup(value, index);
2446 return __EnumerationHelper(cont, value, index);
2447 }
2448 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2449 bool cont;
2450 wxString value;
2451
2452 cont = self->GetNextGroup(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2456 bool cont;
2457 long index = 0;
2458 wxString value;
2459
2460 cont = self->GetFirstEntry(value, index);
2461 return __EnumerationHelper(cont, value, index);
2462 }
2463 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2464 bool cont;
2465 wxString value;
2466
2467 cont = self->GetNextEntry(value, index);
2468 return __EnumerationHelper(cont, value, index);
2469 }
2470 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2471 long rv;
2472 self->Read(key, &rv, defaultVal);
2473 return rv;
2474 }
2475
2476 SWIGINTERN int
2477 SWIG_AsVal_double(PyObject *obj, double* val)
2478 {
2479 if (PyNumber_Check(obj)) {
2480 if (val) *val = PyFloat_AsDouble(obj);
2481 return 1;
2482 }
2483 else {
2484 SWIG_type_error("number", obj);
2485 }
2486 return 0;
2487 }
2488
2489
2490 SWIGINTERNSHORT double
2491 SWIG_As_double(PyObject* obj)
2492 {
2493 double v;
2494 if (!SWIG_AsVal_double(obj, &v)) {
2495 /*
2496 this is needed to make valgrind/purify happier.
2497 */
2498 memset((void*)&v, 0, sizeof(double));
2499 }
2500 return v;
2501 }
2502
2503
2504 SWIGINTERNSHORT int
2505 SWIG_Check_double(PyObject* obj)
2506 {
2507 return SWIG_AsVal_double(obj, (double*)0);
2508 }
2509
2510 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2511 double rv;
2512 self->Read(key, &rv, defaultVal);
2513 return rv;
2514 }
2515
2516 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2517 #define SWIG_From_double PyFloat_FromDouble
2518 /*@@*/
2519
2520 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2521 bool rv;
2522 self->Read(key, &rv, defaultVal);
2523 return rv;
2524 }
2525
2526 #include <wx/datetime.h>
2527
2528 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2529 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2530
2531 #define LOCAL_TZ wxDateTime::Local
2532
2533 static PyObject *DateTime_GetAmPmStrings(){
2534 wxString am;
2535 wxString pm;
2536 wxDateTime::GetAmPmStrings(&am, &pm);
2537 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2538 PyObject* tup = PyTuple_New(2);
2539 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2540 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2541 wxPyEndBlockThreads(blocked);
2542 return tup;
2543 }
2544
2545 #if UINT_MAX < LONG_MAX
2546 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2547 #define SWIG_From_unsigned_SS_int SWIG_From_long
2548 /*@@*/
2549 #else
2550 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2552 /*@@*/
2553 #endif
2554
2555 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2556 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2557 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2558 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2559 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2560 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2561 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2562 return (*self < *other);
2563 }
2564 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2565 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2566 return (*self <= *other);
2567 }
2568 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2569 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2570 return (*self > *other);
2571 }
2572 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2573 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2574 return (*self >= *other);
2575 }
2576 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2577 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2578 return (*self == *other);
2579 }
2580 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2581 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2582 return (*self != *other);
2583 }
2584 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2585 const wxChar* rv;
2586 const wxChar* _date = date;
2587 rv = self->ParseRfc822Date(_date);
2588 if (rv == NULL) return -1;
2589 return rv - _date;
2590 }
2591 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2592 const wxChar* rv;
2593 const wxChar* _date = date;
2594 rv = self->ParseFormat(_date, format, dateDef);
2595 if (rv == NULL) return -1;
2596 return rv - _date;
2597 }
2598 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2599 const wxChar* rv;
2600 const wxChar* _datetime = datetime;
2601 rv = self->ParseDateTime(_datetime);
2602 if (rv == NULL) return -1;
2603 return rv - _datetime;
2604 }
2605 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2606 const wxChar* rv;
2607 const wxChar* _date = date;
2608 rv = self->ParseDate(_date);
2609 if (rv == NULL) return -1;
2610 return rv - _date;
2611 }
2612 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2613 const wxChar* rv;
2614 const wxChar* _time = time;
2615 rv = self->ParseTime(_time);
2616 if (rv == NULL) return -1;
2617 return rv - _time;
2618 }
2619 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2620 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2621 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2622 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2623 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2624 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2625 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2626 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2627 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2628 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2629 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2630 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2631 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2632 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2633 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2634 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2635
2636 #include <wx/dataobj.h>
2637
2638 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2639 size_t count = self->GetFormatCount(dir);
2640 wxDataFormat* formats = new wxDataFormat[count];
2641 self->GetAllFormats(formats, dir);
2642
2643 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2644 PyObject* list = PyList_New(count);
2645 for (size_t i=0; i<count; i++) {
2646 wxDataFormat* format = new wxDataFormat(formats[i]);
2647 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2648 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
2649 }
2650 wxPyEndBlockThreads(blocked);
2651 delete [] formats;
2652 return list;
2653 }
2654 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2655 PyObject* rval = NULL;
2656 size_t size = self->GetDataSize(format);
2657 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2658 if (size) {
2659 char* buf = new char[size];
2660 if (self->GetDataHere(format, buf))
2661 rval = PyString_FromStringAndSize(buf, size);
2662 delete [] buf;
2663 }
2664 if (! rval) {
2665 rval = Py_None;
2666 Py_INCREF(rval);
2667 }
2668 wxPyEndBlockThreads(blocked);
2669 return rval;
2670 }
2671 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2672 bool rval;
2673 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2674 if (PyString_Check(data)) {
2675 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2676 }
2677 else {
2678 // raise a TypeError if not a string
2679 PyErr_SetString(PyExc_TypeError, "String expected.");
2680 rval = false;
2681 }
2682 wxPyEndBlockThreads(blocked);
2683 return rval;
2684 }
2685 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2686 PyObject* rval = NULL;
2687 size_t size = self->GetDataSize();
2688 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2689 if (size) {
2690 char* buf = new char[size];
2691 if (self->GetDataHere(buf))
2692 rval = PyString_FromStringAndSize(buf, size);
2693 delete [] buf;
2694 }
2695 if (! rval) {
2696 rval = Py_None;
2697 Py_INCREF(rval);
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 return rval;
2701 }
2702 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2703 bool rval;
2704 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2705 if (PyString_Check(data)) {
2706 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2707 }
2708 else {
2709 // raise a TypeError if not a string
2710 PyErr_SetString(PyExc_TypeError, "String expected.");
2711 rval = false;
2712 }
2713 wxPyEndBlockThreads(blocked);
2714 return rval;
2715 }
2716 // Create a new class for wxPython to use
2717 class wxPyDataObjectSimple : public wxDataObjectSimple {
2718 public:
2719 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2720 : wxDataObjectSimple(format) {}
2721
2722 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2723 bool GetDataHere(void *buf) const;
2724 bool SetData(size_t len, const void *buf) const;
2725 PYPRIVATE;
2726 };
2727
2728 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2729
2730 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2731 // We need to get the data for this object and write it to buf. I think
2732 // the best way to do this for wxPython is to have the Python method
2733 // return either a string or None and then act appropriately with the
2734 // C++ version.
2735
2736 bool rval = false;
2737 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2738 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2739 PyObject* ro;
2740 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2741 if (ro) {
2742 rval = (ro != Py_None && PyString_Check(ro));
2743 if (rval)
2744 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2745 Py_DECREF(ro);
2746 }
2747 }
2748 wxPyEndBlockThreads(blocked);
2749 return rval;
2750 }
2751
2752 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2753 // For this one we simply need to make a string from buf and len
2754 // and send it to the Python method.
2755 bool rval = false;
2756 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2757 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2758 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2759 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2760 Py_DECREF(data);
2761 }
2762 wxPyEndBlockThreads(blocked);
2763 return rval;
2764 }
2765
2766 // Create a new class for wxPython to use
2767 class wxPyTextDataObject : public wxTextDataObject {
2768 public:
2769 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2770 : wxTextDataObject(text) {}
2771
2772 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2773 DEC_PYCALLBACK_STRING__const(GetText);
2774 DEC_PYCALLBACK__STRING(SetText);
2775 PYPRIVATE;
2776 };
2777
2778 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2779 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2780 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2781
2782
2783 // Create a new class for wxPython to use
2784 class wxPyBitmapDataObject : public wxBitmapDataObject {
2785 public:
2786 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2787 : wxBitmapDataObject(bitmap) {}
2788
2789 wxBitmap GetBitmap() const;
2790 void SetBitmap(const wxBitmap& bitmap);
2791 PYPRIVATE;
2792 };
2793
2794 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2795 wxBitmap* rval = &wxNullBitmap;
2796 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2797 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2798 PyObject* ro;
2799 wxBitmap* ptr;
2800 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2801 if (ro) {
2802 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2803 rval = ptr;
2804 Py_DECREF(ro);
2805 }
2806 }
2807 wxPyEndBlockThreads(blocked);
2808 return *rval;
2809 }
2810
2811 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2813 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2814 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2815 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2816 Py_DECREF(bo);
2817 }
2818 wxPyEndBlockThreads(blocked);
2819 }
2820
2821 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2822 return new wxCustomDataObject(wxDataFormat(formatName));
2823 }
2824 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2825 bool rval;
2826 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2827 if (PyString_Check(data)) {
2828 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2829 }
2830 else {
2831 // raise a TypeError if not a string
2832 PyErr_SetString(PyExc_TypeError, "String expected.");
2833 rval = false;
2834 }
2835 wxPyEndBlockThreads(blocked);
2836 return rval;
2837 }
2838 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2839 PyObject* obj;
2840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2841 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2842 wxPyEndBlockThreads(blocked);
2843 return obj;
2844 }
2845
2846 #include <wx/metafile.h>
2847
2848
2849 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2850
2851
2852 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2853 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2854 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2855 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2856 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2857
2858
2859 class wxPyTextDropTarget : public wxTextDropTarget {
2860 public:
2861 wxPyTextDropTarget() {}
2862
2863 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2864
2865 DEC_PYCALLBACK__(OnLeave);
2866 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2867 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2868 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2869 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2870
2871 PYPRIVATE;
2872 };
2873
2874 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2875 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2876 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2877 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2878 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2879 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2880
2881
2882
2883 class wxPyFileDropTarget : public wxFileDropTarget {
2884 public:
2885 wxPyFileDropTarget() {}
2886
2887 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2888
2889 DEC_PYCALLBACK__(OnLeave);
2890 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2891 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2892 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2893 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2894
2895 PYPRIVATE;
2896 };
2897
2898 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2899 const wxArrayString& filenames) {
2900 bool rval = false;
2901 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2902 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2903 PyObject* list = wxArrayString2PyList_helper(filenames);
2904 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2905 Py_DECREF(list);
2906 }
2907 wxPyEndBlockThreads(blocked);
2908 return rval;
2909 }
2910
2911
2912
2913 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2914 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2915 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2916 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2917 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2918
2919
2920
2921
2922 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2923
2924 #include <wx/display.h>
2925
2926 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2927 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2928
2929 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2930 #if !wxUSE_DISPLAY
2931 #include <wx/dynarray.h>
2932 #include <wx/vidmode.h>
2933
2934 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2935 #include "wx/arrimpl.cpp"
2936 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2937 const wxVideoMode wxDefaultVideoMode;
2938
2939 class wxDisplay
2940 {
2941 public:
2942 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2943 ~wxDisplay() {}
2944
2945 static size_t GetCount()
2946 { wxPyRaiseNotImplemented(); return 0; }
2947
2948 static int GetFromPoint(const wxPoint& pt)
2949 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2950 static int GetFromWindow(wxWindow *window)
2951 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2952
2953 virtual bool IsOk() const { return false; }
2954 virtual wxRect GetGeometry() const { wxRect r; return r; }
2955 virtual wxString GetName() const { return wxEmptyString; }
2956 bool IsPrimary() const { return false; }
2957
2958 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2959 { wxArrayVideoModes a; return a; }
2960
2961 virtual wxVideoMode GetCurrentMode() const
2962 { return wxDefaultVideoMode; }
2963
2964 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2965 { return false; }
2966
2967 void ResetMode() {}
2968 };
2969 #endif
2970
2971 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2972 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2973 PyObject* pyList = NULL;
2974 wxArrayVideoModes arr = self->GetModes(mode);
2975 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2976 pyList = PyList_New(0);
2977 for (int i=0; i < arr.GetCount(); i++) {
2978 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2979 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2980 PyList_Append(pyList, pyObj);
2981 Py_DECREF(pyObj);
2982 }
2983 wxPyEndBlockThreads(blocked);
2984 return pyList;
2985 }
2986
2987 #include <wx/stdpaths.h>
2988
2989 static wxStandardPaths *StandardPaths_Get(){
2990 return (wxStandardPaths*) &wxStandardPaths::Get();
2991 }
2992 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2993 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2994 #ifdef __cplusplus
2995 extern "C" {
2996 #endif
2997 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2998 PyObject *resultobj;
2999 wxSystemColour arg1 ;
3000 wxColour result;
3001 PyObject * obj0 = 0 ;
3002 char *kwnames[] = {
3003 (char *) "index", NULL
3004 };
3005
3006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3007 {
3008 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3009 if (SWIG_arg_fail(1)) SWIG_fail;
3010 }
3011 {
3012 if (!wxPyCheckForApp()) SWIG_fail;
3013 PyThreadState* __tstate = wxPyBeginAllowThreads();
3014 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3015
3016 wxPyEndAllowThreads(__tstate);
3017 if (PyErr_Occurred()) SWIG_fail;
3018 }
3019 {
3020 wxColour * resultptr;
3021 resultptr = new wxColour((wxColour &)(result));
3022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3023 }
3024 return resultobj;
3025 fail:
3026 return NULL;
3027 }
3028
3029
3030 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3031 PyObject *resultobj;
3032 wxSystemFont arg1 ;
3033 wxFont result;
3034 PyObject * obj0 = 0 ;
3035 char *kwnames[] = {
3036 (char *) "index", NULL
3037 };
3038
3039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3040 {
3041 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3042 if (SWIG_arg_fail(1)) SWIG_fail;
3043 }
3044 {
3045 if (!wxPyCheckForApp()) SWIG_fail;
3046 PyThreadState* __tstate = wxPyBeginAllowThreads();
3047 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3048
3049 wxPyEndAllowThreads(__tstate);
3050 if (PyErr_Occurred()) SWIG_fail;
3051 }
3052 {
3053 wxFont * resultptr;
3054 resultptr = new wxFont((wxFont &)(result));
3055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3056 }
3057 return resultobj;
3058 fail:
3059 return NULL;
3060 }
3061
3062
3063 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3064 PyObject *resultobj;
3065 wxSystemMetric arg1 ;
3066 wxWindow *arg2 = (wxWindow *) NULL ;
3067 int result;
3068 PyObject * obj0 = 0 ;
3069 PyObject * obj1 = 0 ;
3070 char *kwnames[] = {
3071 (char *) "index",(char *) "win", NULL
3072 };
3073
3074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3075 {
3076 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3077 if (SWIG_arg_fail(1)) SWIG_fail;
3078 }
3079 if (obj1) {
3080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3081 if (SWIG_arg_fail(2)) SWIG_fail;
3082 }
3083 {
3084 if (!wxPyCheckForApp()) SWIG_fail;
3085 PyThreadState* __tstate = wxPyBeginAllowThreads();
3086 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3087
3088 wxPyEndAllowThreads(__tstate);
3089 if (PyErr_Occurred()) SWIG_fail;
3090 }
3091 {
3092 resultobj = SWIG_From_int((int)(result));
3093 }
3094 return resultobj;
3095 fail:
3096 return NULL;
3097 }
3098
3099
3100 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3101 PyObject *resultobj;
3102 wxSystemFeature arg1 ;
3103 bool result;
3104 PyObject * obj0 = 0 ;
3105 char *kwnames[] = {
3106 (char *) "index", NULL
3107 };
3108
3109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3110 {
3111 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3112 if (SWIG_arg_fail(1)) SWIG_fail;
3113 }
3114 {
3115 if (!wxPyCheckForApp()) SWIG_fail;
3116 PyThreadState* __tstate = wxPyBeginAllowThreads();
3117 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3118
3119 wxPyEndAllowThreads(__tstate);
3120 if (PyErr_Occurred()) SWIG_fail;
3121 }
3122 {
3123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3124 }
3125 return resultobj;
3126 fail:
3127 return NULL;
3128 }
3129
3130
3131 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3132 PyObject *resultobj;
3133 wxSystemScreenType result;
3134 char *kwnames[] = {
3135 NULL
3136 };
3137
3138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3139 {
3140 if (!wxPyCheckForApp()) SWIG_fail;
3141 PyThreadState* __tstate = wxPyBeginAllowThreads();
3142 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3143
3144 wxPyEndAllowThreads(__tstate);
3145 if (PyErr_Occurred()) SWIG_fail;
3146 }
3147 resultobj = SWIG_From_int((result));
3148 return resultobj;
3149 fail:
3150 return NULL;
3151 }
3152
3153
3154 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3155 PyObject *resultobj;
3156 wxSystemScreenType arg1 ;
3157 PyObject * obj0 = 0 ;
3158 char *kwnames[] = {
3159 (char *) "screen", NULL
3160 };
3161
3162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3163 {
3164 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3165 if (SWIG_arg_fail(1)) SWIG_fail;
3166 }
3167 {
3168 if (!wxPyCheckForApp()) SWIG_fail;
3169 PyThreadState* __tstate = wxPyBeginAllowThreads();
3170 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3171
3172 wxPyEndAllowThreads(__tstate);
3173 if (PyErr_Occurred()) SWIG_fail;
3174 }
3175 Py_INCREF(Py_None); resultobj = Py_None;
3176 return resultobj;
3177 fail:
3178 return NULL;
3179 }
3180
3181
3182 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3183 PyObject *obj;
3184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3185 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3186 Py_INCREF(obj);
3187 return Py_BuildValue((char *)"");
3188 }
3189 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3190 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3191 return 1;
3192 }
3193
3194
3195 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3196 PyObject *pyobj;
3197
3198 {
3199 #if wxUSE_UNICODE
3200 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3201 #else
3202 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3203 #endif
3204 }
3205 return pyobj;
3206 }
3207
3208
3209 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3210 PyObject *resultobj;
3211 wxSystemOptions *result;
3212 char *kwnames[] = {
3213 NULL
3214 };
3215
3216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3217 {
3218 PyThreadState* __tstate = wxPyBeginAllowThreads();
3219 result = (wxSystemOptions *)new wxSystemOptions();
3220
3221 wxPyEndAllowThreads(__tstate);
3222 if (PyErr_Occurred()) SWIG_fail;
3223 }
3224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3225 return resultobj;
3226 fail:
3227 return NULL;
3228 }
3229
3230
3231 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3232 PyObject *resultobj;
3233 wxString *arg1 = 0 ;
3234 wxString *arg2 = 0 ;
3235 bool temp1 = false ;
3236 bool temp2 = false ;
3237 PyObject * obj0 = 0 ;
3238 PyObject * obj1 = 0 ;
3239 char *kwnames[] = {
3240 (char *) "name",(char *) "value", NULL
3241 };
3242
3243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3244 {
3245 arg1 = wxString_in_helper(obj0);
3246 if (arg1 == NULL) SWIG_fail;
3247 temp1 = true;
3248 }
3249 {
3250 arg2 = wxString_in_helper(obj1);
3251 if (arg2 == NULL) SWIG_fail;
3252 temp2 = true;
3253 }
3254 {
3255 PyThreadState* __tstate = wxPyBeginAllowThreads();
3256 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3257
3258 wxPyEndAllowThreads(__tstate);
3259 if (PyErr_Occurred()) SWIG_fail;
3260 }
3261 Py_INCREF(Py_None); resultobj = Py_None;
3262 {
3263 if (temp1)
3264 delete arg1;
3265 }
3266 {
3267 if (temp2)
3268 delete arg2;
3269 }
3270 return resultobj;
3271 fail:
3272 {
3273 if (temp1)
3274 delete arg1;
3275 }
3276 {
3277 if (temp2)
3278 delete arg2;
3279 }
3280 return NULL;
3281 }
3282
3283
3284 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3285 PyObject *resultobj;
3286 wxString *arg1 = 0 ;
3287 int arg2 ;
3288 bool temp1 = false ;
3289 PyObject * obj0 = 0 ;
3290 PyObject * obj1 = 0 ;
3291 char *kwnames[] = {
3292 (char *) "name",(char *) "value", NULL
3293 };
3294
3295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3296 {
3297 arg1 = wxString_in_helper(obj0);
3298 if (arg1 == NULL) SWIG_fail;
3299 temp1 = true;
3300 }
3301 {
3302 arg2 = (int)(SWIG_As_int(obj1));
3303 if (SWIG_arg_fail(2)) SWIG_fail;
3304 }
3305 {
3306 PyThreadState* __tstate = wxPyBeginAllowThreads();
3307 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3308
3309 wxPyEndAllowThreads(__tstate);
3310 if (PyErr_Occurred()) SWIG_fail;
3311 }
3312 Py_INCREF(Py_None); resultobj = Py_None;
3313 {
3314 if (temp1)
3315 delete arg1;
3316 }
3317 return resultobj;
3318 fail:
3319 {
3320 if (temp1)
3321 delete arg1;
3322 }
3323 return NULL;
3324 }
3325
3326
3327 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3328 PyObject *resultobj;
3329 wxString *arg1 = 0 ;
3330 wxString result;
3331 bool temp1 = false ;
3332 PyObject * obj0 = 0 ;
3333 char *kwnames[] = {
3334 (char *) "name", NULL
3335 };
3336
3337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3338 {
3339 arg1 = wxString_in_helper(obj0);
3340 if (arg1 == NULL) SWIG_fail;
3341 temp1 = true;
3342 }
3343 {
3344 PyThreadState* __tstate = wxPyBeginAllowThreads();
3345 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3346
3347 wxPyEndAllowThreads(__tstate);
3348 if (PyErr_Occurred()) SWIG_fail;
3349 }
3350 {
3351 #if wxUSE_UNICODE
3352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3353 #else
3354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3355 #endif
3356 }
3357 {
3358 if (temp1)
3359 delete arg1;
3360 }
3361 return resultobj;
3362 fail:
3363 {
3364 if (temp1)
3365 delete arg1;
3366 }
3367 return NULL;
3368 }
3369
3370
3371 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3372 PyObject *resultobj;
3373 wxString *arg1 = 0 ;
3374 int result;
3375 bool temp1 = false ;
3376 PyObject * obj0 = 0 ;
3377 char *kwnames[] = {
3378 (char *) "name", NULL
3379 };
3380
3381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3382 {
3383 arg1 = wxString_in_helper(obj0);
3384 if (arg1 == NULL) SWIG_fail;
3385 temp1 = true;
3386 }
3387 {
3388 PyThreadState* __tstate = wxPyBeginAllowThreads();
3389 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3390
3391 wxPyEndAllowThreads(__tstate);
3392 if (PyErr_Occurred()) SWIG_fail;
3393 }
3394 {
3395 resultobj = SWIG_From_int((int)(result));
3396 }
3397 {
3398 if (temp1)
3399 delete arg1;
3400 }
3401 return resultobj;
3402 fail:
3403 {
3404 if (temp1)
3405 delete arg1;
3406 }
3407 return NULL;
3408 }
3409
3410
3411 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3412 PyObject *resultobj;
3413 wxString *arg1 = 0 ;
3414 bool result;
3415 bool temp1 = false ;
3416 PyObject * obj0 = 0 ;
3417 char *kwnames[] = {
3418 (char *) "name", NULL
3419 };
3420
3421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3422 {
3423 arg1 = wxString_in_helper(obj0);
3424 if (arg1 == NULL) SWIG_fail;
3425 temp1 = true;
3426 }
3427 {
3428 PyThreadState* __tstate = wxPyBeginAllowThreads();
3429 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3430
3431 wxPyEndAllowThreads(__tstate);
3432 if (PyErr_Occurred()) SWIG_fail;
3433 }
3434 {
3435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3436 }
3437 {
3438 if (temp1)
3439 delete arg1;
3440 }
3441 return resultobj;
3442 fail:
3443 {
3444 if (temp1)
3445 delete arg1;
3446 }
3447 return NULL;
3448 }
3449
3450
3451 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3452 PyObject *resultobj;
3453 wxString *arg1 = 0 ;
3454 bool result;
3455 bool temp1 = false ;
3456 PyObject * obj0 = 0 ;
3457 char *kwnames[] = {
3458 (char *) "name", NULL
3459 };
3460
3461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3462 {
3463 arg1 = wxString_in_helper(obj0);
3464 if (arg1 == NULL) SWIG_fail;
3465 temp1 = true;
3466 }
3467 {
3468 PyThreadState* __tstate = wxPyBeginAllowThreads();
3469 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3470
3471 wxPyEndAllowThreads(__tstate);
3472 if (PyErr_Occurred()) SWIG_fail;
3473 }
3474 {
3475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3476 }
3477 {
3478 if (temp1)
3479 delete arg1;
3480 }
3481 return resultobj;
3482 fail:
3483 {
3484 if (temp1)
3485 delete arg1;
3486 }
3487 return NULL;
3488 }
3489
3490
3491 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3492 PyObject *obj;
3493 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3494 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3495 Py_INCREF(obj);
3496 return Py_BuildValue((char *)"");
3497 }
3498 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3499 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3500 return 1;
3501 }
3502
3503
3504 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3505 PyObject *pyobj;
3506
3507 {
3508 #if wxUSE_UNICODE
3509 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3510 #else
3511 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3512 #endif
3513 }
3514 return pyobj;
3515 }
3516
3517
3518 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3519 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3520 return 1;
3521 }
3522
3523
3524 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3525 PyObject *pyobj;
3526
3527 {
3528 #if wxUSE_UNICODE
3529 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3530 #else
3531 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3532 #endif
3533 }
3534 return pyobj;
3535 }
3536
3537
3538 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3539 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3540 return 1;
3541 }
3542
3543
3544 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3545 PyObject *pyobj;
3546
3547 {
3548 #if wxUSE_UNICODE
3549 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3550 #else
3551 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3552 #endif
3553 }
3554 return pyobj;
3555 }
3556
3557
3558 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3559 PyObject *resultobj;
3560 long result;
3561 char *kwnames[] = {
3562 NULL
3563 };
3564
3565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3566 {
3567 PyThreadState* __tstate = wxPyBeginAllowThreads();
3568 result = (long)wxNewId();
3569
3570 wxPyEndAllowThreads(__tstate);
3571 if (PyErr_Occurred()) SWIG_fail;
3572 }
3573 {
3574 resultobj = SWIG_From_long((long)(result));
3575 }
3576 return resultobj;
3577 fail:
3578 return NULL;
3579 }
3580
3581
3582 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3583 PyObject *resultobj;
3584 long arg1 ;
3585 PyObject * obj0 = 0 ;
3586 char *kwnames[] = {
3587 (char *) "id", NULL
3588 };
3589
3590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3591 {
3592 arg1 = (long)(SWIG_As_long(obj0));
3593 if (SWIG_arg_fail(1)) SWIG_fail;
3594 }
3595 {
3596 PyThreadState* __tstate = wxPyBeginAllowThreads();
3597 wxRegisterId(arg1);
3598
3599 wxPyEndAllowThreads(__tstate);
3600 if (PyErr_Occurred()) SWIG_fail;
3601 }
3602 Py_INCREF(Py_None); resultobj = Py_None;
3603 return resultobj;
3604 fail:
3605 return NULL;
3606 }
3607
3608
3609 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3610 PyObject *resultobj;
3611 long result;
3612 char *kwnames[] = {
3613 NULL
3614 };
3615
3616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3617 {
3618 PyThreadState* __tstate = wxPyBeginAllowThreads();
3619 result = (long)wxGetCurrentId();
3620
3621 wxPyEndAllowThreads(__tstate);
3622 if (PyErr_Occurred()) SWIG_fail;
3623 }
3624 {
3625 resultobj = SWIG_From_long((long)(result));
3626 }
3627 return resultobj;
3628 fail:
3629 return NULL;
3630 }
3631
3632
3633 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3634 PyObject *resultobj;
3635 int arg1 ;
3636 bool result;
3637 PyObject * obj0 = 0 ;
3638 char *kwnames[] = {
3639 (char *) "id", NULL
3640 };
3641
3642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3643 {
3644 arg1 = (int)(SWIG_As_int(obj0));
3645 if (SWIG_arg_fail(1)) SWIG_fail;
3646 }
3647 {
3648 PyThreadState* __tstate = wxPyBeginAllowThreads();
3649 result = (bool)wxIsStockID(arg1);
3650
3651 wxPyEndAllowThreads(__tstate);
3652 if (PyErr_Occurred()) SWIG_fail;
3653 }
3654 {
3655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3656 }
3657 return resultobj;
3658 fail:
3659 return NULL;
3660 }
3661
3662
3663 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3664 PyObject *resultobj;
3665 int arg1 ;
3666 wxString *arg2 = 0 ;
3667 bool result;
3668 bool temp2 = false ;
3669 PyObject * obj0 = 0 ;
3670 PyObject * obj1 = 0 ;
3671 char *kwnames[] = {
3672 (char *) "id",(char *) "label", NULL
3673 };
3674
3675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3676 {
3677 arg1 = (int)(SWIG_As_int(obj0));
3678 if (SWIG_arg_fail(1)) SWIG_fail;
3679 }
3680 {
3681 arg2 = wxString_in_helper(obj1);
3682 if (arg2 == NULL) SWIG_fail;
3683 temp2 = true;
3684 }
3685 {
3686 PyThreadState* __tstate = wxPyBeginAllowThreads();
3687 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3688
3689 wxPyEndAllowThreads(__tstate);
3690 if (PyErr_Occurred()) SWIG_fail;
3691 }
3692 {
3693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3694 }
3695 {
3696 if (temp2)
3697 delete arg2;
3698 }
3699 return resultobj;
3700 fail:
3701 {
3702 if (temp2)
3703 delete arg2;
3704 }
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 int arg1 ;
3712 bool arg2 = (bool) true ;
3713 wxString arg3 = (wxString) wxPyEmptyString ;
3714 wxString result;
3715 PyObject * obj0 = 0 ;
3716 PyObject * obj1 = 0 ;
3717 PyObject * obj2 = 0 ;
3718 char *kwnames[] = {
3719 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3720 };
3721
3722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3723 {
3724 arg1 = (int)(SWIG_As_int(obj0));
3725 if (SWIG_arg_fail(1)) SWIG_fail;
3726 }
3727 if (obj1) {
3728 {
3729 arg2 = (bool)(SWIG_As_bool(obj1));
3730 if (SWIG_arg_fail(2)) SWIG_fail;
3731 }
3732 }
3733 if (obj2) {
3734 {
3735 wxString* sptr = wxString_in_helper(obj2);
3736 if (sptr == NULL) SWIG_fail;
3737 arg3 = *sptr;
3738 delete sptr;
3739 }
3740 }
3741 {
3742 PyThreadState* __tstate = wxPyBeginAllowThreads();
3743 result = wxGetStockLabel(arg1,arg2,arg3);
3744
3745 wxPyEndAllowThreads(__tstate);
3746 if (PyErr_Occurred()) SWIG_fail;
3747 }
3748 {
3749 #if wxUSE_UNICODE
3750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3751 #else
3752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3753 #endif
3754 }
3755 return resultobj;
3756 fail:
3757 return NULL;
3758 }
3759
3760
3761 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3762 PyObject *resultobj;
3763 char *kwnames[] = {
3764 NULL
3765 };
3766
3767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3768 {
3769 if (!wxPyCheckForApp()) SWIG_fail;
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 wxBell();
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 Py_INCREF(Py_None); resultobj = Py_None;
3777 return resultobj;
3778 fail:
3779 return NULL;
3780 }
3781
3782
3783 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3784 PyObject *resultobj;
3785 char *kwnames[] = {
3786 NULL
3787 };
3788
3789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3790 {
3791 if (!wxPyCheckForApp()) SWIG_fail;
3792 PyThreadState* __tstate = wxPyBeginAllowThreads();
3793 wxEndBusyCursor();
3794
3795 wxPyEndAllowThreads(__tstate);
3796 if (PyErr_Occurred()) SWIG_fail;
3797 }
3798 Py_INCREF(Py_None); resultobj = Py_None;
3799 return resultobj;
3800 fail:
3801 return NULL;
3802 }
3803
3804
3805 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3806 PyObject *resultobj;
3807 bool arg1 = (bool) true ;
3808 long result;
3809 PyObject * obj0 = 0 ;
3810 char *kwnames[] = {
3811 (char *) "resetTimer", NULL
3812 };
3813
3814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3815 if (obj0) {
3816 {
3817 arg1 = (bool)(SWIG_As_bool(obj0));
3818 if (SWIG_arg_fail(1)) SWIG_fail;
3819 }
3820 }
3821 {
3822 PyThreadState* __tstate = wxPyBeginAllowThreads();
3823 result = (long)wxGetElapsedTime(arg1);
3824
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 {
3829 resultobj = SWIG_From_long((long)(result));
3830 }
3831 return resultobj;
3832 fail:
3833 return NULL;
3834 }
3835
3836
3837 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3838 PyObject *resultobj;
3839 int *arg1 = (int *) 0 ;
3840 int *arg2 = (int *) 0 ;
3841 int temp1 ;
3842 int res1 = 0 ;
3843 int temp2 ;
3844 int res2 = 0 ;
3845 char *kwnames[] = {
3846 NULL
3847 };
3848
3849 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3850 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3852 {
3853 if (!wxPyCheckForApp()) SWIG_fail;
3854 PyThreadState* __tstate = wxPyBeginAllowThreads();
3855 wxGetMousePosition(arg1,arg2);
3856
3857 wxPyEndAllowThreads(__tstate);
3858 if (PyErr_Occurred()) SWIG_fail;
3859 }
3860 Py_INCREF(Py_None); resultobj = Py_None;
3861 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3862 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3863 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3864 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 bool result;
3874 char *kwnames[] = {
3875 NULL
3876 };
3877
3878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3879 {
3880 PyThreadState* __tstate = wxPyBeginAllowThreads();
3881 result = (bool)wxIsBusy();
3882
3883 wxPyEndAllowThreads(__tstate);
3884 if (PyErr_Occurred()) SWIG_fail;
3885 }
3886 {
3887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3888 }
3889 return resultobj;
3890 fail:
3891 return NULL;
3892 }
3893
3894
3895 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3896 PyObject *resultobj;
3897 wxString result;
3898 char *kwnames[] = {
3899 NULL
3900 };
3901
3902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3903 {
3904 PyThreadState* __tstate = wxPyBeginAllowThreads();
3905 result = wxNow();
3906
3907 wxPyEndAllowThreads(__tstate);
3908 if (PyErr_Occurred()) SWIG_fail;
3909 }
3910 {
3911 #if wxUSE_UNICODE
3912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3913 #else
3914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3915 #endif
3916 }
3917 return resultobj;
3918 fail:
3919 return NULL;
3920 }
3921
3922
3923 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3924 PyObject *resultobj;
3925 wxString const &arg1_defvalue = wxPyEmptyString ;
3926 wxString *arg1 = (wxString *) &arg1_defvalue ;
3927 bool result;
3928 bool temp1 = false ;
3929 PyObject * obj0 = 0 ;
3930 char *kwnames[] = {
3931 (char *) "command", NULL
3932 };
3933
3934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3935 if (obj0) {
3936 {
3937 arg1 = wxString_in_helper(obj0);
3938 if (arg1 == NULL) SWIG_fail;
3939 temp1 = true;
3940 }
3941 }
3942 {
3943 PyThreadState* __tstate = wxPyBeginAllowThreads();
3944 result = (bool)wxShell((wxString const &)*arg1);
3945
3946 wxPyEndAllowThreads(__tstate);
3947 if (PyErr_Occurred()) SWIG_fail;
3948 }
3949 {
3950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3951 }
3952 {
3953 if (temp1)
3954 delete arg1;
3955 }
3956 return resultobj;
3957 fail:
3958 {
3959 if (temp1)
3960 delete arg1;
3961 }
3962 return NULL;
3963 }
3964
3965
3966 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3967 PyObject *resultobj;
3968 char *kwnames[] = {
3969 NULL
3970 };
3971
3972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3973 {
3974 PyThreadState* __tstate = wxPyBeginAllowThreads();
3975 wxStartTimer();
3976
3977 wxPyEndAllowThreads(__tstate);
3978 if (PyErr_Occurred()) SWIG_fail;
3979 }
3980 Py_INCREF(Py_None); resultobj = Py_None;
3981 return resultobj;
3982 fail:
3983 return NULL;
3984 }
3985
3986
3987 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3988 PyObject *resultobj;
3989 int *arg1 = (int *) 0 ;
3990 int *arg2 = (int *) 0 ;
3991 int result;
3992 int temp1 ;
3993 int res1 = 0 ;
3994 int temp2 ;
3995 int res2 = 0 ;
3996 char *kwnames[] = {
3997 NULL
3998 };
3999
4000 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4001 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4003 {
4004 PyThreadState* __tstate = wxPyBeginAllowThreads();
4005 result = (int)wxGetOsVersion(arg1,arg2);
4006
4007 wxPyEndAllowThreads(__tstate);
4008 if (PyErr_Occurred()) SWIG_fail;
4009 }
4010 {
4011 resultobj = SWIG_From_int((int)(result));
4012 }
4013 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4014 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4015 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4016 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
4023 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4024 PyObject *resultobj;
4025 wxString result;
4026 char *kwnames[] = {
4027 NULL
4028 };
4029
4030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4031 {
4032 PyThreadState* __tstate = wxPyBeginAllowThreads();
4033 result = wxGetOsDescription();
4034
4035 wxPyEndAllowThreads(__tstate);
4036 if (PyErr_Occurred()) SWIG_fail;
4037 }
4038 {
4039 #if wxUSE_UNICODE
4040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4041 #else
4042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4043 #endif
4044 }
4045 return resultobj;
4046 fail:
4047 return NULL;
4048 }
4049
4050
4051 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4052 PyObject *resultobj;
4053 wxMemorySize result;
4054 char *kwnames[] = {
4055 NULL
4056 };
4057
4058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4059 {
4060 PyThreadState* __tstate = wxPyBeginAllowThreads();
4061 result = wxGetFreeMemory();
4062
4063 wxPyEndAllowThreads(__tstate);
4064 if (PyErr_Occurred()) SWIG_fail;
4065 }
4066 {
4067 wxMemorySize * resultptr;
4068 resultptr = new wxMemorySize((wxMemorySize &)(result));
4069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMemorySize, 1);
4070 }
4071 return resultobj;
4072 fail:
4073 return NULL;
4074 }
4075
4076
4077 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4078 PyObject *resultobj;
4079 wxShutdownFlags arg1 ;
4080 bool result;
4081 PyObject * obj0 = 0 ;
4082 char *kwnames[] = {
4083 (char *) "wFlags", NULL
4084 };
4085
4086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4087 {
4088 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4089 if (SWIG_arg_fail(1)) SWIG_fail;
4090 }
4091 {
4092 if (!wxPyCheckForApp()) SWIG_fail;
4093 PyThreadState* __tstate = wxPyBeginAllowThreads();
4094 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4095
4096 wxPyEndAllowThreads(__tstate);
4097 if (PyErr_Occurred()) SWIG_fail;
4098 }
4099 {
4100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4101 }
4102 return resultobj;
4103 fail:
4104 return NULL;
4105 }
4106
4107
4108 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj;
4110 int arg1 ;
4111 PyObject * obj0 = 0 ;
4112 char *kwnames[] = {
4113 (char *) "secs", NULL
4114 };
4115
4116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4117 {
4118 arg1 = (int)(SWIG_As_int(obj0));
4119 if (SWIG_arg_fail(1)) SWIG_fail;
4120 }
4121 {
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 wxSleep(arg1);
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 Py_INCREF(Py_None); resultobj = Py_None;
4129 return resultobj;
4130 fail:
4131 return NULL;
4132 }
4133
4134
4135 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4136 PyObject *resultobj;
4137 unsigned long arg1 ;
4138 PyObject * obj0 = 0 ;
4139 char *kwnames[] = {
4140 (char *) "milliseconds", NULL
4141 };
4142
4143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4144 {
4145 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4146 if (SWIG_arg_fail(1)) SWIG_fail;
4147 }
4148 {
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 wxMilliSleep(arg1);
4151
4152 wxPyEndAllowThreads(__tstate);
4153 if (PyErr_Occurred()) SWIG_fail;
4154 }
4155 Py_INCREF(Py_None); resultobj = Py_None;
4156 return resultobj;
4157 fail:
4158 return NULL;
4159 }
4160
4161
4162 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4163 PyObject *resultobj;
4164 unsigned long arg1 ;
4165 PyObject * obj0 = 0 ;
4166 char *kwnames[] = {
4167 (char *) "microseconds", NULL
4168 };
4169
4170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4171 {
4172 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4173 if (SWIG_arg_fail(1)) SWIG_fail;
4174 }
4175 {
4176 PyThreadState* __tstate = wxPyBeginAllowThreads();
4177 wxMicroSleep(arg1);
4178
4179 wxPyEndAllowThreads(__tstate);
4180 if (PyErr_Occurred()) SWIG_fail;
4181 }
4182 Py_INCREF(Py_None); resultobj = Py_None;
4183 return resultobj;
4184 fail:
4185 return NULL;
4186 }
4187
4188
4189 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4190 PyObject *resultobj;
4191 bool arg1 ;
4192 PyObject * obj0 = 0 ;
4193 char *kwnames[] = {
4194 (char *) "enable", NULL
4195 };
4196
4197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4198 {
4199 arg1 = (bool)(SWIG_As_bool(obj0));
4200 if (SWIG_arg_fail(1)) SWIG_fail;
4201 }
4202 {
4203 PyThreadState* __tstate = wxPyBeginAllowThreads();
4204 wxEnableTopLevelWindows(arg1);
4205
4206 wxPyEndAllowThreads(__tstate);
4207 if (PyErr_Occurred()) SWIG_fail;
4208 }
4209 Py_INCREF(Py_None); resultobj = Py_None;
4210 return resultobj;
4211 fail:
4212 return NULL;
4213 }
4214
4215
4216 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4217 PyObject *resultobj;
4218 wxString *arg1 = 0 ;
4219 wxString result;
4220 bool temp1 = false ;
4221 PyObject * obj0 = 0 ;
4222 char *kwnames[] = {
4223 (char *) "in", NULL
4224 };
4225
4226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4227 {
4228 arg1 = wxString_in_helper(obj0);
4229 if (arg1 == NULL) SWIG_fail;
4230 temp1 = true;
4231 }
4232 {
4233 PyThreadState* __tstate = wxPyBeginAllowThreads();
4234 result = wxStripMenuCodes((wxString const &)*arg1);
4235
4236 wxPyEndAllowThreads(__tstate);
4237 if (PyErr_Occurred()) SWIG_fail;
4238 }
4239 {
4240 #if wxUSE_UNICODE
4241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4242 #else
4243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4244 #endif
4245 }
4246 {
4247 if (temp1)
4248 delete arg1;
4249 }
4250 return resultobj;
4251 fail:
4252 {
4253 if (temp1)
4254 delete arg1;
4255 }
4256 return NULL;
4257 }
4258
4259
4260 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4261 PyObject *resultobj;
4262 wxString result;
4263 char *kwnames[] = {
4264 NULL
4265 };
4266
4267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 result = wxGetEmailAddress();
4271
4272 wxPyEndAllowThreads(__tstate);
4273 if (PyErr_Occurred()) SWIG_fail;
4274 }
4275 {
4276 #if wxUSE_UNICODE
4277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4278 #else
4279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4280 #endif
4281 }
4282 return resultobj;
4283 fail:
4284 return NULL;
4285 }
4286
4287
4288 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4289 PyObject *resultobj;
4290 wxString result;
4291 char *kwnames[] = {
4292 NULL
4293 };
4294
4295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4296 {
4297 PyThreadState* __tstate = wxPyBeginAllowThreads();
4298 result = wxGetHostName();
4299
4300 wxPyEndAllowThreads(__tstate);
4301 if (PyErr_Occurred()) SWIG_fail;
4302 }
4303 {
4304 #if wxUSE_UNICODE
4305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4306 #else
4307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4308 #endif
4309 }
4310 return resultobj;
4311 fail:
4312 return NULL;
4313 }
4314
4315
4316 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4317 PyObject *resultobj;
4318 wxString result;
4319 char *kwnames[] = {
4320 NULL
4321 };
4322
4323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4324 {
4325 PyThreadState* __tstate = wxPyBeginAllowThreads();
4326 result = wxGetFullHostName();
4327
4328 wxPyEndAllowThreads(__tstate);
4329 if (PyErr_Occurred()) SWIG_fail;
4330 }
4331 {
4332 #if wxUSE_UNICODE
4333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4334 #else
4335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4336 #endif
4337 }
4338 return resultobj;
4339 fail:
4340 return NULL;
4341 }
4342
4343
4344 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4345 PyObject *resultobj;
4346 wxString result;
4347 char *kwnames[] = {
4348 NULL
4349 };
4350
4351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4352 {
4353 PyThreadState* __tstate = wxPyBeginAllowThreads();
4354 result = wxGetUserId();
4355
4356 wxPyEndAllowThreads(__tstate);
4357 if (PyErr_Occurred()) SWIG_fail;
4358 }
4359 {
4360 #if wxUSE_UNICODE
4361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4362 #else
4363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4364 #endif
4365 }
4366 return resultobj;
4367 fail:
4368 return NULL;
4369 }
4370
4371
4372 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4373 PyObject *resultobj;
4374 wxString result;
4375 char *kwnames[] = {
4376 NULL
4377 };
4378
4379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4380 {
4381 PyThreadState* __tstate = wxPyBeginAllowThreads();
4382 result = wxGetUserName();
4383
4384 wxPyEndAllowThreads(__tstate);
4385 if (PyErr_Occurred()) SWIG_fail;
4386 }
4387 {
4388 #if wxUSE_UNICODE
4389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4390 #else
4391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4392 #endif
4393 }
4394 return resultobj;
4395 fail:
4396 return NULL;
4397 }
4398
4399
4400 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4401 PyObject *resultobj;
4402 wxString result;
4403 char *kwnames[] = {
4404 NULL
4405 };
4406
4407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 result = wxGetHomeDir();
4411
4412 wxPyEndAllowThreads(__tstate);
4413 if (PyErr_Occurred()) SWIG_fail;
4414 }
4415 {
4416 #if wxUSE_UNICODE
4417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4418 #else
4419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4420 #endif
4421 }
4422 return resultobj;
4423 fail:
4424 return NULL;
4425 }
4426
4427
4428 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4429 PyObject *resultobj;
4430 wxString const &arg1_defvalue = wxPyEmptyString ;
4431 wxString *arg1 = (wxString *) &arg1_defvalue ;
4432 wxString result;
4433 bool temp1 = false ;
4434 PyObject * obj0 = 0 ;
4435 char *kwnames[] = {
4436 (char *) "user", NULL
4437 };
4438
4439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4440 if (obj0) {
4441 {
4442 arg1 = wxString_in_helper(obj0);
4443 if (arg1 == NULL) SWIG_fail;
4444 temp1 = true;
4445 }
4446 }
4447 {
4448 PyThreadState* __tstate = wxPyBeginAllowThreads();
4449 result = wxGetUserHome((wxString const &)*arg1);
4450
4451 wxPyEndAllowThreads(__tstate);
4452 if (PyErr_Occurred()) SWIG_fail;
4453 }
4454 {
4455 #if wxUSE_UNICODE
4456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4457 #else
4458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4459 #endif
4460 }
4461 {
4462 if (temp1)
4463 delete arg1;
4464 }
4465 return resultobj;
4466 fail:
4467 {
4468 if (temp1)
4469 delete arg1;
4470 }
4471 return NULL;
4472 }
4473
4474
4475 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4476 PyObject *resultobj;
4477 unsigned long result;
4478 char *kwnames[] = {
4479 NULL
4480 };
4481
4482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4483 {
4484 PyThreadState* __tstate = wxPyBeginAllowThreads();
4485 result = (unsigned long)wxGetProcessId();
4486
4487 wxPyEndAllowThreads(__tstate);
4488 if (PyErr_Occurred()) SWIG_fail;
4489 }
4490 {
4491 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4492 }
4493 return resultobj;
4494 fail:
4495 return NULL;
4496 }
4497
4498
4499 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4500 PyObject *resultobj;
4501 char *kwnames[] = {
4502 NULL
4503 };
4504
4505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4506 {
4507 PyThreadState* __tstate = wxPyBeginAllowThreads();
4508 wxTrap();
4509
4510 wxPyEndAllowThreads(__tstate);
4511 if (PyErr_Occurred()) SWIG_fail;
4512 }
4513 Py_INCREF(Py_None); resultobj = Py_None;
4514 return resultobj;
4515 fail:
4516 return NULL;
4517 }
4518
4519
4520 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4521 PyObject *resultobj;
4522 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4523 wxString *arg1 = (wxString *) &arg1_defvalue ;
4524 wxString const &arg2_defvalue = wxPyEmptyString ;
4525 wxString *arg2 = (wxString *) &arg2_defvalue ;
4526 wxString const &arg3_defvalue = wxPyEmptyString ;
4527 wxString *arg3 = (wxString *) &arg3_defvalue ;
4528 wxString const &arg4_defvalue = wxPyEmptyString ;
4529 wxString *arg4 = (wxString *) &arg4_defvalue ;
4530 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4531 wxString *arg5 = (wxString *) &arg5_defvalue ;
4532 int arg6 = (int) 0 ;
4533 wxWindow *arg7 = (wxWindow *) NULL ;
4534 int arg8 = (int) -1 ;
4535 int arg9 = (int) -1 ;
4536 wxString result;
4537 bool temp1 = false ;
4538 bool temp2 = false ;
4539 bool temp3 = false ;
4540 bool temp4 = false ;
4541 bool temp5 = false ;
4542 PyObject * obj0 = 0 ;
4543 PyObject * obj1 = 0 ;
4544 PyObject * obj2 = 0 ;
4545 PyObject * obj3 = 0 ;
4546 PyObject * obj4 = 0 ;
4547 PyObject * obj5 = 0 ;
4548 PyObject * obj6 = 0 ;
4549 PyObject * obj7 = 0 ;
4550 PyObject * obj8 = 0 ;
4551 char *kwnames[] = {
4552 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4553 };
4554
4555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4556 if (obj0) {
4557 {
4558 arg1 = wxString_in_helper(obj0);
4559 if (arg1 == NULL) SWIG_fail;
4560 temp1 = true;
4561 }
4562 }
4563 if (obj1) {
4564 {
4565 arg2 = wxString_in_helper(obj1);
4566 if (arg2 == NULL) SWIG_fail;
4567 temp2 = true;
4568 }
4569 }
4570 if (obj2) {
4571 {
4572 arg3 = wxString_in_helper(obj2);
4573 if (arg3 == NULL) SWIG_fail;
4574 temp3 = true;
4575 }
4576 }
4577 if (obj3) {
4578 {
4579 arg4 = wxString_in_helper(obj3);
4580 if (arg4 == NULL) SWIG_fail;
4581 temp4 = true;
4582 }
4583 }
4584 if (obj4) {
4585 {
4586 arg5 = wxString_in_helper(obj4);
4587 if (arg5 == NULL) SWIG_fail;
4588 temp5 = true;
4589 }
4590 }
4591 if (obj5) {
4592 {
4593 arg6 = (int)(SWIG_As_int(obj5));
4594 if (SWIG_arg_fail(6)) SWIG_fail;
4595 }
4596 }
4597 if (obj6) {
4598 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4599 if (SWIG_arg_fail(7)) SWIG_fail;
4600 }
4601 if (obj7) {
4602 {
4603 arg8 = (int)(SWIG_As_int(obj7));
4604 if (SWIG_arg_fail(8)) SWIG_fail;
4605 }
4606 }
4607 if (obj8) {
4608 {
4609 arg9 = (int)(SWIG_As_int(obj8));
4610 if (SWIG_arg_fail(9)) SWIG_fail;
4611 }
4612 }
4613 {
4614 if (!wxPyCheckForApp()) SWIG_fail;
4615 PyThreadState* __tstate = wxPyBeginAllowThreads();
4616 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4617
4618 wxPyEndAllowThreads(__tstate);
4619 if (PyErr_Occurred()) SWIG_fail;
4620 }
4621 {
4622 #if wxUSE_UNICODE
4623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4624 #else
4625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4626 #endif
4627 }
4628 {
4629 if (temp1)
4630 delete arg1;
4631 }
4632 {
4633 if (temp2)
4634 delete arg2;
4635 }
4636 {
4637 if (temp3)
4638 delete arg3;
4639 }
4640 {
4641 if (temp4)
4642 delete arg4;
4643 }
4644 {
4645 if (temp5)
4646 delete arg5;
4647 }
4648 return resultobj;
4649 fail:
4650 {
4651 if (temp1)
4652 delete arg1;
4653 }
4654 {
4655 if (temp2)
4656 delete arg2;
4657 }
4658 {
4659 if (temp3)
4660 delete arg3;
4661 }
4662 {
4663 if (temp4)
4664 delete arg4;
4665 }
4666 {
4667 if (temp5)
4668 delete arg5;
4669 }
4670 return NULL;
4671 }
4672
4673
4674 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj;
4676 wxString *arg1 = 0 ;
4677 wxString *arg2 = 0 ;
4678 wxString const &arg3_defvalue = wxPyEmptyString ;
4679 wxString *arg3 = (wxString *) &arg3_defvalue ;
4680 wxWindow *arg4 = (wxWindow *) NULL ;
4681 wxString result;
4682 bool temp1 = false ;
4683 bool temp2 = false ;
4684 bool temp3 = false ;
4685 PyObject * obj0 = 0 ;
4686 PyObject * obj1 = 0 ;
4687 PyObject * obj2 = 0 ;
4688 PyObject * obj3 = 0 ;
4689 char *kwnames[] = {
4690 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4691 };
4692
4693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4694 {
4695 arg1 = wxString_in_helper(obj0);
4696 if (arg1 == NULL) SWIG_fail;
4697 temp1 = true;
4698 }
4699 {
4700 arg2 = wxString_in_helper(obj1);
4701 if (arg2 == NULL) SWIG_fail;
4702 temp2 = true;
4703 }
4704 if (obj2) {
4705 {
4706 arg3 = wxString_in_helper(obj2);
4707 if (arg3 == NULL) SWIG_fail;
4708 temp3 = true;
4709 }
4710 }
4711 if (obj3) {
4712 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4713 if (SWIG_arg_fail(4)) SWIG_fail;
4714 }
4715 {
4716 if (!wxPyCheckForApp()) SWIG_fail;
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4719
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 {
4724 #if wxUSE_UNICODE
4725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4726 #else
4727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4728 #endif
4729 }
4730 {
4731 if (temp1)
4732 delete arg1;
4733 }
4734 {
4735 if (temp2)
4736 delete arg2;
4737 }
4738 {
4739 if (temp3)
4740 delete arg3;
4741 }
4742 return resultobj;
4743 fail:
4744 {
4745 if (temp1)
4746 delete arg1;
4747 }
4748 {
4749 if (temp2)
4750 delete arg2;
4751 }
4752 {
4753 if (temp3)
4754 delete arg3;
4755 }
4756 return NULL;
4757 }
4758
4759
4760 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj;
4762 wxString *arg1 = 0 ;
4763 wxString *arg2 = 0 ;
4764 wxString const &arg3_defvalue = wxPyEmptyString ;
4765 wxString *arg3 = (wxString *) &arg3_defvalue ;
4766 wxWindow *arg4 = (wxWindow *) NULL ;
4767 wxString result;
4768 bool temp1 = false ;
4769 bool temp2 = false ;
4770 bool temp3 = false ;
4771 PyObject * obj0 = 0 ;
4772 PyObject * obj1 = 0 ;
4773 PyObject * obj2 = 0 ;
4774 PyObject * obj3 = 0 ;
4775 char *kwnames[] = {
4776 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4777 };
4778
4779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4780 {
4781 arg1 = wxString_in_helper(obj0);
4782 if (arg1 == NULL) SWIG_fail;
4783 temp1 = true;
4784 }
4785 {
4786 arg2 = wxString_in_helper(obj1);
4787 if (arg2 == NULL) SWIG_fail;
4788 temp2 = true;
4789 }
4790 if (obj2) {
4791 {
4792 arg3 = wxString_in_helper(obj2);
4793 if (arg3 == NULL) SWIG_fail;
4794 temp3 = true;
4795 }
4796 }
4797 if (obj3) {
4798 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4799 if (SWIG_arg_fail(4)) SWIG_fail;
4800 }
4801 {
4802 if (!wxPyCheckForApp()) SWIG_fail;
4803 PyThreadState* __tstate = wxPyBeginAllowThreads();
4804 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4805
4806 wxPyEndAllowThreads(__tstate);
4807 if (PyErr_Occurred()) SWIG_fail;
4808 }
4809 {
4810 #if wxUSE_UNICODE
4811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4812 #else
4813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4814 #endif
4815 }
4816 {
4817 if (temp1)
4818 delete arg1;
4819 }
4820 {
4821 if (temp2)
4822 delete arg2;
4823 }
4824 {
4825 if (temp3)
4826 delete arg3;
4827 }
4828 return resultobj;
4829 fail:
4830 {
4831 if (temp1)
4832 delete arg1;
4833 }
4834 {
4835 if (temp2)
4836 delete arg2;
4837 }
4838 {
4839 if (temp3)
4840 delete arg3;
4841 }
4842 return NULL;
4843 }
4844
4845
4846 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4847 PyObject *resultobj;
4848 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4849 wxString *arg1 = (wxString *) &arg1_defvalue ;
4850 wxString const &arg2_defvalue = wxPyEmptyString ;
4851 wxString *arg2 = (wxString *) &arg2_defvalue ;
4852 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4853 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4854 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4855 wxWindow *arg5 = (wxWindow *) NULL ;
4856 wxString result;
4857 bool temp1 = false ;
4858 bool temp2 = false ;
4859 wxPoint temp4 ;
4860 PyObject * obj0 = 0 ;
4861 PyObject * obj1 = 0 ;
4862 PyObject * obj2 = 0 ;
4863 PyObject * obj3 = 0 ;
4864 PyObject * obj4 = 0 ;
4865 char *kwnames[] = {
4866 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4867 };
4868
4869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4870 if (obj0) {
4871 {
4872 arg1 = wxString_in_helper(obj0);
4873 if (arg1 == NULL) SWIG_fail;
4874 temp1 = true;
4875 }
4876 }
4877 if (obj1) {
4878 {
4879 arg2 = wxString_in_helper(obj1);
4880 if (arg2 == NULL) SWIG_fail;
4881 temp2 = true;
4882 }
4883 }
4884 if (obj2) {
4885 {
4886 arg3 = (long)(SWIG_As_long(obj2));
4887 if (SWIG_arg_fail(3)) SWIG_fail;
4888 }
4889 }
4890 if (obj3) {
4891 {
4892 arg4 = &temp4;
4893 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4894 }
4895 }
4896 if (obj4) {
4897 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4898 if (SWIG_arg_fail(5)) SWIG_fail;
4899 }
4900 {
4901 if (!wxPyCheckForApp()) SWIG_fail;
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4904
4905 wxPyEndAllowThreads(__tstate);
4906 if (PyErr_Occurred()) SWIG_fail;
4907 }
4908 {
4909 #if wxUSE_UNICODE
4910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4911 #else
4912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4913 #endif
4914 }
4915 {
4916 if (temp1)
4917 delete arg1;
4918 }
4919 {
4920 if (temp2)
4921 delete arg2;
4922 }
4923 return resultobj;
4924 fail:
4925 {
4926 if (temp1)
4927 delete arg1;
4928 }
4929 {
4930 if (temp2)
4931 delete arg2;
4932 }
4933 return NULL;
4934 }
4935
4936
4937 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4938 PyObject *resultobj;
4939 wxString *arg1 = 0 ;
4940 wxString const &arg2_defvalue = wxPyEmptyString ;
4941 wxString *arg2 = (wxString *) &arg2_defvalue ;
4942 wxString const &arg3_defvalue = wxPyEmptyString ;
4943 wxString *arg3 = (wxString *) &arg3_defvalue ;
4944 wxWindow *arg4 = (wxWindow *) NULL ;
4945 int arg5 = (int) -1 ;
4946 int arg6 = (int) -1 ;
4947 bool arg7 = (bool) true ;
4948 wxString result;
4949 bool temp1 = false ;
4950 bool temp2 = false ;
4951 bool temp3 = false ;
4952 PyObject * obj0 = 0 ;
4953 PyObject * obj1 = 0 ;
4954 PyObject * obj2 = 0 ;
4955 PyObject * obj3 = 0 ;
4956 PyObject * obj4 = 0 ;
4957 PyObject * obj5 = 0 ;
4958 PyObject * obj6 = 0 ;
4959 char *kwnames[] = {
4960 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4961 };
4962
4963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4964 {
4965 arg1 = wxString_in_helper(obj0);
4966 if (arg1 == NULL) SWIG_fail;
4967 temp1 = true;
4968 }
4969 if (obj1) {
4970 {
4971 arg2 = wxString_in_helper(obj1);
4972 if (arg2 == NULL) SWIG_fail;
4973 temp2 = true;
4974 }
4975 }
4976 if (obj2) {
4977 {
4978 arg3 = wxString_in_helper(obj2);
4979 if (arg3 == NULL) SWIG_fail;
4980 temp3 = true;
4981 }
4982 }
4983 if (obj3) {
4984 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4985 if (SWIG_arg_fail(4)) SWIG_fail;
4986 }
4987 if (obj4) {
4988 {
4989 arg5 = (int)(SWIG_As_int(obj4));
4990 if (SWIG_arg_fail(5)) SWIG_fail;
4991 }
4992 }
4993 if (obj5) {
4994 {
4995 arg6 = (int)(SWIG_As_int(obj5));
4996 if (SWIG_arg_fail(6)) SWIG_fail;
4997 }
4998 }
4999 if (obj6) {
5000 {
5001 arg7 = (bool)(SWIG_As_bool(obj6));
5002 if (SWIG_arg_fail(7)) SWIG_fail;
5003 }
5004 }
5005 {
5006 if (!wxPyCheckForApp()) SWIG_fail;
5007 PyThreadState* __tstate = wxPyBeginAllowThreads();
5008 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5009
5010 wxPyEndAllowThreads(__tstate);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 {
5014 #if wxUSE_UNICODE
5015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5016 #else
5017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5018 #endif
5019 }
5020 {
5021 if (temp1)
5022 delete arg1;
5023 }
5024 {
5025 if (temp2)
5026 delete arg2;
5027 }
5028 {
5029 if (temp3)
5030 delete arg3;
5031 }
5032 return resultobj;
5033 fail:
5034 {
5035 if (temp1)
5036 delete arg1;
5037 }
5038 {
5039 if (temp2)
5040 delete arg2;
5041 }
5042 {
5043 if (temp3)
5044 delete arg3;
5045 }
5046 return NULL;
5047 }
5048
5049
5050 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5051 PyObject *resultobj;
5052 wxString *arg1 = 0 ;
5053 wxString const &arg2_defvalue = wxPyEmptyString ;
5054 wxString *arg2 = (wxString *) &arg2_defvalue ;
5055 wxString const &arg3_defvalue = wxPyEmptyString ;
5056 wxString *arg3 = (wxString *) &arg3_defvalue ;
5057 wxWindow *arg4 = (wxWindow *) NULL ;
5058 wxString result;
5059 bool temp1 = false ;
5060 bool temp2 = false ;
5061 bool temp3 = false ;
5062 PyObject * obj0 = 0 ;
5063 PyObject * obj1 = 0 ;
5064 PyObject * obj2 = 0 ;
5065 PyObject * obj3 = 0 ;
5066 char *kwnames[] = {
5067 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5068 };
5069
5070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5071 {
5072 arg1 = wxString_in_helper(obj0);
5073 if (arg1 == NULL) SWIG_fail;
5074 temp1 = true;
5075 }
5076 if (obj1) {
5077 {
5078 arg2 = wxString_in_helper(obj1);
5079 if (arg2 == NULL) SWIG_fail;
5080 temp2 = true;
5081 }
5082 }
5083 if (obj2) {
5084 {
5085 arg3 = wxString_in_helper(obj2);
5086 if (arg3 == NULL) SWIG_fail;
5087 temp3 = true;
5088 }
5089 }
5090 if (obj3) {
5091 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5092 if (SWIG_arg_fail(4)) SWIG_fail;
5093 }
5094 {
5095 if (!wxPyCheckForApp()) SWIG_fail;
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5098
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 {
5103 #if wxUSE_UNICODE
5104 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5105 #else
5106 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5107 #endif
5108 }
5109 {
5110 if (temp1)
5111 delete arg1;
5112 }
5113 {
5114 if (temp2)
5115 delete arg2;
5116 }
5117 {
5118 if (temp3)
5119 delete arg3;
5120 }
5121 return resultobj;
5122 fail:
5123 {
5124 if (temp1)
5125 delete arg1;
5126 }
5127 {
5128 if (temp2)
5129 delete arg2;
5130 }
5131 {
5132 if (temp3)
5133 delete arg3;
5134 }
5135 return NULL;
5136 }
5137
5138
5139 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5140 PyObject *resultobj;
5141 wxString *arg1 = 0 ;
5142 wxString *arg2 = 0 ;
5143 int arg3 ;
5144 wxString *arg4 = (wxString *) 0 ;
5145 wxWindow *arg5 = (wxWindow *) NULL ;
5146 int arg6 = (int) -1 ;
5147 int arg7 = (int) -1 ;
5148 bool arg8 = (bool) true ;
5149 int arg9 = (int) 150 ;
5150 int arg10 = (int) 200 ;
5151 wxString result;
5152 bool temp1 = false ;
5153 bool temp2 = false ;
5154 PyObject * obj0 = 0 ;
5155 PyObject * obj1 = 0 ;
5156 PyObject * obj2 = 0 ;
5157 PyObject * obj3 = 0 ;
5158 PyObject * obj4 = 0 ;
5159 PyObject * obj5 = 0 ;
5160 PyObject * obj6 = 0 ;
5161 PyObject * obj7 = 0 ;
5162 PyObject * obj8 = 0 ;
5163 char *kwnames[] = {
5164 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5165 };
5166
5167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5168 {
5169 arg1 = wxString_in_helper(obj0);
5170 if (arg1 == NULL) SWIG_fail;
5171 temp1 = true;
5172 }
5173 {
5174 arg2 = wxString_in_helper(obj1);
5175 if (arg2 == NULL) SWIG_fail;
5176 temp2 = true;
5177 }
5178 {
5179 arg3 = PyList_Size(obj2);
5180 arg4 = wxString_LIST_helper(obj2);
5181 if (arg4 == NULL) SWIG_fail;
5182 }
5183 if (obj3) {
5184 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5185 if (SWIG_arg_fail(5)) SWIG_fail;
5186 }
5187 if (obj4) {
5188 {
5189 arg6 = (int)(SWIG_As_int(obj4));
5190 if (SWIG_arg_fail(6)) SWIG_fail;
5191 }
5192 }
5193 if (obj5) {
5194 {
5195 arg7 = (int)(SWIG_As_int(obj5));
5196 if (SWIG_arg_fail(7)) SWIG_fail;
5197 }
5198 }
5199 if (obj6) {
5200 {
5201 arg8 = (bool)(SWIG_As_bool(obj6));
5202 if (SWIG_arg_fail(8)) SWIG_fail;
5203 }
5204 }
5205 if (obj7) {
5206 {
5207 arg9 = (int)(SWIG_As_int(obj7));
5208 if (SWIG_arg_fail(9)) SWIG_fail;
5209 }
5210 }
5211 if (obj8) {
5212 {
5213 arg10 = (int)(SWIG_As_int(obj8));
5214 if (SWIG_arg_fail(10)) SWIG_fail;
5215 }
5216 }
5217 {
5218 if (!wxPyCheckForApp()) SWIG_fail;
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5221
5222 wxPyEndAllowThreads(__tstate);
5223 if (PyErr_Occurred()) SWIG_fail;
5224 }
5225 {
5226 #if wxUSE_UNICODE
5227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5228 #else
5229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5230 #endif
5231 }
5232 {
5233 if (temp1)
5234 delete arg1;
5235 }
5236 {
5237 if (temp2)
5238 delete arg2;
5239 }
5240 {
5241 if (arg4) delete [] arg4;
5242 }
5243 return resultobj;
5244 fail:
5245 {
5246 if (temp1)
5247 delete arg1;
5248 }
5249 {
5250 if (temp2)
5251 delete arg2;
5252 }
5253 {
5254 if (arg4) delete [] arg4;
5255 }
5256 return NULL;
5257 }
5258
5259
5260 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5261 PyObject *resultobj;
5262 wxString *arg1 = 0 ;
5263 wxString *arg2 = 0 ;
5264 int arg3 ;
5265 wxString *arg4 = (wxString *) 0 ;
5266 wxWindow *arg5 = (wxWindow *) NULL ;
5267 int arg6 = (int) -1 ;
5268 int arg7 = (int) -1 ;
5269 bool arg8 = (bool) true ;
5270 int arg9 = (int) 150 ;
5271 int arg10 = (int) 200 ;
5272 int result;
5273 bool temp1 = false ;
5274 bool temp2 = false ;
5275 PyObject * obj0 = 0 ;
5276 PyObject * obj1 = 0 ;
5277 PyObject * obj2 = 0 ;
5278 PyObject * obj3 = 0 ;
5279 PyObject * obj4 = 0 ;
5280 PyObject * obj5 = 0 ;
5281 PyObject * obj6 = 0 ;
5282 PyObject * obj7 = 0 ;
5283 PyObject * obj8 = 0 ;
5284 char *kwnames[] = {
5285 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5286 };
5287
5288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5289 {
5290 arg1 = wxString_in_helper(obj0);
5291 if (arg1 == NULL) SWIG_fail;
5292 temp1 = true;
5293 }
5294 {
5295 arg2 = wxString_in_helper(obj1);
5296 if (arg2 == NULL) SWIG_fail;
5297 temp2 = true;
5298 }
5299 {
5300 arg3 = PyList_Size(obj2);
5301 arg4 = wxString_LIST_helper(obj2);
5302 if (arg4 == NULL) SWIG_fail;
5303 }
5304 if (obj3) {
5305 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5306 if (SWIG_arg_fail(5)) SWIG_fail;
5307 }
5308 if (obj4) {
5309 {
5310 arg6 = (int)(SWIG_As_int(obj4));
5311 if (SWIG_arg_fail(6)) SWIG_fail;
5312 }
5313 }
5314 if (obj5) {
5315 {
5316 arg7 = (int)(SWIG_As_int(obj5));
5317 if (SWIG_arg_fail(7)) SWIG_fail;
5318 }
5319 }
5320 if (obj6) {
5321 {
5322 arg8 = (bool)(SWIG_As_bool(obj6));
5323 if (SWIG_arg_fail(8)) SWIG_fail;
5324 }
5325 }
5326 if (obj7) {
5327 {
5328 arg9 = (int)(SWIG_As_int(obj7));
5329 if (SWIG_arg_fail(9)) SWIG_fail;
5330 }
5331 }
5332 if (obj8) {
5333 {
5334 arg10 = (int)(SWIG_As_int(obj8));
5335 if (SWIG_arg_fail(10)) SWIG_fail;
5336 }
5337 }
5338 {
5339 if (!wxPyCheckForApp()) SWIG_fail;
5340 PyThreadState* __tstate = wxPyBeginAllowThreads();
5341 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5342
5343 wxPyEndAllowThreads(__tstate);
5344 if (PyErr_Occurred()) SWIG_fail;
5345 }
5346 {
5347 resultobj = SWIG_From_int((int)(result));
5348 }
5349 {
5350 if (temp1)
5351 delete arg1;
5352 }
5353 {
5354 if (temp2)
5355 delete arg2;
5356 }
5357 {
5358 if (arg4) delete [] arg4;
5359 }
5360 return resultobj;
5361 fail:
5362 {
5363 if (temp1)
5364 delete arg1;
5365 }
5366 {
5367 if (temp2)
5368 delete arg2;
5369 }
5370 {
5371 if (arg4) delete [] arg4;
5372 }
5373 return NULL;
5374 }
5375
5376
5377 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5378 PyObject *resultobj;
5379 wxString *arg1 = 0 ;
5380 wxString const &arg2_defvalue = wxPyEmptyString ;
5381 wxString *arg2 = (wxString *) &arg2_defvalue ;
5382 int arg3 = (int) wxOK|wxCENTRE ;
5383 wxWindow *arg4 = (wxWindow *) NULL ;
5384 int arg5 = (int) -1 ;
5385 int arg6 = (int) -1 ;
5386 int result;
5387 bool temp1 = false ;
5388 bool temp2 = false ;
5389 PyObject * obj0 = 0 ;
5390 PyObject * obj1 = 0 ;
5391 PyObject * obj2 = 0 ;
5392 PyObject * obj3 = 0 ;
5393 PyObject * obj4 = 0 ;
5394 PyObject * obj5 = 0 ;
5395 char *kwnames[] = {
5396 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5397 };
5398
5399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5400 {
5401 arg1 = wxString_in_helper(obj0);
5402 if (arg1 == NULL) SWIG_fail;
5403 temp1 = true;
5404 }
5405 if (obj1) {
5406 {
5407 arg2 = wxString_in_helper(obj1);
5408 if (arg2 == NULL) SWIG_fail;
5409 temp2 = true;
5410 }
5411 }
5412 if (obj2) {
5413 {
5414 arg3 = (int)(SWIG_As_int(obj2));
5415 if (SWIG_arg_fail(3)) SWIG_fail;
5416 }
5417 }
5418 if (obj3) {
5419 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5420 if (SWIG_arg_fail(4)) SWIG_fail;
5421 }
5422 if (obj4) {
5423 {
5424 arg5 = (int)(SWIG_As_int(obj4));
5425 if (SWIG_arg_fail(5)) SWIG_fail;
5426 }
5427 }
5428 if (obj5) {
5429 {
5430 arg6 = (int)(SWIG_As_int(obj5));
5431 if (SWIG_arg_fail(6)) SWIG_fail;
5432 }
5433 }
5434 {
5435 if (!wxPyCheckForApp()) SWIG_fail;
5436 PyThreadState* __tstate = wxPyBeginAllowThreads();
5437 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5438
5439 wxPyEndAllowThreads(__tstate);
5440 if (PyErr_Occurred()) SWIG_fail;
5441 }
5442 {
5443 resultobj = SWIG_From_int((int)(result));
5444 }
5445 {
5446 if (temp1)
5447 delete arg1;
5448 }
5449 {
5450 if (temp2)
5451 delete arg2;
5452 }
5453 return resultobj;
5454 fail:
5455 {
5456 if (temp1)
5457 delete arg1;
5458 }
5459 {
5460 if (temp2)
5461 delete arg2;
5462 }
5463 return NULL;
5464 }
5465
5466
5467 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5468 PyObject *resultobj;
5469 bool result;
5470 char *kwnames[] = {
5471 NULL
5472 };
5473
5474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5475 {
5476 if (!wxPyCheckForApp()) SWIG_fail;
5477 PyThreadState* __tstate = wxPyBeginAllowThreads();
5478 result = (bool)wxColourDisplay();
5479
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 {
5484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5485 }
5486 return resultobj;
5487 fail:
5488 return NULL;
5489 }
5490
5491
5492 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5493 PyObject *resultobj;
5494 int result;
5495 char *kwnames[] = {
5496 NULL
5497 };
5498
5499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5500 {
5501 if (!wxPyCheckForApp()) SWIG_fail;
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = (int)wxDisplayDepth();
5504
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 {
5509 resultobj = SWIG_From_int((int)(result));
5510 }
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj;
5519 int result;
5520 char *kwnames[] = {
5521 NULL
5522 };
5523
5524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5525 {
5526 if (!wxPyCheckForApp()) SWIG_fail;
5527 PyThreadState* __tstate = wxPyBeginAllowThreads();
5528 result = (int)wxGetDisplayDepth();
5529
5530 wxPyEndAllowThreads(__tstate);
5531 if (PyErr_Occurred()) SWIG_fail;
5532 }
5533 {
5534 resultobj = SWIG_From_int((int)(result));
5535 }
5536 return resultobj;
5537 fail:
5538 return NULL;
5539 }
5540
5541
5542 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5543 PyObject *resultobj;
5544 int *arg1 = (int *) 0 ;
5545 int *arg2 = (int *) 0 ;
5546 int temp1 ;
5547 int res1 = 0 ;
5548 int temp2 ;
5549 int res2 = 0 ;
5550 char *kwnames[] = {
5551 NULL
5552 };
5553
5554 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5555 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5557 {
5558 if (!wxPyCheckForApp()) SWIG_fail;
5559 PyThreadState* __tstate = wxPyBeginAllowThreads();
5560 wxDisplaySize(arg1,arg2);
5561
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 Py_INCREF(Py_None); resultobj = Py_None;
5566 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5567 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5568 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5569 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5570 return resultobj;
5571 fail:
5572 return NULL;
5573 }
5574
5575
5576 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5577 PyObject *resultobj;
5578 wxSize result;
5579 char *kwnames[] = {
5580 NULL
5581 };
5582
5583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5584 {
5585 if (!wxPyCheckForApp()) SWIG_fail;
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 result = wxGetDisplaySize();
5588
5589 wxPyEndAllowThreads(__tstate);
5590 if (PyErr_Occurred()) SWIG_fail;
5591 }
5592 {
5593 wxSize * resultptr;
5594 resultptr = new wxSize((wxSize &)(result));
5595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5596 }
5597 return resultobj;
5598 fail:
5599 return NULL;
5600 }
5601
5602
5603 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5604 PyObject *resultobj;
5605 int *arg1 = (int *) 0 ;
5606 int *arg2 = (int *) 0 ;
5607 int temp1 ;
5608 int res1 = 0 ;
5609 int temp2 ;
5610 int res2 = 0 ;
5611 char *kwnames[] = {
5612 NULL
5613 };
5614
5615 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5616 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5618 {
5619 if (!wxPyCheckForApp()) SWIG_fail;
5620 PyThreadState* __tstate = wxPyBeginAllowThreads();
5621 wxDisplaySizeMM(arg1,arg2);
5622
5623 wxPyEndAllowThreads(__tstate);
5624 if (PyErr_Occurred()) SWIG_fail;
5625 }
5626 Py_INCREF(Py_None); resultobj = Py_None;
5627 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5628 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5629 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5630 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5638 PyObject *resultobj;
5639 wxSize result;
5640 char *kwnames[] = {
5641 NULL
5642 };
5643
5644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5645 {
5646 if (!wxPyCheckForApp()) SWIG_fail;
5647 PyThreadState* __tstate = wxPyBeginAllowThreads();
5648 result = wxGetDisplaySizeMM();
5649
5650 wxPyEndAllowThreads(__tstate);
5651 if (PyErr_Occurred()) SWIG_fail;
5652 }
5653 {
5654 wxSize * resultptr;
5655 resultptr = new wxSize((wxSize &)(result));
5656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5657 }
5658 return resultobj;
5659 fail:
5660 return NULL;
5661 }
5662
5663
5664 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5665 PyObject *resultobj;
5666 int *arg1 = (int *) 0 ;
5667 int *arg2 = (int *) 0 ;
5668 int *arg3 = (int *) 0 ;
5669 int *arg4 = (int *) 0 ;
5670 int temp1 ;
5671 int res1 = 0 ;
5672 int temp2 ;
5673 int res2 = 0 ;
5674 int temp3 ;
5675 int res3 = 0 ;
5676 int temp4 ;
5677 int res4 = 0 ;
5678 char *kwnames[] = {
5679 NULL
5680 };
5681
5682 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5683 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5684 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5685 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5687 {
5688 if (!wxPyCheckForApp()) SWIG_fail;
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 Py_INCREF(Py_None); resultobj = Py_None;
5696 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5697 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5698 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5699 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5700 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5701 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5702 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5703 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj;
5712 wxRect result;
5713 char *kwnames[] = {
5714 NULL
5715 };
5716
5717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5718 {
5719 if (!wxPyCheckForApp()) SWIG_fail;
5720 PyThreadState* __tstate = wxPyBeginAllowThreads();
5721 result = wxGetClientDisplayRect();
5722
5723 wxPyEndAllowThreads(__tstate);
5724 if (PyErr_Occurred()) SWIG_fail;
5725 }
5726 {
5727 wxRect * resultptr;
5728 resultptr = new wxRect((wxRect &)(result));
5729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5730 }
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5738 PyObject *resultobj;
5739 wxCursor *arg1 = 0 ;
5740 PyObject * obj0 = 0 ;
5741 char *kwnames[] = {
5742 (char *) "cursor", NULL
5743 };
5744
5745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5746 {
5747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5748 if (SWIG_arg_fail(1)) SWIG_fail;
5749 if (arg1 == NULL) {
5750 SWIG_null_ref("wxCursor");
5751 }
5752 if (SWIG_arg_fail(1)) SWIG_fail;
5753 }
5754 {
5755 if (!wxPyCheckForApp()) SWIG_fail;
5756 PyThreadState* __tstate = wxPyBeginAllowThreads();
5757 wxSetCursor(*arg1);
5758
5759 wxPyEndAllowThreads(__tstate);
5760 if (PyErr_Occurred()) SWIG_fail;
5761 }
5762 Py_INCREF(Py_None); resultobj = Py_None;
5763 return resultobj;
5764 fail:
5765 return NULL;
5766 }
5767
5768
5769 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5770 PyObject *resultobj;
5771 void *result;
5772 char *kwnames[] = {
5773 NULL
5774 };
5775
5776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5777 {
5778 if (!wxPyCheckForApp()) SWIG_fail;
5779 PyThreadState* __tstate = wxPyBeginAllowThreads();
5780 result = (void *)wxGetXDisplay();
5781
5782 wxPyEndAllowThreads(__tstate);
5783 if (PyErr_Occurred()) SWIG_fail;
5784 }
5785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5793 PyObject *resultobj;
5794 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5795 PyObject * obj0 = 0 ;
5796 char *kwnames[] = {
5797 (char *) "cursor", NULL
5798 };
5799
5800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5801 if (obj0) {
5802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5803 if (SWIG_arg_fail(1)) SWIG_fail;
5804 }
5805 {
5806 if (!wxPyCheckForApp()) SWIG_fail;
5807 PyThreadState* __tstate = wxPyBeginAllowThreads();
5808 wxBeginBusyCursor(arg1);
5809
5810 wxPyEndAllowThreads(__tstate);
5811 if (PyErr_Occurred()) SWIG_fail;
5812 }
5813 Py_INCREF(Py_None); resultobj = Py_None;
5814 return resultobj;
5815 fail:
5816 return NULL;
5817 }
5818
5819
5820 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5821 PyObject *resultobj;
5822 wxWindow *result;
5823 char *kwnames[] = {
5824 NULL
5825 };
5826
5827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5828 {
5829 if (!wxPyCheckForApp()) SWIG_fail;
5830 PyThreadState* __tstate = wxPyBeginAllowThreads();
5831 result = (wxWindow *)wxGetActiveWindow();
5832
5833 wxPyEndAllowThreads(__tstate);
5834 if (PyErr_Occurred()) SWIG_fail;
5835 }
5836 {
5837 resultobj = wxPyMake_wxObject(result, 0);
5838 }
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj;
5847 wxPoint *arg1 = 0 ;
5848 wxWindow *result;
5849 wxPoint temp1 ;
5850 PyObject * obj0 = 0 ;
5851 char *kwnames[] = {
5852 (char *) "pt", NULL
5853 };
5854
5855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5856 {
5857 arg1 = &temp1;
5858 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5859 }
5860 {
5861 if (!wxPyCheckForApp()) SWIG_fail;
5862 PyThreadState* __tstate = wxPyBeginAllowThreads();
5863 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5864
5865 wxPyEndAllowThreads(__tstate);
5866 if (PyErr_Occurred()) SWIG_fail;
5867 }
5868 {
5869 resultobj = wxPyMake_wxObject(result, 0);
5870 }
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj;
5879 wxPoint *arg1 = 0 ;
5880 wxWindow *result;
5881 wxPoint temp1 ;
5882 PyObject * obj0 = 0 ;
5883 char *kwnames[] = {
5884 (char *) "pt", NULL
5885 };
5886
5887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5888 {
5889 arg1 = &temp1;
5890 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5891 }
5892 {
5893 if (!wxPyCheckForApp()) SWIG_fail;
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5896
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 {
5901 resultobj = wxPyMake_wxObject(result, 0);
5902 }
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj;
5911 wxWindow *arg1 = (wxWindow *) 0 ;
5912 wxWindow *result;
5913 PyObject * obj0 = 0 ;
5914 char *kwnames[] = {
5915 (char *) "win", NULL
5916 };
5917
5918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5920 if (SWIG_arg_fail(1)) SWIG_fail;
5921 {
5922 if (!wxPyCheckForApp()) SWIG_fail;
5923 PyThreadState* __tstate = wxPyBeginAllowThreads();
5924 result = (wxWindow *)wxGetTopLevelParent(arg1);
5925
5926 wxPyEndAllowThreads(__tstate);
5927 if (PyErr_Occurred()) SWIG_fail;
5928 }
5929 {
5930 resultobj = wxPyMake_wxObject(result, 0);
5931 }
5932 return resultobj;
5933 fail:
5934 return NULL;
5935 }
5936
5937
5938 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
5939 PyObject *resultobj;
5940 wxString *arg1 = 0 ;
5941 bool result;
5942 bool temp1 = false ;
5943 PyObject * obj0 = 0 ;
5944 char *kwnames[] = {
5945 (char *) "url", NULL
5946 };
5947
5948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
5949 {
5950 arg1 = wxString_in_helper(obj0);
5951 if (arg1 == NULL) SWIG_fail;
5952 temp1 = true;
5953 }
5954 {
5955 PyThreadState* __tstate = wxPyBeginAllowThreads();
5956 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
5957
5958 wxPyEndAllowThreads(__tstate);
5959 if (PyErr_Occurred()) SWIG_fail;
5960 }
5961 {
5962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5963 }
5964 {
5965 if (temp1)
5966 delete arg1;
5967 }
5968 return resultobj;
5969 fail:
5970 {
5971 if (temp1)
5972 delete arg1;
5973 }
5974 return NULL;
5975 }
5976
5977
5978 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5979 PyObject *resultobj;
5980 wxKeyCode arg1 ;
5981 bool result;
5982 PyObject * obj0 = 0 ;
5983 char *kwnames[] = {
5984 (char *) "key", NULL
5985 };
5986
5987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5988 {
5989 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5990 if (SWIG_arg_fail(1)) SWIG_fail;
5991 }
5992 {
5993 if (!wxPyCheckForApp()) SWIG_fail;
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5996
5997 wxPyEndAllowThreads(__tstate);
5998 if (PyErr_Occurred()) SWIG_fail;
5999 }
6000 {
6001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6002 }
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj;
6011 char *kwnames[] = {
6012 NULL
6013 };
6014
6015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6016 {
6017 if (!wxPyCheckForApp()) SWIG_fail;
6018 PyThreadState* __tstate = wxPyBeginAllowThreads();
6019 wxWakeUpMainThread();
6020
6021 wxPyEndAllowThreads(__tstate);
6022 if (PyErr_Occurred()) SWIG_fail;
6023 }
6024 Py_INCREF(Py_None); resultobj = Py_None;
6025 return resultobj;
6026 fail:
6027 return NULL;
6028 }
6029
6030
6031 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6032 PyObject *resultobj;
6033 char *kwnames[] = {
6034 NULL
6035 };
6036
6037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6038 {
6039 if (!wxPyCheckForApp()) SWIG_fail;
6040 PyThreadState* __tstate = wxPyBeginAllowThreads();
6041 wxMutexGuiEnter();
6042
6043 wxPyEndAllowThreads(__tstate);
6044 if (PyErr_Occurred()) SWIG_fail;
6045 }
6046 Py_INCREF(Py_None); resultobj = Py_None;
6047 return resultobj;
6048 fail:
6049 return NULL;
6050 }
6051
6052
6053 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6054 PyObject *resultobj;
6055 char *kwnames[] = {
6056 NULL
6057 };
6058
6059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6060 {
6061 if (!wxPyCheckForApp()) SWIG_fail;
6062 PyThreadState* __tstate = wxPyBeginAllowThreads();
6063 wxMutexGuiLeave();
6064
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 Py_INCREF(Py_None); resultobj = Py_None;
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj;
6077 wxMutexGuiLocker *result;
6078 char *kwnames[] = {
6079 NULL
6080 };
6081
6082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6083 {
6084 if (!wxPyCheckForApp()) SWIG_fail;
6085 PyThreadState* __tstate = wxPyBeginAllowThreads();
6086 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6087
6088 wxPyEndAllowThreads(__tstate);
6089 if (PyErr_Occurred()) SWIG_fail;
6090 }
6091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6092 return resultobj;
6093 fail:
6094 return NULL;
6095 }
6096
6097
6098 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6099 PyObject *resultobj;
6100 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6101 PyObject * obj0 = 0 ;
6102 char *kwnames[] = {
6103 (char *) "self", NULL
6104 };
6105
6106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6108 if (SWIG_arg_fail(1)) SWIG_fail;
6109 {
6110 PyThreadState* __tstate = wxPyBeginAllowThreads();
6111 delete arg1;
6112
6113 wxPyEndAllowThreads(__tstate);
6114 if (PyErr_Occurred()) SWIG_fail;
6115 }
6116 Py_INCREF(Py_None); resultobj = Py_None;
6117 return resultobj;
6118 fail:
6119 return NULL;
6120 }
6121
6122
6123 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6124 PyObject *obj;
6125 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6126 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6127 Py_INCREF(obj);
6128 return Py_BuildValue((char *)"");
6129 }
6130 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj;
6132 bool result;
6133 char *kwnames[] = {
6134 NULL
6135 };
6136
6137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = (bool)wxThread_IsMain();
6141
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 {
6146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6147 }
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6155 PyObject *resultobj;
6156 wxString *arg1 = 0 ;
6157 wxToolTip *result;
6158 bool temp1 = false ;
6159 PyObject * obj0 = 0 ;
6160 char *kwnames[] = {
6161 (char *) "tip", NULL
6162 };
6163
6164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6165 {
6166 arg1 = wxString_in_helper(obj0);
6167 if (arg1 == NULL) SWIG_fail;
6168 temp1 = true;
6169 }
6170 {
6171 if (!wxPyCheckForApp()) SWIG_fail;
6172 PyThreadState* __tstate = wxPyBeginAllowThreads();
6173 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6174
6175 wxPyEndAllowThreads(__tstate);
6176 if (PyErr_Occurred()) SWIG_fail;
6177 }
6178 {
6179 resultobj = wxPyMake_wxObject(result, 1);
6180 }
6181 {
6182 if (temp1)
6183 delete arg1;
6184 }
6185 return resultobj;
6186 fail:
6187 {
6188 if (temp1)
6189 delete arg1;
6190 }
6191 return NULL;
6192 }
6193
6194
6195 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6196 PyObject *resultobj;
6197 wxToolTip *arg1 = (wxToolTip *) 0 ;
6198 wxString *arg2 = 0 ;
6199 bool temp2 = false ;
6200 PyObject * obj0 = 0 ;
6201 PyObject * obj1 = 0 ;
6202 char *kwnames[] = {
6203 (char *) "self",(char *) "tip", NULL
6204 };
6205
6206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6208 if (SWIG_arg_fail(1)) SWIG_fail;
6209 {
6210 arg2 = wxString_in_helper(obj1);
6211 if (arg2 == NULL) SWIG_fail;
6212 temp2 = true;
6213 }
6214 {
6215 PyThreadState* __tstate = wxPyBeginAllowThreads();
6216 (arg1)->SetTip((wxString const &)*arg2);
6217
6218 wxPyEndAllowThreads(__tstate);
6219 if (PyErr_Occurred()) SWIG_fail;
6220 }
6221 Py_INCREF(Py_None); resultobj = Py_None;
6222 {
6223 if (temp2)
6224 delete arg2;
6225 }
6226 return resultobj;
6227 fail:
6228 {
6229 if (temp2)
6230 delete arg2;
6231 }
6232 return NULL;
6233 }
6234
6235
6236 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6237 PyObject *resultobj;
6238 wxToolTip *arg1 = (wxToolTip *) 0 ;
6239 wxString result;
6240 PyObject * obj0 = 0 ;
6241 char *kwnames[] = {
6242 (char *) "self", NULL
6243 };
6244
6245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6247 if (SWIG_arg_fail(1)) SWIG_fail;
6248 {
6249 PyThreadState* __tstate = wxPyBeginAllowThreads();
6250 result = (arg1)->GetTip();
6251
6252 wxPyEndAllowThreads(__tstate);
6253 if (PyErr_Occurred()) SWIG_fail;
6254 }
6255 {
6256 #if wxUSE_UNICODE
6257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6258 #else
6259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6260 #endif
6261 }
6262 return resultobj;
6263 fail:
6264 return NULL;
6265 }
6266
6267
6268 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6269 PyObject *resultobj;
6270 wxToolTip *arg1 = (wxToolTip *) 0 ;
6271 wxWindow *result;
6272 PyObject * obj0 = 0 ;
6273 char *kwnames[] = {
6274 (char *) "self", NULL
6275 };
6276
6277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6279 if (SWIG_arg_fail(1)) SWIG_fail;
6280 {
6281 PyThreadState* __tstate = wxPyBeginAllowThreads();
6282 result = (wxWindow *)(arg1)->GetWindow();
6283
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 {
6288 resultobj = wxPyMake_wxObject(result, 0);
6289 }
6290 return resultobj;
6291 fail:
6292 return NULL;
6293 }
6294
6295
6296 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6297 PyObject *resultobj;
6298 bool arg1 ;
6299 PyObject * obj0 = 0 ;
6300 char *kwnames[] = {
6301 (char *) "flag", NULL
6302 };
6303
6304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6305 {
6306 arg1 = (bool)(SWIG_As_bool(obj0));
6307 if (SWIG_arg_fail(1)) SWIG_fail;
6308 }
6309 {
6310 PyThreadState* __tstate = wxPyBeginAllowThreads();
6311 wxToolTip::Enable(arg1);
6312
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 Py_INCREF(Py_None); resultobj = Py_None;
6317 return resultobj;
6318 fail:
6319 return NULL;
6320 }
6321
6322
6323 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6324 PyObject *resultobj;
6325 long arg1 ;
6326 PyObject * obj0 = 0 ;
6327 char *kwnames[] = {
6328 (char *) "milliseconds", NULL
6329 };
6330
6331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6332 {
6333 arg1 = (long)(SWIG_As_long(obj0));
6334 if (SWIG_arg_fail(1)) SWIG_fail;
6335 }
6336 {
6337 PyThreadState* __tstate = wxPyBeginAllowThreads();
6338 wxToolTip::SetDelay(arg1);
6339
6340 wxPyEndAllowThreads(__tstate);
6341 if (PyErr_Occurred()) SWIG_fail;
6342 }
6343 Py_INCREF(Py_None); resultobj = Py_None;
6344 return resultobj;
6345 fail:
6346 return NULL;
6347 }
6348
6349
6350 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6351 PyObject *obj;
6352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6353 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6354 Py_INCREF(obj);
6355 return Py_BuildValue((char *)"");
6356 }
6357 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj;
6359 wxWindow *arg1 = (wxWindow *) 0 ;
6360 wxSize *arg2 = 0 ;
6361 wxCaret *result;
6362 wxSize temp2 ;
6363 PyObject * obj0 = 0 ;
6364 PyObject * obj1 = 0 ;
6365 char *kwnames[] = {
6366 (char *) "window",(char *) "size", NULL
6367 };
6368
6369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6371 if (SWIG_arg_fail(1)) SWIG_fail;
6372 {
6373 arg2 = &temp2;
6374 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6375 }
6376 {
6377 if (!wxPyCheckForApp()) SWIG_fail;
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6380
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6392 PyObject *resultobj;
6393 wxCaret *arg1 = (wxCaret *) 0 ;
6394 PyObject * obj0 = 0 ;
6395 char *kwnames[] = {
6396 (char *) "self", NULL
6397 };
6398
6399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6401 if (SWIG_arg_fail(1)) SWIG_fail;
6402 {
6403 PyThreadState* __tstate = wxPyBeginAllowThreads();
6404 wxCaret_Destroy(arg1);
6405
6406 wxPyEndAllowThreads(__tstate);
6407 if (PyErr_Occurred()) SWIG_fail;
6408 }
6409 Py_INCREF(Py_None); resultobj = Py_None;
6410 return resultobj;
6411 fail:
6412 return NULL;
6413 }
6414
6415
6416 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6417 PyObject *resultobj;
6418 wxCaret *arg1 = (wxCaret *) 0 ;
6419 bool result;
6420 PyObject * obj0 = 0 ;
6421 char *kwnames[] = {
6422 (char *) "self", NULL
6423 };
6424
6425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6427 if (SWIG_arg_fail(1)) SWIG_fail;
6428 {
6429 PyThreadState* __tstate = wxPyBeginAllowThreads();
6430 result = (bool)(arg1)->IsOk();
6431
6432 wxPyEndAllowThreads(__tstate);
6433 if (PyErr_Occurred()) SWIG_fail;
6434 }
6435 {
6436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6437 }
6438 return resultobj;
6439 fail:
6440 return NULL;
6441 }
6442
6443
6444 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6445 PyObject *resultobj;
6446 wxCaret *arg1 = (wxCaret *) 0 ;
6447 bool result;
6448 PyObject * obj0 = 0 ;
6449 char *kwnames[] = {
6450 (char *) "self", NULL
6451 };
6452
6453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6455 if (SWIG_arg_fail(1)) SWIG_fail;
6456 {
6457 PyThreadState* __tstate = wxPyBeginAllowThreads();
6458 result = (bool)(arg1)->IsVisible();
6459
6460 wxPyEndAllowThreads(__tstate);
6461 if (PyErr_Occurred()) SWIG_fail;
6462 }
6463 {
6464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6465 }
6466 return resultobj;
6467 fail:
6468 return NULL;
6469 }
6470
6471
6472 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj;
6474 wxCaret *arg1 = (wxCaret *) 0 ;
6475 wxPoint result;
6476 PyObject * obj0 = 0 ;
6477 char *kwnames[] = {
6478 (char *) "self", NULL
6479 };
6480
6481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6483 if (SWIG_arg_fail(1)) SWIG_fail;
6484 {
6485 PyThreadState* __tstate = wxPyBeginAllowThreads();
6486 result = (arg1)->GetPosition();
6487
6488 wxPyEndAllowThreads(__tstate);
6489 if (PyErr_Occurred()) SWIG_fail;
6490 }
6491 {
6492 wxPoint * resultptr;
6493 resultptr = new wxPoint((wxPoint &)(result));
6494 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6495 }
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj;
6504 wxCaret *arg1 = (wxCaret *) 0 ;
6505 int *arg2 = (int *) 0 ;
6506 int *arg3 = (int *) 0 ;
6507 int temp2 ;
6508 int res2 = 0 ;
6509 int temp3 ;
6510 int res3 = 0 ;
6511 PyObject * obj0 = 0 ;
6512 char *kwnames[] = {
6513 (char *) "self", NULL
6514 };
6515
6516 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6517 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6520 if (SWIG_arg_fail(1)) SWIG_fail;
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 (arg1)->GetPosition(arg2,arg3);
6524
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 Py_INCREF(Py_None); resultobj = Py_None;
6529 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6530 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6531 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6532 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6533 return resultobj;
6534 fail:
6535 return NULL;
6536 }
6537
6538
6539 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6540 PyObject *resultobj;
6541 wxCaret *arg1 = (wxCaret *) 0 ;
6542 wxSize result;
6543 PyObject * obj0 = 0 ;
6544 char *kwnames[] = {
6545 (char *) "self", NULL
6546 };
6547
6548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6550 if (SWIG_arg_fail(1)) SWIG_fail;
6551 {
6552 PyThreadState* __tstate = wxPyBeginAllowThreads();
6553 result = (arg1)->GetSize();
6554
6555 wxPyEndAllowThreads(__tstate);
6556 if (PyErr_Occurred()) SWIG_fail;
6557 }
6558 {
6559 wxSize * resultptr;
6560 resultptr = new wxSize((wxSize &)(result));
6561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6562 }
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj;
6571 wxCaret *arg1 = (wxCaret *) 0 ;
6572 int *arg2 = (int *) 0 ;
6573 int *arg3 = (int *) 0 ;
6574 int temp2 ;
6575 int res2 = 0 ;
6576 int temp3 ;
6577 int res3 = 0 ;
6578 PyObject * obj0 = 0 ;
6579 char *kwnames[] = {
6580 (char *) "self", NULL
6581 };
6582
6583 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6584 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6587 if (SWIG_arg_fail(1)) SWIG_fail;
6588 {
6589 PyThreadState* __tstate = wxPyBeginAllowThreads();
6590 (arg1)->GetSize(arg2,arg3);
6591
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 Py_INCREF(Py_None); resultobj = Py_None;
6596 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6597 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6598 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6599 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6607 PyObject *resultobj;
6608 wxCaret *arg1 = (wxCaret *) 0 ;
6609 wxWindow *result;
6610 PyObject * obj0 = 0 ;
6611 char *kwnames[] = {
6612 (char *) "self", NULL
6613 };
6614
6615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6617 if (SWIG_arg_fail(1)) SWIG_fail;
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 result = (wxWindow *)(arg1)->GetWindow();
6621
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 {
6626 resultobj = wxPyMake_wxObject(result, 0);
6627 }
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj;
6636 wxCaret *arg1 = (wxCaret *) 0 ;
6637 int arg2 ;
6638 int arg3 ;
6639 PyObject * obj0 = 0 ;
6640 PyObject * obj1 = 0 ;
6641 PyObject * obj2 = 0 ;
6642 char *kwnames[] = {
6643 (char *) "self",(char *) "x",(char *) "y", NULL
6644 };
6645
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 {
6650 arg2 = (int)(SWIG_As_int(obj1));
6651 if (SWIG_arg_fail(2)) SWIG_fail;
6652 }
6653 {
6654 arg3 = (int)(SWIG_As_int(obj2));
6655 if (SWIG_arg_fail(3)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->Move(arg2,arg3);
6660
6661 wxPyEndAllowThreads(__tstate);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 Py_INCREF(Py_None); resultobj = Py_None;
6665 return resultobj;
6666 fail:
6667 return NULL;
6668 }
6669
6670
6671 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6672 PyObject *resultobj;
6673 wxCaret *arg1 = (wxCaret *) 0 ;
6674 wxPoint *arg2 = 0 ;
6675 wxPoint temp2 ;
6676 PyObject * obj0 = 0 ;
6677 PyObject * obj1 = 0 ;
6678 char *kwnames[] = {
6679 (char *) "self",(char *) "pt", NULL
6680 };
6681
6682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6684 if (SWIG_arg_fail(1)) SWIG_fail;
6685 {
6686 arg2 = &temp2;
6687 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6688 }
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 (arg1)->Move((wxPoint const &)*arg2);
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 Py_INCREF(Py_None); resultobj = Py_None;
6697 return resultobj;
6698 fail:
6699 return NULL;
6700 }
6701
6702
6703 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6704 PyObject *resultobj;
6705 wxCaret *arg1 = (wxCaret *) 0 ;
6706 int arg2 ;
6707 int arg3 ;
6708 PyObject * obj0 = 0 ;
6709 PyObject * obj1 = 0 ;
6710 PyObject * obj2 = 0 ;
6711 char *kwnames[] = {
6712 (char *) "self",(char *) "width",(char *) "height", NULL
6713 };
6714
6715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6717 if (SWIG_arg_fail(1)) SWIG_fail;
6718 {
6719 arg2 = (int)(SWIG_As_int(obj1));
6720 if (SWIG_arg_fail(2)) SWIG_fail;
6721 }
6722 {
6723 arg3 = (int)(SWIG_As_int(obj2));
6724 if (SWIG_arg_fail(3)) SWIG_fail;
6725 }
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 (arg1)->SetSize(arg2,arg3);
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 Py_INCREF(Py_None); resultobj = Py_None;
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6741 PyObject *resultobj;
6742 wxCaret *arg1 = (wxCaret *) 0 ;
6743 wxSize *arg2 = 0 ;
6744 wxSize temp2 ;
6745 PyObject * obj0 = 0 ;
6746 PyObject * obj1 = 0 ;
6747 char *kwnames[] = {
6748 (char *) "self",(char *) "size", NULL
6749 };
6750
6751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6753 if (SWIG_arg_fail(1)) SWIG_fail;
6754 {
6755 arg2 = &temp2;
6756 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6757 }
6758 {
6759 PyThreadState* __tstate = wxPyBeginAllowThreads();
6760 (arg1)->SetSize((wxSize const &)*arg2);
6761
6762 wxPyEndAllowThreads(__tstate);
6763 if (PyErr_Occurred()) SWIG_fail;
6764 }
6765 Py_INCREF(Py_None); resultobj = Py_None;
6766 return resultobj;
6767 fail:
6768 return NULL;
6769 }
6770
6771
6772 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6773 PyObject *resultobj;
6774 wxCaret *arg1 = (wxCaret *) 0 ;
6775 int arg2 = (int) true ;
6776 PyObject * obj0 = 0 ;
6777 PyObject * obj1 = 0 ;
6778 char *kwnames[] = {
6779 (char *) "self",(char *) "show", NULL
6780 };
6781
6782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6784 if (SWIG_arg_fail(1)) SWIG_fail;
6785 if (obj1) {
6786 {
6787 arg2 = (int)(SWIG_As_int(obj1));
6788 if (SWIG_arg_fail(2)) SWIG_fail;
6789 }
6790 }
6791 {
6792 PyThreadState* __tstate = wxPyBeginAllowThreads();
6793 (arg1)->Show(arg2);
6794
6795 wxPyEndAllowThreads(__tstate);
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 Py_INCREF(Py_None); resultobj = Py_None;
6799 return resultobj;
6800 fail:
6801 return NULL;
6802 }
6803
6804
6805 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6806 PyObject *resultobj;
6807 wxCaret *arg1 = (wxCaret *) 0 ;
6808 PyObject * obj0 = 0 ;
6809 char *kwnames[] = {
6810 (char *) "self", NULL
6811 };
6812
6813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6815 if (SWIG_arg_fail(1)) SWIG_fail;
6816 {
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 (arg1)->Hide();
6819
6820 wxPyEndAllowThreads(__tstate);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 Py_INCREF(Py_None); resultobj = Py_None;
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6831 PyObject *resultobj;
6832 int result;
6833 char *kwnames[] = {
6834 NULL
6835 };
6836
6837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6838 {
6839 PyThreadState* __tstate = wxPyBeginAllowThreads();
6840 result = (int)wxCaret::GetBlinkTime();
6841
6842 wxPyEndAllowThreads(__tstate);
6843 if (PyErr_Occurred()) SWIG_fail;
6844 }
6845 {
6846 resultobj = SWIG_From_int((int)(result));
6847 }
6848 return resultobj;
6849 fail:
6850 return NULL;
6851 }
6852
6853
6854 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6855 PyObject *resultobj;
6856 int arg1 ;
6857 PyObject * obj0 = 0 ;
6858 char *kwnames[] = {
6859 (char *) "milliseconds", NULL
6860 };
6861
6862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6863 {
6864 arg1 = (int)(SWIG_As_int(obj0));
6865 if (SWIG_arg_fail(1)) SWIG_fail;
6866 }
6867 {
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 wxCaret::SetBlinkTime(arg1);
6870
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 Py_INCREF(Py_None); resultobj = Py_None;
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6882 PyObject *obj;
6883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6884 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6885 Py_INCREF(obj);
6886 return Py_BuildValue((char *)"");
6887 }
6888 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6889 PyObject *resultobj;
6890 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6891 wxBusyCursor *result;
6892 PyObject * obj0 = 0 ;
6893 char *kwnames[] = {
6894 (char *) "cursor", NULL
6895 };
6896
6897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6898 if (obj0) {
6899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6900 if (SWIG_arg_fail(1)) SWIG_fail;
6901 }
6902 {
6903 if (!wxPyCheckForApp()) SWIG_fail;
6904 PyThreadState* __tstate = wxPyBeginAllowThreads();
6905 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6906
6907 wxPyEndAllowThreads(__tstate);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6918 PyObject *resultobj;
6919 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6920 PyObject * obj0 = 0 ;
6921 char *kwnames[] = {
6922 (char *) "self", NULL
6923 };
6924
6925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6927 if (SWIG_arg_fail(1)) SWIG_fail;
6928 {
6929 PyThreadState* __tstate = wxPyBeginAllowThreads();
6930 delete arg1;
6931
6932 wxPyEndAllowThreads(__tstate);
6933 if (PyErr_Occurred()) SWIG_fail;
6934 }
6935 Py_INCREF(Py_None); resultobj = Py_None;
6936 return resultobj;
6937 fail:
6938 return NULL;
6939 }
6940
6941
6942 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6943 PyObject *obj;
6944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6945 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6946 Py_INCREF(obj);
6947 return Py_BuildValue((char *)"");
6948 }
6949 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6950 PyObject *resultobj;
6951 wxWindow *arg1 = (wxWindow *) NULL ;
6952 wxWindowDisabler *result;
6953 PyObject * obj0 = 0 ;
6954 char *kwnames[] = {
6955 (char *) "winToSkip", NULL
6956 };
6957
6958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6959 if (obj0) {
6960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6961 if (SWIG_arg_fail(1)) SWIG_fail;
6962 }
6963 {
6964 if (!wxPyCheckForApp()) SWIG_fail;
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6967
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj;
6980 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6981 PyObject * obj0 = 0 ;
6982 char *kwnames[] = {
6983 (char *) "self", NULL
6984 };
6985
6986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6988 if (SWIG_arg_fail(1)) SWIG_fail;
6989 {
6990 PyThreadState* __tstate = wxPyBeginAllowThreads();
6991 delete arg1;
6992
6993 wxPyEndAllowThreads(__tstate);
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 Py_INCREF(Py_None); resultobj = Py_None;
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7004 PyObject *obj;
7005 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7006 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7007 Py_INCREF(obj);
7008 return Py_BuildValue((char *)"");
7009 }
7010 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7011 PyObject *resultobj;
7012 wxString *arg1 = 0 ;
7013 wxBusyInfo *result;
7014 bool temp1 = false ;
7015 PyObject * obj0 = 0 ;
7016 char *kwnames[] = {
7017 (char *) "message", NULL
7018 };
7019
7020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7021 {
7022 arg1 = wxString_in_helper(obj0);
7023 if (arg1 == NULL) SWIG_fail;
7024 temp1 = true;
7025 }
7026 {
7027 if (!wxPyCheckForApp()) SWIG_fail;
7028 PyThreadState* __tstate = wxPyBeginAllowThreads();
7029 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7030
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7035 {
7036 if (temp1)
7037 delete arg1;
7038 }
7039 return resultobj;
7040 fail:
7041 {
7042 if (temp1)
7043 delete arg1;
7044 }
7045 return NULL;
7046 }
7047
7048
7049 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7050 PyObject *resultobj;
7051 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7052 PyObject * obj0 = 0 ;
7053 char *kwnames[] = {
7054 (char *) "self", NULL
7055 };
7056
7057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7059 if (SWIG_arg_fail(1)) SWIG_fail;
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 delete arg1;
7063
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 Py_INCREF(Py_None); resultobj = Py_None;
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7075 PyObject *obj;
7076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7077 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7078 Py_INCREF(obj);
7079 return Py_BuildValue((char *)"");
7080 }
7081 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7082 PyObject *resultobj;
7083 wxStopWatch *result;
7084 char *kwnames[] = {
7085 NULL
7086 };
7087
7088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7089 {
7090 PyThreadState* __tstate = wxPyBeginAllowThreads();
7091 result = (wxStopWatch *)new wxStopWatch();
7092
7093 wxPyEndAllowThreads(__tstate);
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7097 return resultobj;
7098 fail:
7099 return NULL;
7100 }
7101
7102
7103 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7104 PyObject *resultobj;
7105 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7106 long arg2 = (long) 0 ;
7107 PyObject * obj0 = 0 ;
7108 PyObject * obj1 = 0 ;
7109 char *kwnames[] = {
7110 (char *) "self",(char *) "t0", NULL
7111 };
7112
7113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7115 if (SWIG_arg_fail(1)) SWIG_fail;
7116 if (obj1) {
7117 {
7118 arg2 = (long)(SWIG_As_long(obj1));
7119 if (SWIG_arg_fail(2)) SWIG_fail;
7120 }
7121 }
7122 {
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 (arg1)->Start(arg2);
7125
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 Py_INCREF(Py_None); resultobj = Py_None;
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7137 PyObject *resultobj;
7138 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7139 PyObject * obj0 = 0 ;
7140 char *kwnames[] = {
7141 (char *) "self", NULL
7142 };
7143
7144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7146 if (SWIG_arg_fail(1)) SWIG_fail;
7147 {
7148 PyThreadState* __tstate = wxPyBeginAllowThreads();
7149 (arg1)->Pause();
7150
7151 wxPyEndAllowThreads(__tstate);
7152 if (PyErr_Occurred()) SWIG_fail;
7153 }
7154 Py_INCREF(Py_None); resultobj = Py_None;
7155 return resultobj;
7156 fail:
7157 return NULL;
7158 }
7159
7160
7161 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7162 PyObject *resultobj;
7163 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7164 PyObject * obj0 = 0 ;
7165 char *kwnames[] = {
7166 (char *) "self", NULL
7167 };
7168
7169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7171 if (SWIG_arg_fail(1)) SWIG_fail;
7172 {
7173 PyThreadState* __tstate = wxPyBeginAllowThreads();
7174 (arg1)->Resume();
7175
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 Py_INCREF(Py_None); resultobj = Py_None;
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj;
7188 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7189 long result;
7190 PyObject * obj0 = 0 ;
7191 char *kwnames[] = {
7192 (char *) "self", NULL
7193 };
7194
7195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7197 if (SWIG_arg_fail(1)) SWIG_fail;
7198 {
7199 PyThreadState* __tstate = wxPyBeginAllowThreads();
7200 result = (long)((wxStopWatch const *)arg1)->Time();
7201
7202 wxPyEndAllowThreads(__tstate);
7203 if (PyErr_Occurred()) SWIG_fail;
7204 }
7205 {
7206 resultobj = SWIG_From_long((long)(result));
7207 }
7208 return resultobj;
7209 fail:
7210 return NULL;
7211 }
7212
7213
7214 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7215 PyObject *obj;
7216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7217 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7218 Py_INCREF(obj);
7219 return Py_BuildValue((char *)"");
7220 }
7221 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj;
7223 int arg1 = (int) 9 ;
7224 int arg2 = (int) wxID_FILE1 ;
7225 wxFileHistory *result;
7226 PyObject * obj0 = 0 ;
7227 PyObject * obj1 = 0 ;
7228 char *kwnames[] = {
7229 (char *) "maxFiles",(char *) "idBase", NULL
7230 };
7231
7232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7233 if (obj0) {
7234 {
7235 arg1 = (int)(SWIG_As_int(obj0));
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 }
7238 }
7239 if (obj1) {
7240 {
7241 arg2 = (int)(SWIG_As_int(obj1));
7242 if (SWIG_arg_fail(2)) SWIG_fail;
7243 }
7244 }
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7248
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj;
7261 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7262 PyObject * obj0 = 0 ;
7263 char *kwnames[] = {
7264 (char *) "self", NULL
7265 };
7266
7267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7269 if (SWIG_arg_fail(1)) SWIG_fail;
7270 {
7271 PyThreadState* __tstate = wxPyBeginAllowThreads();
7272 delete arg1;
7273
7274 wxPyEndAllowThreads(__tstate);
7275 if (PyErr_Occurred()) SWIG_fail;
7276 }
7277 Py_INCREF(Py_None); resultobj = Py_None;
7278 return resultobj;
7279 fail:
7280 return NULL;
7281 }
7282
7283
7284 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7285 PyObject *resultobj;
7286 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7287 wxString *arg2 = 0 ;
7288 bool temp2 = false ;
7289 PyObject * obj0 = 0 ;
7290 PyObject * obj1 = 0 ;
7291 char *kwnames[] = {
7292 (char *) "self",(char *) "file", NULL
7293 };
7294
7295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7297 if (SWIG_arg_fail(1)) SWIG_fail;
7298 {
7299 arg2 = wxString_in_helper(obj1);
7300 if (arg2 == NULL) SWIG_fail;
7301 temp2 = true;
7302 }
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 (arg1)->AddFileToHistory((wxString const &)*arg2);
7306
7307 wxPyEndAllowThreads(__tstate);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 Py_INCREF(Py_None); resultobj = Py_None;
7311 {
7312 if (temp2)
7313 delete arg2;
7314 }
7315 return resultobj;
7316 fail:
7317 {
7318 if (temp2)
7319 delete arg2;
7320 }
7321 return NULL;
7322 }
7323
7324
7325 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7326 PyObject *resultobj;
7327 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7328 int arg2 ;
7329 PyObject * obj0 = 0 ;
7330 PyObject * obj1 = 0 ;
7331 char *kwnames[] = {
7332 (char *) "self",(char *) "i", NULL
7333 };
7334
7335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7337 if (SWIG_arg_fail(1)) SWIG_fail;
7338 {
7339 arg2 = (int)(SWIG_As_int(obj1));
7340 if (SWIG_arg_fail(2)) SWIG_fail;
7341 }
7342 {
7343 PyThreadState* __tstate = wxPyBeginAllowThreads();
7344 (arg1)->RemoveFileFromHistory(arg2);
7345
7346 wxPyEndAllowThreads(__tstate);
7347 if (PyErr_Occurred()) SWIG_fail;
7348 }
7349 Py_INCREF(Py_None); resultobj = Py_None;
7350 return resultobj;
7351 fail:
7352 return NULL;
7353 }
7354
7355
7356 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7357 PyObject *resultobj;
7358 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7359 int result;
7360 PyObject * obj0 = 0 ;
7361 char *kwnames[] = {
7362 (char *) "self", NULL
7363 };
7364
7365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7367 if (SWIG_arg_fail(1)) SWIG_fail;
7368 {
7369 PyThreadState* __tstate = wxPyBeginAllowThreads();
7370 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7371
7372 wxPyEndAllowThreads(__tstate);
7373 if (PyErr_Occurred()) SWIG_fail;
7374 }
7375 {
7376 resultobj = SWIG_From_int((int)(result));
7377 }
7378 return resultobj;
7379 fail:
7380 return NULL;
7381 }
7382
7383
7384 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7385 PyObject *resultobj;
7386 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7387 wxMenu *arg2 = (wxMenu *) 0 ;
7388 PyObject * obj0 = 0 ;
7389 PyObject * obj1 = 0 ;
7390 char *kwnames[] = {
7391 (char *) "self",(char *) "menu", NULL
7392 };
7393
7394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7396 if (SWIG_arg_fail(1)) SWIG_fail;
7397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7398 if (SWIG_arg_fail(2)) SWIG_fail;
7399 {
7400 PyThreadState* __tstate = wxPyBeginAllowThreads();
7401 (arg1)->UseMenu(arg2);
7402
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 Py_INCREF(Py_None); resultobj = Py_None;
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj;
7415 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7416 wxMenu *arg2 = (wxMenu *) 0 ;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 char *kwnames[] = {
7420 (char *) "self",(char *) "menu", NULL
7421 };
7422
7423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7425 if (SWIG_arg_fail(1)) SWIG_fail;
7426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7427 if (SWIG_arg_fail(2)) SWIG_fail;
7428 {
7429 PyThreadState* __tstate = wxPyBeginAllowThreads();
7430 (arg1)->RemoveMenu(arg2);
7431
7432 wxPyEndAllowThreads(__tstate);
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 Py_INCREF(Py_None); resultobj = Py_None;
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7443 PyObject *resultobj;
7444 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7445 wxConfigBase *arg2 = 0 ;
7446 PyObject * obj0 = 0 ;
7447 PyObject * obj1 = 0 ;
7448 char *kwnames[] = {
7449 (char *) "self",(char *) "config", NULL
7450 };
7451
7452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7454 if (SWIG_arg_fail(1)) SWIG_fail;
7455 {
7456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7457 if (SWIG_arg_fail(2)) SWIG_fail;
7458 if (arg2 == NULL) {
7459 SWIG_null_ref("wxConfigBase");
7460 }
7461 if (SWIG_arg_fail(2)) SWIG_fail;
7462 }
7463 {
7464 PyThreadState* __tstate = wxPyBeginAllowThreads();
7465 (arg1)->Load(*arg2);
7466
7467 wxPyEndAllowThreads(__tstate);
7468 if (PyErr_Occurred()) SWIG_fail;
7469 }
7470 Py_INCREF(Py_None); resultobj = Py_None;
7471 return resultobj;
7472 fail:
7473 return NULL;
7474 }
7475
7476
7477 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7478 PyObject *resultobj;
7479 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7480 wxConfigBase *arg2 = 0 ;
7481 PyObject * obj0 = 0 ;
7482 PyObject * obj1 = 0 ;
7483 char *kwnames[] = {
7484 (char *) "self",(char *) "config", NULL
7485 };
7486
7487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7489 if (SWIG_arg_fail(1)) SWIG_fail;
7490 {
7491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7492 if (SWIG_arg_fail(2)) SWIG_fail;
7493 if (arg2 == NULL) {
7494 SWIG_null_ref("wxConfigBase");
7495 }
7496 if (SWIG_arg_fail(2)) SWIG_fail;
7497 }
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 (arg1)->Save(*arg2);
7501
7502 wxPyEndAllowThreads(__tstate);
7503 if (PyErr_Occurred()) SWIG_fail;
7504 }
7505 Py_INCREF(Py_None); resultobj = Py_None;
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj;
7514 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7515 PyObject * obj0 = 0 ;
7516 char *kwnames[] = {
7517 (char *) "self", NULL
7518 };
7519
7520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7522 if (SWIG_arg_fail(1)) SWIG_fail;
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 (arg1)->AddFilesToMenu();
7526
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 Py_INCREF(Py_None); resultobj = Py_None;
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj;
7539 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7540 wxMenu *arg2 = (wxMenu *) 0 ;
7541 PyObject * obj0 = 0 ;
7542 PyObject * obj1 = 0 ;
7543 char *kwnames[] = {
7544 (char *) "self",(char *) "menu", NULL
7545 };
7546
7547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7549 if (SWIG_arg_fail(1)) SWIG_fail;
7550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7551 if (SWIG_arg_fail(2)) SWIG_fail;
7552 {
7553 PyThreadState* __tstate = wxPyBeginAllowThreads();
7554 (arg1)->AddFilesToMenu(arg2);
7555
7556 wxPyEndAllowThreads(__tstate);
7557 if (PyErr_Occurred()) SWIG_fail;
7558 }
7559 Py_INCREF(Py_None); resultobj = Py_None;
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7567 PyObject *resultobj;
7568 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7569 int arg2 ;
7570 wxString result;
7571 PyObject * obj0 = 0 ;
7572 PyObject * obj1 = 0 ;
7573 char *kwnames[] = {
7574 (char *) "self",(char *) "i", NULL
7575 };
7576
7577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7579 if (SWIG_arg_fail(1)) SWIG_fail;
7580 {
7581 arg2 = (int)(SWIG_As_int(obj1));
7582 if (SWIG_arg_fail(2)) SWIG_fail;
7583 }
7584 {
7585 PyThreadState* __tstate = wxPyBeginAllowThreads();
7586 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7587
7588 wxPyEndAllowThreads(__tstate);
7589 if (PyErr_Occurred()) SWIG_fail;
7590 }
7591 {
7592 #if wxUSE_UNICODE
7593 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7594 #else
7595 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7596 #endif
7597 }
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7605 PyObject *resultobj;
7606 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7607 int result;
7608 PyObject * obj0 = 0 ;
7609 char *kwnames[] = {
7610 (char *) "self", NULL
7611 };
7612
7613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7615 if (SWIG_arg_fail(1)) SWIG_fail;
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 result = (int)((wxFileHistory const *)arg1)->GetCount();
7619
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 {
7624 resultobj = SWIG_From_int((int)(result));
7625 }
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7633 PyObject *obj;
7634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7635 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7636 Py_INCREF(obj);
7637 return Py_BuildValue((char *)"");
7638 }
7639 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7640 PyObject *resultobj;
7641 wxString *arg1 = 0 ;
7642 wxString const &arg2_defvalue = wxPyEmptyString ;
7643 wxString *arg2 = (wxString *) &arg2_defvalue ;
7644 wxSingleInstanceChecker *result;
7645 bool temp1 = false ;
7646 bool temp2 = false ;
7647 PyObject * obj0 = 0 ;
7648 PyObject * obj1 = 0 ;
7649 char *kwnames[] = {
7650 (char *) "name",(char *) "path", NULL
7651 };
7652
7653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7654 {
7655 arg1 = wxString_in_helper(obj0);
7656 if (arg1 == NULL) SWIG_fail;
7657 temp1 = true;
7658 }
7659 if (obj1) {
7660 {
7661 arg2 = wxString_in_helper(obj1);
7662 if (arg2 == NULL) SWIG_fail;
7663 temp2 = true;
7664 }
7665 }
7666 {
7667 PyThreadState* __tstate = wxPyBeginAllowThreads();
7668 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7669
7670 wxPyEndAllowThreads(__tstate);
7671 if (PyErr_Occurred()) SWIG_fail;
7672 }
7673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7674 {
7675 if (temp1)
7676 delete arg1;
7677 }
7678 {
7679 if (temp2)
7680 delete arg2;
7681 }
7682 return resultobj;
7683 fail:
7684 {
7685 if (temp1)
7686 delete arg1;
7687 }
7688 {
7689 if (temp2)
7690 delete arg2;
7691 }
7692 return NULL;
7693 }
7694
7695
7696 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7697 PyObject *resultobj;
7698 wxSingleInstanceChecker *result;
7699 char *kwnames[] = {
7700 NULL
7701 };
7702
7703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7704 {
7705 PyThreadState* __tstate = wxPyBeginAllowThreads();
7706 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7707
7708 wxPyEndAllowThreads(__tstate);
7709 if (PyErr_Occurred()) SWIG_fail;
7710 }
7711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj;
7720 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7721 PyObject * obj0 = 0 ;
7722 char *kwnames[] = {
7723 (char *) "self", NULL
7724 };
7725
7726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7728 if (SWIG_arg_fail(1)) SWIG_fail;
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 delete arg1;
7732
7733 wxPyEndAllowThreads(__tstate);
7734 if (PyErr_Occurred()) SWIG_fail;
7735 }
7736 Py_INCREF(Py_None); resultobj = Py_None;
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj;
7745 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7746 wxString *arg2 = 0 ;
7747 wxString const &arg3_defvalue = wxPyEmptyString ;
7748 wxString *arg3 = (wxString *) &arg3_defvalue ;
7749 bool result;
7750 bool temp2 = false ;
7751 bool temp3 = false ;
7752 PyObject * obj0 = 0 ;
7753 PyObject * obj1 = 0 ;
7754 PyObject * obj2 = 0 ;
7755 char *kwnames[] = {
7756 (char *) "self",(char *) "name",(char *) "path", NULL
7757 };
7758
7759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7761 if (SWIG_arg_fail(1)) SWIG_fail;
7762 {
7763 arg2 = wxString_in_helper(obj1);
7764 if (arg2 == NULL) SWIG_fail;
7765 temp2 = true;
7766 }
7767 if (obj2) {
7768 {
7769 arg3 = wxString_in_helper(obj2);
7770 if (arg3 == NULL) SWIG_fail;
7771 temp3 = true;
7772 }
7773 }
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 {
7782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7783 }
7784 {
7785 if (temp2)
7786 delete arg2;
7787 }
7788 {
7789 if (temp3)
7790 delete arg3;
7791 }
7792 return resultobj;
7793 fail:
7794 {
7795 if (temp2)
7796 delete arg2;
7797 }
7798 {
7799 if (temp3)
7800 delete arg3;
7801 }
7802 return NULL;
7803 }
7804
7805
7806 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj;
7808 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7809 bool result;
7810 PyObject * obj0 = 0 ;
7811 char *kwnames[] = {
7812 (char *) "self", NULL
7813 };
7814
7815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7817 if (SWIG_arg_fail(1)) SWIG_fail;
7818 {
7819 PyThreadState* __tstate = wxPyBeginAllowThreads();
7820 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7821
7822 wxPyEndAllowThreads(__tstate);
7823 if (PyErr_Occurred()) SWIG_fail;
7824 }
7825 {
7826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7827 }
7828 return resultobj;
7829 fail:
7830 return NULL;
7831 }
7832
7833
7834 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7835 PyObject *obj;
7836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7837 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7838 Py_INCREF(obj);
7839 return Py_BuildValue((char *)"");
7840 }
7841 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7842 PyObject *resultobj;
7843 wxWindow *arg1 = (wxWindow *) 0 ;
7844 wxDC *arg2 = 0 ;
7845 bool result;
7846 PyObject * obj0 = 0 ;
7847 PyObject * obj1 = 0 ;
7848 char *kwnames[] = {
7849 (char *) "window",(char *) "dc", NULL
7850 };
7851
7852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7854 if (SWIG_arg_fail(1)) SWIG_fail;
7855 {
7856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7857 if (SWIG_arg_fail(2)) SWIG_fail;
7858 if (arg2 == NULL) {
7859 SWIG_null_ref("wxDC");
7860 }
7861 if (SWIG_arg_fail(2)) SWIG_fail;
7862 }
7863 {
7864 PyThreadState* __tstate = wxPyBeginAllowThreads();
7865 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7866
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 {
7871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7872 }
7873 return resultobj;
7874 fail:
7875 return NULL;
7876 }
7877
7878
7879 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7880 PyObject *resultobj;
7881 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7882 PyObject * obj0 = 0 ;
7883 char *kwnames[] = {
7884 (char *) "self", NULL
7885 };
7886
7887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7889 if (SWIG_arg_fail(1)) SWIG_fail;
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 delete arg1;
7893
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 Py_INCREF(Py_None); resultobj = Py_None;
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7905 PyObject *resultobj;
7906 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7907 wxString result;
7908 PyObject * obj0 = 0 ;
7909 char *kwnames[] = {
7910 (char *) "self", NULL
7911 };
7912
7913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7915 if (SWIG_arg_fail(1)) SWIG_fail;
7916 {
7917 PyThreadState* __tstate = wxPyBeginAllowThreads();
7918 result = (arg1)->GetTip();
7919
7920 wxPyEndAllowThreads(__tstate);
7921 if (PyErr_Occurred()) SWIG_fail;
7922 }
7923 {
7924 #if wxUSE_UNICODE
7925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7926 #else
7927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7928 #endif
7929 }
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj;
7938 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7939 size_t result;
7940 PyObject * obj0 = 0 ;
7941 char *kwnames[] = {
7942 (char *) "self", NULL
7943 };
7944
7945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7947 if (SWIG_arg_fail(1)) SWIG_fail;
7948 {
7949 PyThreadState* __tstate = wxPyBeginAllowThreads();
7950 result = (size_t)(arg1)->GetCurrentTip();
7951
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 {
7956 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7957 }
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7965 PyObject *resultobj;
7966 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7967 wxString *arg2 = 0 ;
7968 wxString result;
7969 bool temp2 = false ;
7970 PyObject * obj0 = 0 ;
7971 PyObject * obj1 = 0 ;
7972 char *kwnames[] = {
7973 (char *) "self",(char *) "tip", NULL
7974 };
7975
7976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7978 if (SWIG_arg_fail(1)) SWIG_fail;
7979 {
7980 arg2 = wxString_in_helper(obj1);
7981 if (arg2 == NULL) SWIG_fail;
7982 temp2 = true;
7983 }
7984 {
7985 PyThreadState* __tstate = wxPyBeginAllowThreads();
7986 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7987
7988 wxPyEndAllowThreads(__tstate);
7989 if (PyErr_Occurred()) SWIG_fail;
7990 }
7991 {
7992 #if wxUSE_UNICODE
7993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7994 #else
7995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7996 #endif
7997 }
7998 {
7999 if (temp2)
8000 delete arg2;
8001 }
8002 return resultobj;
8003 fail:
8004 {
8005 if (temp2)
8006 delete arg2;
8007 }
8008 return NULL;
8009 }
8010
8011
8012 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8013 PyObject *obj;
8014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8015 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8016 Py_INCREF(obj);
8017 return Py_BuildValue((char *)"");
8018 }
8019 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8020 PyObject *resultobj;
8021 size_t arg1 ;
8022 wxPyTipProvider *result;
8023 PyObject * obj0 = 0 ;
8024 char *kwnames[] = {
8025 (char *) "currentTip", NULL
8026 };
8027
8028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8029 {
8030 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8031 if (SWIG_arg_fail(1)) SWIG_fail;
8032 }
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8036
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8048 PyObject *resultobj;
8049 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8050 PyObject *arg2 = (PyObject *) 0 ;
8051 PyObject *arg3 = (PyObject *) 0 ;
8052 PyObject * obj0 = 0 ;
8053 PyObject * obj1 = 0 ;
8054 PyObject * obj2 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self",(char *) "self",(char *) "_class", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 arg2 = obj1;
8063 arg3 = obj2;
8064 {
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 (arg1)->_setCallbackInfo(arg2,arg3);
8067
8068 wxPyEndAllowThreads(__tstate);
8069 if (PyErr_Occurred()) SWIG_fail;
8070 }
8071 Py_INCREF(Py_None); resultobj = Py_None;
8072 return resultobj;
8073 fail:
8074 return NULL;
8075 }
8076
8077
8078 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8079 PyObject *obj;
8080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8081 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8082 Py_INCREF(obj);
8083 return Py_BuildValue((char *)"");
8084 }
8085 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8086 PyObject *resultobj;
8087 wxWindow *arg1 = (wxWindow *) 0 ;
8088 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8089 bool arg3 = (bool) true ;
8090 bool result;
8091 PyObject * obj0 = 0 ;
8092 PyObject * obj1 = 0 ;
8093 PyObject * obj2 = 0 ;
8094 char *kwnames[] = {
8095 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8096 };
8097
8098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8100 if (SWIG_arg_fail(1)) SWIG_fail;
8101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8102 if (SWIG_arg_fail(2)) SWIG_fail;
8103 if (obj2) {
8104 {
8105 arg3 = (bool)(SWIG_As_bool(obj2));
8106 if (SWIG_arg_fail(3)) SWIG_fail;
8107 }
8108 }
8109 {
8110 if (!wxPyCheckForApp()) SWIG_fail;
8111 PyThreadState* __tstate = wxPyBeginAllowThreads();
8112 result = (bool)wxShowTip(arg1,arg2,arg3);
8113
8114 wxPyEndAllowThreads(__tstate);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 {
8118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8119 }
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj;
8128 wxString *arg1 = 0 ;
8129 size_t arg2 ;
8130 wxTipProvider *result;
8131 bool temp1 = false ;
8132 PyObject * obj0 = 0 ;
8133 PyObject * obj1 = 0 ;
8134 char *kwnames[] = {
8135 (char *) "filename",(char *) "currentTip", NULL
8136 };
8137
8138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8139 {
8140 arg1 = wxString_in_helper(obj0);
8141 if (arg1 == NULL) SWIG_fail;
8142 temp1 = true;
8143 }
8144 {
8145 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8146 if (SWIG_arg_fail(2)) SWIG_fail;
8147 }
8148 {
8149 if (!wxPyCheckForApp()) SWIG_fail;
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8152
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8157 {
8158 if (temp1)
8159 delete arg1;
8160 }
8161 return resultobj;
8162 fail:
8163 {
8164 if (temp1)
8165 delete arg1;
8166 }
8167 return NULL;
8168 }
8169
8170
8171 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8172 PyObject *resultobj;
8173 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8174 int arg2 = (int) -1 ;
8175 wxPyTimer *result;
8176 PyObject * obj0 = 0 ;
8177 PyObject * obj1 = 0 ;
8178 char *kwnames[] = {
8179 (char *) "owner",(char *) "id", NULL
8180 };
8181
8182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8183 if (obj0) {
8184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8185 if (SWIG_arg_fail(1)) SWIG_fail;
8186 }
8187 if (obj1) {
8188 {
8189 arg2 = (int)(SWIG_As_int(obj1));
8190 if (SWIG_arg_fail(2)) SWIG_fail;
8191 }
8192 }
8193 {
8194 if (!wxPyCheckForApp()) SWIG_fail;
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8202 return resultobj;
8203 fail:
8204 return NULL;
8205 }
8206
8207
8208 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8209 PyObject *resultobj;
8210 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8211 PyObject * obj0 = 0 ;
8212 char *kwnames[] = {
8213 (char *) "self", NULL
8214 };
8215
8216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8218 if (SWIG_arg_fail(1)) SWIG_fail;
8219 {
8220 PyThreadState* __tstate = wxPyBeginAllowThreads();
8221 delete arg1;
8222
8223 wxPyEndAllowThreads(__tstate);
8224 if (PyErr_Occurred()) SWIG_fail;
8225 }
8226 Py_INCREF(Py_None); resultobj = Py_None;
8227 return resultobj;
8228 fail:
8229 return NULL;
8230 }
8231
8232
8233 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8234 PyObject *resultobj;
8235 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8236 PyObject *arg2 = (PyObject *) 0 ;
8237 PyObject *arg3 = (PyObject *) 0 ;
8238 int arg4 = (int) 1 ;
8239 PyObject * obj0 = 0 ;
8240 PyObject * obj1 = 0 ;
8241 PyObject * obj2 = 0 ;
8242 PyObject * obj3 = 0 ;
8243 char *kwnames[] = {
8244 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8245 };
8246
8247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8249 if (SWIG_arg_fail(1)) SWIG_fail;
8250 arg2 = obj1;
8251 arg3 = obj2;
8252 if (obj3) {
8253 {
8254 arg4 = (int)(SWIG_As_int(obj3));
8255 if (SWIG_arg_fail(4)) SWIG_fail;
8256 }
8257 }
8258 {
8259 PyThreadState* __tstate = wxPyBeginAllowThreads();
8260 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8261
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 Py_INCREF(Py_None); resultobj = Py_None;
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8273 PyObject *resultobj;
8274 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8275 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8276 int arg3 = (int) -1 ;
8277 PyObject * obj0 = 0 ;
8278 PyObject * obj1 = 0 ;
8279 PyObject * obj2 = 0 ;
8280 char *kwnames[] = {
8281 (char *) "self",(char *) "owner",(char *) "id", NULL
8282 };
8283
8284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8286 if (SWIG_arg_fail(1)) SWIG_fail;
8287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8288 if (SWIG_arg_fail(2)) SWIG_fail;
8289 if (obj2) {
8290 {
8291 arg3 = (int)(SWIG_As_int(obj2));
8292 if (SWIG_arg_fail(3)) SWIG_fail;
8293 }
8294 }
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 (arg1)->SetOwner(arg2,arg3);
8298
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 Py_INCREF(Py_None); resultobj = Py_None;
8303 return resultobj;
8304 fail:
8305 return NULL;
8306 }
8307
8308
8309 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8310 PyObject *resultobj;
8311 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8312 wxEvtHandler *result;
8313 PyObject * obj0 = 0 ;
8314 char *kwnames[] = {
8315 (char *) "self", NULL
8316 };
8317
8318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8320 if (SWIG_arg_fail(1)) SWIG_fail;
8321 {
8322 PyThreadState* __tstate = wxPyBeginAllowThreads();
8323 result = (wxEvtHandler *)(arg1)->GetOwner();
8324
8325 wxPyEndAllowThreads(__tstate);
8326 if (PyErr_Occurred()) SWIG_fail;
8327 }
8328 {
8329 resultobj = wxPyMake_wxObject(result, 0);
8330 }
8331 return resultobj;
8332 fail:
8333 return NULL;
8334 }
8335
8336
8337 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8338 PyObject *resultobj;
8339 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8340 int arg2 = (int) -1 ;
8341 bool arg3 = (bool) false ;
8342 bool result;
8343 PyObject * obj0 = 0 ;
8344 PyObject * obj1 = 0 ;
8345 PyObject * obj2 = 0 ;
8346 char *kwnames[] = {
8347 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8348 };
8349
8350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8352 if (SWIG_arg_fail(1)) SWIG_fail;
8353 if (obj1) {
8354 {
8355 arg2 = (int)(SWIG_As_int(obj1));
8356 if (SWIG_arg_fail(2)) SWIG_fail;
8357 }
8358 }
8359 if (obj2) {
8360 {
8361 arg3 = (bool)(SWIG_As_bool(obj2));
8362 if (SWIG_arg_fail(3)) SWIG_fail;
8363 }
8364 }
8365 {
8366 PyThreadState* __tstate = wxPyBeginAllowThreads();
8367 result = (bool)(arg1)->Start(arg2,arg3);
8368
8369 wxPyEndAllowThreads(__tstate);
8370 if (PyErr_Occurred()) SWIG_fail;
8371 }
8372 {
8373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8374 }
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj;
8383 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8384 PyObject * obj0 = 0 ;
8385 char *kwnames[] = {
8386 (char *) "self", NULL
8387 };
8388
8389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8391 if (SWIG_arg_fail(1)) SWIG_fail;
8392 {
8393 PyThreadState* __tstate = wxPyBeginAllowThreads();
8394 (arg1)->Stop();
8395
8396 wxPyEndAllowThreads(__tstate);
8397 if (PyErr_Occurred()) SWIG_fail;
8398 }
8399 Py_INCREF(Py_None); resultobj = Py_None;
8400 return resultobj;
8401 fail:
8402 return NULL;
8403 }
8404
8405
8406 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8407 PyObject *resultobj;
8408 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8409 bool result;
8410 PyObject * obj0 = 0 ;
8411 char *kwnames[] = {
8412 (char *) "self", NULL
8413 };
8414
8415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8417 if (SWIG_arg_fail(1)) SWIG_fail;
8418 {
8419 PyThreadState* __tstate = wxPyBeginAllowThreads();
8420 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8421
8422 wxPyEndAllowThreads(__tstate);
8423 if (PyErr_Occurred()) SWIG_fail;
8424 }
8425 {
8426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8427 }
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj;
8436 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8437 int result;
8438 PyObject * obj0 = 0 ;
8439 char *kwnames[] = {
8440 (char *) "self", NULL
8441 };
8442
8443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8445 if (SWIG_arg_fail(1)) SWIG_fail;
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8449
8450 wxPyEndAllowThreads(__tstate);
8451 if (PyErr_Occurred()) SWIG_fail;
8452 }
8453 {
8454 resultobj = SWIG_From_int((int)(result));
8455 }
8456 return resultobj;
8457 fail:
8458 return NULL;
8459 }
8460
8461
8462 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8463 PyObject *resultobj;
8464 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8465 bool result;
8466 PyObject * obj0 = 0 ;
8467 char *kwnames[] = {
8468 (char *) "self", NULL
8469 };
8470
8471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8473 if (SWIG_arg_fail(1)) SWIG_fail;
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8477
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 {
8482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8483 }
8484 return resultobj;
8485 fail:
8486 return NULL;
8487 }
8488
8489
8490 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8491 PyObject *resultobj;
8492 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8493 int result;
8494 PyObject * obj0 = 0 ;
8495 char *kwnames[] = {
8496 (char *) "self", NULL
8497 };
8498
8499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8501 if (SWIG_arg_fail(1)) SWIG_fail;
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (int)((wxPyTimer const *)arg1)->GetId();
8505
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 {
8510 resultobj = SWIG_From_int((int)(result));
8511 }
8512 return resultobj;
8513 fail:
8514 return NULL;
8515 }
8516
8517
8518 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8519 PyObject *obj;
8520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8521 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8522 Py_INCREF(obj);
8523 return Py_BuildValue((char *)"");
8524 }
8525 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8526 PyObject *resultobj;
8527 int arg1 = (int) 0 ;
8528 int arg2 = (int) 0 ;
8529 wxTimerEvent *result;
8530 PyObject * obj0 = 0 ;
8531 PyObject * obj1 = 0 ;
8532 char *kwnames[] = {
8533 (char *) "timerid",(char *) "interval", NULL
8534 };
8535
8536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8537 if (obj0) {
8538 {
8539 arg1 = (int)(SWIG_As_int(obj0));
8540 if (SWIG_arg_fail(1)) SWIG_fail;
8541 }
8542 }
8543 if (obj1) {
8544 {
8545 arg2 = (int)(SWIG_As_int(obj1));
8546 if (SWIG_arg_fail(2)) SWIG_fail;
8547 }
8548 }
8549 {
8550 PyThreadState* __tstate = wxPyBeginAllowThreads();
8551 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8552
8553 wxPyEndAllowThreads(__tstate);
8554 if (PyErr_Occurred()) SWIG_fail;
8555 }
8556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8557 return resultobj;
8558 fail:
8559 return NULL;
8560 }
8561
8562
8563 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8564 PyObject *resultobj;
8565 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8566 int result;
8567 PyObject * obj0 = 0 ;
8568 char *kwnames[] = {
8569 (char *) "self", NULL
8570 };
8571
8572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8574 if (SWIG_arg_fail(1)) SWIG_fail;
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8578
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 {
8583 resultobj = SWIG_From_int((int)(result));
8584 }
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8592 PyObject *obj;
8593 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8594 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8595 Py_INCREF(obj);
8596 return Py_BuildValue((char *)"");
8597 }
8598 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8599 PyObject *resultobj;
8600 wxTimer *arg1 = 0 ;
8601 wxTimerRunner *result;
8602 PyObject * obj0 = 0 ;
8603
8604 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8605 {
8606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 if (arg1 == NULL) {
8609 SWIG_null_ref("wxTimer");
8610 }
8611 if (SWIG_arg_fail(1)) SWIG_fail;
8612 }
8613 {
8614 if (!wxPyCheckForApp()) SWIG_fail;
8615 PyThreadState* __tstate = wxPyBeginAllowThreads();
8616 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8617
8618 wxPyEndAllowThreads(__tstate);
8619 if (PyErr_Occurred()) SWIG_fail;
8620 }
8621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8622 return resultobj;
8623 fail:
8624 return NULL;
8625 }
8626
8627
8628 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8629 PyObject *resultobj;
8630 wxTimer *arg1 = 0 ;
8631 int arg2 ;
8632 bool arg3 = (bool) false ;
8633 wxTimerRunner *result;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 PyObject * obj2 = 0 ;
8637
8638 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8639 {
8640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8641 if (SWIG_arg_fail(1)) SWIG_fail;
8642 if (arg1 == NULL) {
8643 SWIG_null_ref("wxTimer");
8644 }
8645 if (SWIG_arg_fail(1)) SWIG_fail;
8646 }
8647 {
8648 arg2 = (int)(SWIG_As_int(obj1));
8649 if (SWIG_arg_fail(2)) SWIG_fail;
8650 }
8651 if (obj2) {
8652 {
8653 arg3 = (bool)(SWIG_As_bool(obj2));
8654 if (SWIG_arg_fail(3)) SWIG_fail;
8655 }
8656 }
8657 {
8658 if (!wxPyCheckForApp()) SWIG_fail;
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8661
8662 wxPyEndAllowThreads(__tstate);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8666 return resultobj;
8667 fail:
8668 return NULL;
8669 }
8670
8671
8672 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8673 int argc;
8674 PyObject *argv[4];
8675 int ii;
8676
8677 argc = PyObject_Length(args);
8678 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8679 argv[ii] = PyTuple_GetItem(args,ii);
8680 }
8681 if (argc == 1) {
8682 int _v;
8683 {
8684 void *ptr = 0;
8685 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8686 _v = 0;
8687 PyErr_Clear();
8688 } else {
8689 _v = (ptr != 0);
8690 }
8691 }
8692 if (_v) {
8693 return _wrap_new_TimerRunner__SWIG_0(self,args);
8694 }
8695 }
8696 if ((argc >= 2) && (argc <= 3)) {
8697 int _v;
8698 {
8699 void *ptr = 0;
8700 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8701 _v = 0;
8702 PyErr_Clear();
8703 } else {
8704 _v = (ptr != 0);
8705 }
8706 }
8707 if (_v) {
8708 _v = SWIG_Check_int(argv[1]);
8709 if (_v) {
8710 if (argc <= 2) {
8711 return _wrap_new_TimerRunner__SWIG_1(self,args);
8712 }
8713 _v = SWIG_Check_bool(argv[2]);
8714 if (_v) {
8715 return _wrap_new_TimerRunner__SWIG_1(self,args);
8716 }
8717 }
8718 }
8719 }
8720
8721 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8722 return NULL;
8723 }
8724
8725
8726 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8727 PyObject *resultobj;
8728 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8729 PyObject * obj0 = 0 ;
8730 char *kwnames[] = {
8731 (char *) "self", NULL
8732 };
8733
8734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8736 if (SWIG_arg_fail(1)) SWIG_fail;
8737 {
8738 PyThreadState* __tstate = wxPyBeginAllowThreads();
8739 delete arg1;
8740
8741 wxPyEndAllowThreads(__tstate);
8742 if (PyErr_Occurred()) SWIG_fail;
8743 }
8744 Py_INCREF(Py_None); resultobj = Py_None;
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8752 PyObject *resultobj;
8753 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8754 int arg2 ;
8755 bool arg3 = (bool) false ;
8756 PyObject * obj0 = 0 ;
8757 PyObject * obj1 = 0 ;
8758 PyObject * obj2 = 0 ;
8759 char *kwnames[] = {
8760 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8761 };
8762
8763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8765 if (SWIG_arg_fail(1)) SWIG_fail;
8766 {
8767 arg2 = (int)(SWIG_As_int(obj1));
8768 if (SWIG_arg_fail(2)) SWIG_fail;
8769 }
8770 if (obj2) {
8771 {
8772 arg3 = (bool)(SWIG_As_bool(obj2));
8773 if (SWIG_arg_fail(3)) SWIG_fail;
8774 }
8775 }
8776 {
8777 PyThreadState* __tstate = wxPyBeginAllowThreads();
8778 (arg1)->Start(arg2,arg3);
8779
8780 wxPyEndAllowThreads(__tstate);
8781 if (PyErr_Occurred()) SWIG_fail;
8782 }
8783 Py_INCREF(Py_None); resultobj = Py_None;
8784 return resultobj;
8785 fail:
8786 return NULL;
8787 }
8788
8789
8790 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8791 PyObject *obj;
8792 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8793 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8794 Py_INCREF(obj);
8795 return Py_BuildValue((char *)"");
8796 }
8797 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj;
8799 wxLog *result;
8800 char *kwnames[] = {
8801 NULL
8802 };
8803
8804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8805 {
8806 PyThreadState* __tstate = wxPyBeginAllowThreads();
8807 result = (wxLog *)new wxLog();
8808
8809 wxPyEndAllowThreads(__tstate);
8810 if (PyErr_Occurred()) SWIG_fail;
8811 }
8812 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8813 return resultobj;
8814 fail:
8815 return NULL;
8816 }
8817
8818
8819 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8820 PyObject *resultobj;
8821 bool result;
8822 char *kwnames[] = {
8823 NULL
8824 };
8825
8826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8827 {
8828 PyThreadState* __tstate = wxPyBeginAllowThreads();
8829 result = (bool)wxLog::IsEnabled();
8830
8831 wxPyEndAllowThreads(__tstate);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 {
8835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8836 }
8837 return resultobj;
8838 fail:
8839 return NULL;
8840 }
8841
8842
8843 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj;
8845 bool arg1 = (bool) true ;
8846 bool result;
8847 PyObject * obj0 = 0 ;
8848 char *kwnames[] = {
8849 (char *) "doIt", NULL
8850 };
8851
8852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8853 if (obj0) {
8854 {
8855 arg1 = (bool)(SWIG_As_bool(obj0));
8856 if (SWIG_arg_fail(1)) SWIG_fail;
8857 }
8858 }
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 result = (bool)wxLog::EnableLogging(arg1);
8862
8863 wxPyEndAllowThreads(__tstate);
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 {
8867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8868 }
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8876 PyObject *resultobj;
8877 wxLogLevel arg1 ;
8878 wxChar *arg2 = (wxChar *) 0 ;
8879 time_t arg3 ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 PyObject * obj2 = 0 ;
8883 char *kwnames[] = {
8884 (char *) "level",(char *) "szString",(char *) "t", NULL
8885 };
8886
8887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8888 {
8889 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8890 if (SWIG_arg_fail(1)) SWIG_fail;
8891 }
8892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8893 if (SWIG_arg_fail(2)) SWIG_fail;
8894 {
8895 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8896 if (SWIG_arg_fail(3)) SWIG_fail;
8897 }
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8901
8902 wxPyEndAllowThreads(__tstate);
8903 if (PyErr_Occurred()) SWIG_fail;
8904 }
8905 Py_INCREF(Py_None); resultobj = Py_None;
8906 return resultobj;
8907 fail:
8908 return NULL;
8909 }
8910
8911
8912 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8913 PyObject *resultobj;
8914 wxLog *arg1 = (wxLog *) 0 ;
8915 PyObject * obj0 = 0 ;
8916 char *kwnames[] = {
8917 (char *) "self", NULL
8918 };
8919
8920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8922 if (SWIG_arg_fail(1)) SWIG_fail;
8923 {
8924 PyThreadState* __tstate = wxPyBeginAllowThreads();
8925 (arg1)->Flush();
8926
8927 wxPyEndAllowThreads(__tstate);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 Py_INCREF(Py_None); resultobj = Py_None;
8931 return resultobj;
8932 fail:
8933 return NULL;
8934 }
8935
8936
8937 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8938 PyObject *resultobj;
8939 char *kwnames[] = {
8940 NULL
8941 };
8942
8943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 wxLog::FlushActive();
8947
8948 wxPyEndAllowThreads(__tstate);
8949 if (PyErr_Occurred()) SWIG_fail;
8950 }
8951 Py_INCREF(Py_None); resultobj = Py_None;
8952 return resultobj;
8953 fail:
8954 return NULL;
8955 }
8956
8957
8958 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8959 PyObject *resultobj;
8960 wxLog *result;
8961 char *kwnames[] = {
8962 NULL
8963 };
8964
8965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 result = (wxLog *)wxLog::GetActiveTarget();
8969
8970 wxPyEndAllowThreads(__tstate);
8971 if (PyErr_Occurred()) SWIG_fail;
8972 }
8973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8974 return resultobj;
8975 fail:
8976 return NULL;
8977 }
8978
8979
8980 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8981 PyObject *resultobj;
8982 wxLog *arg1 = (wxLog *) 0 ;
8983 wxLog *result;
8984 PyObject * obj0 = 0 ;
8985 char *kwnames[] = {
8986 (char *) "pLogger", NULL
8987 };
8988
8989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8991 if (SWIG_arg_fail(1)) SWIG_fail;
8992 {
8993 PyThreadState* __tstate = wxPyBeginAllowThreads();
8994 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8995
8996 wxPyEndAllowThreads(__tstate);
8997 if (PyErr_Occurred()) SWIG_fail;
8998 }
8999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj;
9008 char *kwnames[] = {
9009 NULL
9010 };
9011
9012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9013 {
9014 PyThreadState* __tstate = wxPyBeginAllowThreads();
9015 wxLog::Suspend();
9016
9017 wxPyEndAllowThreads(__tstate);
9018 if (PyErr_Occurred()) SWIG_fail;
9019 }
9020 Py_INCREF(Py_None); resultobj = Py_None;
9021 return resultobj;
9022 fail:
9023 return NULL;
9024 }
9025
9026
9027 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9028 PyObject *resultobj;
9029 char *kwnames[] = {
9030 NULL
9031 };
9032
9033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 wxLog::Resume();
9037
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 Py_INCREF(Py_None); resultobj = Py_None;
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9049 PyObject *resultobj;
9050 bool arg1 = (bool) true ;
9051 PyObject * obj0 = 0 ;
9052 char *kwnames[] = {
9053 (char *) "bVerbose", NULL
9054 };
9055
9056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9057 if (obj0) {
9058 {
9059 arg1 = (bool)(SWIG_As_bool(obj0));
9060 if (SWIG_arg_fail(1)) SWIG_fail;
9061 }
9062 }
9063 {
9064 PyThreadState* __tstate = wxPyBeginAllowThreads();
9065 wxLog::SetVerbose(arg1);
9066
9067 wxPyEndAllowThreads(__tstate);
9068 if (PyErr_Occurred()) SWIG_fail;
9069 }
9070 Py_INCREF(Py_None); resultobj = Py_None;
9071 return resultobj;
9072 fail:
9073 return NULL;
9074 }
9075
9076
9077 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9078 PyObject *resultobj;
9079 wxLogLevel arg1 ;
9080 PyObject * obj0 = 0 ;
9081 char *kwnames[] = {
9082 (char *) "logLevel", NULL
9083 };
9084
9085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9086 {
9087 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9088 if (SWIG_arg_fail(1)) SWIG_fail;
9089 }
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 wxLog::SetLogLevel(arg1);
9093
9094 wxPyEndAllowThreads(__tstate);
9095 if (PyErr_Occurred()) SWIG_fail;
9096 }
9097 Py_INCREF(Py_None); resultobj = Py_None;
9098 return resultobj;
9099 fail:
9100 return NULL;
9101 }
9102
9103
9104 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9105 PyObject *resultobj;
9106 char *kwnames[] = {
9107 NULL
9108 };
9109
9110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9111 {
9112 PyThreadState* __tstate = wxPyBeginAllowThreads();
9113 wxLog::DontCreateOnDemand();
9114
9115 wxPyEndAllowThreads(__tstate);
9116 if (PyErr_Occurred()) SWIG_fail;
9117 }
9118 Py_INCREF(Py_None); resultobj = Py_None;
9119 return resultobj;
9120 fail:
9121 return NULL;
9122 }
9123
9124
9125 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj;
9127 wxTraceMask arg1 ;
9128 PyObject * obj0 = 0 ;
9129 char *kwnames[] = {
9130 (char *) "ulMask", NULL
9131 };
9132
9133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9134 {
9135 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9136 if (SWIG_arg_fail(1)) SWIG_fail;
9137 }
9138 {
9139 PyThreadState* __tstate = wxPyBeginAllowThreads();
9140 wxLog::SetTraceMask(arg1);
9141
9142 wxPyEndAllowThreads(__tstate);
9143 if (PyErr_Occurred()) SWIG_fail;
9144 }
9145 Py_INCREF(Py_None); resultobj = Py_None;
9146 return resultobj;
9147 fail:
9148 return NULL;
9149 }
9150
9151
9152 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9153 PyObject *resultobj;
9154 wxString *arg1 = 0 ;
9155 bool temp1 = false ;
9156 PyObject * obj0 = 0 ;
9157 char *kwnames[] = {
9158 (char *) "str", NULL
9159 };
9160
9161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9162 {
9163 arg1 = wxString_in_helper(obj0);
9164 if (arg1 == NULL) SWIG_fail;
9165 temp1 = true;
9166 }
9167 {
9168 PyThreadState* __tstate = wxPyBeginAllowThreads();
9169 wxLog::AddTraceMask((wxString const &)*arg1);
9170
9171 wxPyEndAllowThreads(__tstate);
9172 if (PyErr_Occurred()) SWIG_fail;
9173 }
9174 Py_INCREF(Py_None); resultobj = Py_None;
9175 {
9176 if (temp1)
9177 delete arg1;
9178 }
9179 return resultobj;
9180 fail:
9181 {
9182 if (temp1)
9183 delete arg1;
9184 }
9185 return NULL;
9186 }
9187
9188
9189 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9190 PyObject *resultobj;
9191 wxString *arg1 = 0 ;
9192 bool temp1 = false ;
9193 PyObject * obj0 = 0 ;
9194 char *kwnames[] = {
9195 (char *) "str", NULL
9196 };
9197
9198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9199 {
9200 arg1 = wxString_in_helper(obj0);
9201 if (arg1 == NULL) SWIG_fail;
9202 temp1 = true;
9203 }
9204 {
9205 PyThreadState* __tstate = wxPyBeginAllowThreads();
9206 wxLog::RemoveTraceMask((wxString const &)*arg1);
9207
9208 wxPyEndAllowThreads(__tstate);
9209 if (PyErr_Occurred()) SWIG_fail;
9210 }
9211 Py_INCREF(Py_None); resultobj = Py_None;
9212 {
9213 if (temp1)
9214 delete arg1;
9215 }
9216 return resultobj;
9217 fail:
9218 {
9219 if (temp1)
9220 delete arg1;
9221 }
9222 return NULL;
9223 }
9224
9225
9226 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9227 PyObject *resultobj;
9228 char *kwnames[] = {
9229 NULL
9230 };
9231
9232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 wxLog::ClearTraceMasks();
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 Py_INCREF(Py_None); resultobj = Py_None;
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9248 PyObject *resultobj;
9249 wxArrayString *result;
9250 char *kwnames[] = {
9251 NULL
9252 };
9253
9254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 {
9258 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9259 result = (wxArrayString *) &_result_ref;
9260 }
9261
9262 wxPyEndAllowThreads(__tstate);
9263 if (PyErr_Occurred()) SWIG_fail;
9264 }
9265 {
9266 resultobj = wxArrayString2PyList_helper(*result);
9267 }
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9275 PyObject *resultobj;
9276 wxChar *arg1 = (wxChar *) 0 ;
9277 PyObject * obj0 = 0 ;
9278 char *kwnames[] = {
9279 (char *) "ts", NULL
9280 };
9281
9282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9284 if (SWIG_arg_fail(1)) SWIG_fail;
9285 {
9286 PyThreadState* __tstate = wxPyBeginAllowThreads();
9287 wxLog::SetTimestamp((wxChar const *)arg1);
9288
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 Py_INCREF(Py_None); resultobj = Py_None;
9293 return resultobj;
9294 fail:
9295 return NULL;
9296 }
9297
9298
9299 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9300 PyObject *resultobj;
9301 bool result;
9302 char *kwnames[] = {
9303 NULL
9304 };
9305
9306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9307 {
9308 PyThreadState* __tstate = wxPyBeginAllowThreads();
9309 result = (bool)wxLog::GetVerbose();
9310
9311 wxPyEndAllowThreads(__tstate);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 {
9315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9316 }
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9324 PyObject *resultobj;
9325 wxTraceMask result;
9326 char *kwnames[] = {
9327 NULL
9328 };
9329
9330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 result = (wxTraceMask)wxLog::GetTraceMask();
9334
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 {
9339 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9340 }
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9348 PyObject *resultobj;
9349 wxChar *arg1 = (wxChar *) 0 ;
9350 bool result;
9351 PyObject * obj0 = 0 ;
9352 char *kwnames[] = {
9353 (char *) "mask", NULL
9354 };
9355
9356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9358 if (SWIG_arg_fail(1)) SWIG_fail;
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9362
9363 wxPyEndAllowThreads(__tstate);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 {
9367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9368 }
9369 return resultobj;
9370 fail:
9371 return NULL;
9372 }
9373
9374
9375 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9376 PyObject *resultobj;
9377 wxLogLevel result;
9378 char *kwnames[] = {
9379 NULL
9380 };
9381
9382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9383 {
9384 PyThreadState* __tstate = wxPyBeginAllowThreads();
9385 result = (wxLogLevel)wxLog::GetLogLevel();
9386
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 {
9391 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9392 }
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9400 PyObject *resultobj;
9401 wxChar *result;
9402 char *kwnames[] = {
9403 NULL
9404 };
9405
9406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9407 {
9408 PyThreadState* __tstate = wxPyBeginAllowThreads();
9409 result = (wxChar *)wxLog::GetTimestamp();
9410
9411 wxPyEndAllowThreads(__tstate);
9412 if (PyErr_Occurred()) SWIG_fail;
9413 }
9414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9415 return resultobj;
9416 fail:
9417 return NULL;
9418 }
9419
9420
9421 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9422 PyObject *resultobj;
9423 wxString result;
9424 char *kwnames[] = {
9425 NULL
9426 };
9427
9428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9429 {
9430 PyThreadState* __tstate = wxPyBeginAllowThreads();
9431 result = Log_TimeStamp();
9432
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 {
9437 #if wxUSE_UNICODE
9438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9439 #else
9440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9441 #endif
9442 }
9443 return resultobj;
9444 fail:
9445 return NULL;
9446 }
9447
9448
9449 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9450 PyObject *resultobj;
9451 wxLog *arg1 = (wxLog *) 0 ;
9452 PyObject * obj0 = 0 ;
9453 char *kwnames[] = {
9454 (char *) "self", NULL
9455 };
9456
9457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9459 if (SWIG_arg_fail(1)) SWIG_fail;
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 wxLog_Destroy(arg1);
9463
9464 wxPyEndAllowThreads(__tstate);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 Py_INCREF(Py_None); resultobj = Py_None;
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9475 PyObject *obj;
9476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9477 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9478 Py_INCREF(obj);
9479 return Py_BuildValue((char *)"");
9480 }
9481 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9482 PyObject *resultobj;
9483 wxLogStderr *result;
9484 char *kwnames[] = {
9485 NULL
9486 };
9487
9488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 result = (wxLogStderr *)new wxLogStderr();
9492
9493 wxPyEndAllowThreads(__tstate);
9494 if (PyErr_Occurred()) SWIG_fail;
9495 }
9496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9504 PyObject *obj;
9505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9506 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9507 Py_INCREF(obj);
9508 return Py_BuildValue((char *)"");
9509 }
9510 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9511 PyObject *resultobj;
9512 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9513 wxLogTextCtrl *result;
9514 PyObject * obj0 = 0 ;
9515 char *kwnames[] = {
9516 (char *) "pTextCtrl", NULL
9517 };
9518
9519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9521 if (SWIG_arg_fail(1)) SWIG_fail;
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9525
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9537 PyObject *obj;
9538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9539 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9540 Py_INCREF(obj);
9541 return Py_BuildValue((char *)"");
9542 }
9543 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj;
9545 wxLogGui *result;
9546 char *kwnames[] = {
9547 NULL
9548 };
9549
9550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9551 {
9552 PyThreadState* __tstate = wxPyBeginAllowThreads();
9553 result = (wxLogGui *)new wxLogGui();
9554
9555 wxPyEndAllowThreads(__tstate);
9556 if (PyErr_Occurred()) SWIG_fail;
9557 }
9558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9559 return resultobj;
9560 fail:
9561 return NULL;
9562 }
9563
9564
9565 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9566 PyObject *obj;
9567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9568 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9569 Py_INCREF(obj);
9570 return Py_BuildValue((char *)"");
9571 }
9572 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9573 PyObject *resultobj;
9574 wxFrame *arg1 = (wxFrame *) 0 ;
9575 wxString *arg2 = 0 ;
9576 bool arg3 = (bool) true ;
9577 bool arg4 = (bool) true ;
9578 wxLogWindow *result;
9579 bool temp2 = false ;
9580 PyObject * obj0 = 0 ;
9581 PyObject * obj1 = 0 ;
9582 PyObject * obj2 = 0 ;
9583 PyObject * obj3 = 0 ;
9584 char *kwnames[] = {
9585 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9586 };
9587
9588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9590 if (SWIG_arg_fail(1)) SWIG_fail;
9591 {
9592 arg2 = wxString_in_helper(obj1);
9593 if (arg2 == NULL) SWIG_fail;
9594 temp2 = true;
9595 }
9596 if (obj2) {
9597 {
9598 arg3 = (bool)(SWIG_As_bool(obj2));
9599 if (SWIG_arg_fail(3)) SWIG_fail;
9600 }
9601 }
9602 if (obj3) {
9603 {
9604 arg4 = (bool)(SWIG_As_bool(obj3));
9605 if (SWIG_arg_fail(4)) SWIG_fail;
9606 }
9607 }
9608 {
9609 PyThreadState* __tstate = wxPyBeginAllowThreads();
9610 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9611
9612 wxPyEndAllowThreads(__tstate);
9613 if (PyErr_Occurred()) SWIG_fail;
9614 }
9615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9616 {
9617 if (temp2)
9618 delete arg2;
9619 }
9620 return resultobj;
9621 fail:
9622 {
9623 if (temp2)
9624 delete arg2;
9625 }
9626 return NULL;
9627 }
9628
9629
9630 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9631 PyObject *resultobj;
9632 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9633 bool arg2 = (bool) true ;
9634 PyObject * obj0 = 0 ;
9635 PyObject * obj1 = 0 ;
9636 char *kwnames[] = {
9637 (char *) "self",(char *) "bShow", NULL
9638 };
9639
9640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9642 if (SWIG_arg_fail(1)) SWIG_fail;
9643 if (obj1) {
9644 {
9645 arg2 = (bool)(SWIG_As_bool(obj1));
9646 if (SWIG_arg_fail(2)) SWIG_fail;
9647 }
9648 }
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 (arg1)->Show(arg2);
9652
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 Py_INCREF(Py_None); resultobj = Py_None;
9657 return resultobj;
9658 fail:
9659 return NULL;
9660 }
9661
9662
9663 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9664 PyObject *resultobj;
9665 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9666 wxFrame *result;
9667 PyObject * obj0 = 0 ;
9668 char *kwnames[] = {
9669 (char *) "self", NULL
9670 };
9671
9672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9674 if (SWIG_arg_fail(1)) SWIG_fail;
9675 {
9676 PyThreadState* __tstate = wxPyBeginAllowThreads();
9677 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9678
9679 wxPyEndAllowThreads(__tstate);
9680 if (PyErr_Occurred()) SWIG_fail;
9681 }
9682 {
9683 resultobj = wxPyMake_wxObject(result, 0);
9684 }
9685 return resultobj;
9686 fail:
9687 return NULL;
9688 }
9689
9690
9691 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9692 PyObject *resultobj;
9693 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9694 wxLog *result;
9695 PyObject * obj0 = 0 ;
9696 char *kwnames[] = {
9697 (char *) "self", NULL
9698 };
9699
9700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9702 if (SWIG_arg_fail(1)) SWIG_fail;
9703 {
9704 PyThreadState* __tstate = wxPyBeginAllowThreads();
9705 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9706
9707 wxPyEndAllowThreads(__tstate);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9711 return resultobj;
9712 fail:
9713 return NULL;
9714 }
9715
9716
9717 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9718 PyObject *resultobj;
9719 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9720 bool result;
9721 PyObject * obj0 = 0 ;
9722 char *kwnames[] = {
9723 (char *) "self", NULL
9724 };
9725
9726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9728 if (SWIG_arg_fail(1)) SWIG_fail;
9729 {
9730 PyThreadState* __tstate = wxPyBeginAllowThreads();
9731 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9732
9733 wxPyEndAllowThreads(__tstate);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 {
9737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9738 }
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9746 PyObject *resultobj;
9747 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9748 bool arg2 ;
9749 PyObject * obj0 = 0 ;
9750 PyObject * obj1 = 0 ;
9751 char *kwnames[] = {
9752 (char *) "self",(char *) "bDoPass", NULL
9753 };
9754
9755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(1)) SWIG_fail;
9758 {
9759 arg2 = (bool)(SWIG_As_bool(obj1));
9760 if (SWIG_arg_fail(2)) SWIG_fail;
9761 }
9762 {
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 (arg1)->PassMessages(arg2);
9765
9766 wxPyEndAllowThreads(__tstate);
9767 if (PyErr_Occurred()) SWIG_fail;
9768 }
9769 Py_INCREF(Py_None); resultobj = Py_None;
9770 return resultobj;
9771 fail:
9772 return NULL;
9773 }
9774
9775
9776 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9777 PyObject *obj;
9778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9779 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9780 Py_INCREF(obj);
9781 return Py_BuildValue((char *)"");
9782 }
9783 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9784 PyObject *resultobj;
9785 wxLog *arg1 = (wxLog *) 0 ;
9786 wxLogChain *result;
9787 PyObject * obj0 = 0 ;
9788 char *kwnames[] = {
9789 (char *) "logger", NULL
9790 };
9791
9792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9794 if (SWIG_arg_fail(1)) SWIG_fail;
9795 {
9796 PyThreadState* __tstate = wxPyBeginAllowThreads();
9797 result = (wxLogChain *)new wxLogChain(arg1);
9798
9799 wxPyEndAllowThreads(__tstate);
9800 if (PyErr_Occurred()) SWIG_fail;
9801 }
9802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9803 return resultobj;
9804 fail:
9805 return NULL;
9806 }
9807
9808
9809 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9810 PyObject *resultobj;
9811 wxLogChain *arg1 = (wxLogChain *) 0 ;
9812 wxLog *arg2 = (wxLog *) 0 ;
9813 PyObject * obj0 = 0 ;
9814 PyObject * obj1 = 0 ;
9815 char *kwnames[] = {
9816 (char *) "self",(char *) "logger", NULL
9817 };
9818
9819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9821 if (SWIG_arg_fail(1)) SWIG_fail;
9822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9823 if (SWIG_arg_fail(2)) SWIG_fail;
9824 {
9825 PyThreadState* __tstate = wxPyBeginAllowThreads();
9826 (arg1)->SetLog(arg2);
9827
9828 wxPyEndAllowThreads(__tstate);
9829 if (PyErr_Occurred()) SWIG_fail;
9830 }
9831 Py_INCREF(Py_None); resultobj = Py_None;
9832 return resultobj;
9833 fail:
9834 return NULL;
9835 }
9836
9837
9838 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9839 PyObject *resultobj;
9840 wxLogChain *arg1 = (wxLogChain *) 0 ;
9841 bool arg2 ;
9842 PyObject * obj0 = 0 ;
9843 PyObject * obj1 = 0 ;
9844 char *kwnames[] = {
9845 (char *) "self",(char *) "bDoPass", NULL
9846 };
9847
9848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9850 if (SWIG_arg_fail(1)) SWIG_fail;
9851 {
9852 arg2 = (bool)(SWIG_As_bool(obj1));
9853 if (SWIG_arg_fail(2)) SWIG_fail;
9854 }
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 (arg1)->PassMessages(arg2);
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 Py_INCREF(Py_None); resultobj = Py_None;
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj;
9871 wxLogChain *arg1 = (wxLogChain *) 0 ;
9872 bool result;
9873 PyObject * obj0 = 0 ;
9874 char *kwnames[] = {
9875 (char *) "self", NULL
9876 };
9877
9878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9880 if (SWIG_arg_fail(1)) SWIG_fail;
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (bool)(arg1)->IsPassingMessages();
9884
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9890 }
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj;
9899 wxLogChain *arg1 = (wxLogChain *) 0 ;
9900 wxLog *result;
9901 PyObject * obj0 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = (wxLog *)(arg1)->GetOldLog();
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9917 return resultobj;
9918 fail:
9919 return NULL;
9920 }
9921
9922
9923 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9924 PyObject *obj;
9925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9926 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9927 Py_INCREF(obj);
9928 return Py_BuildValue((char *)"");
9929 }
9930 static PyObject *_wrap_new_LogBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
9931 PyObject *resultobj;
9932 wxLogBuffer *result;
9933 char *kwnames[] = {
9934 NULL
9935 };
9936
9937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogBuffer",kwnames)) goto fail;
9938 {
9939 PyThreadState* __tstate = wxPyBeginAllowThreads();
9940 result = (wxLogBuffer *)new wxLogBuffer();
9941
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogBuffer, 1);
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 static PyObject *_wrap_LogBuffer_GetBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj;
9954 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
9955 wxString *result;
9956 PyObject * obj0 = 0 ;
9957 char *kwnames[] = {
9958 (char *) "self", NULL
9959 };
9960
9961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_GetBuffer",kwnames,&obj0)) goto fail;
9962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
9963 if (SWIG_arg_fail(1)) SWIG_fail;
9964 {
9965 PyThreadState* __tstate = wxPyBeginAllowThreads();
9966 {
9967 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
9968 result = (wxString *) &_result_ref;
9969 }
9970
9971 wxPyEndAllowThreads(__tstate);
9972 if (PyErr_Occurred()) SWIG_fail;
9973 }
9974 {
9975 #if wxUSE_UNICODE
9976 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9977 #else
9978 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9979 #endif
9980 }
9981 return resultobj;
9982 fail:
9983 return NULL;
9984 }
9985
9986
9987 static PyObject *_wrap_LogBuffer_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9988 PyObject *resultobj;
9989 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
9990 PyObject * obj0 = 0 ;
9991 char *kwnames[] = {
9992 (char *) "self", NULL
9993 };
9994
9995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_Flush",kwnames,&obj0)) goto fail;
9996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
9997 if (SWIG_arg_fail(1)) SWIG_fail;
9998 {
9999 PyThreadState* __tstate = wxPyBeginAllowThreads();
10000 (arg1)->Flush();
10001
10002 wxPyEndAllowThreads(__tstate);
10003 if (PyErr_Occurred()) SWIG_fail;
10004 }
10005 Py_INCREF(Py_None); resultobj = Py_None;
10006 return resultobj;
10007 fail:
10008 return NULL;
10009 }
10010
10011
10012 static PyObject * LogBuffer_swigregister(PyObject *, PyObject *args) {
10013 PyObject *obj;
10014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10015 SWIG_TypeClientData(SWIGTYPE_p_wxLogBuffer, obj);
10016 Py_INCREF(obj);
10017 return Py_BuildValue((char *)"");
10018 }
10019 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10020 PyObject *resultobj;
10021 unsigned long result;
10022 char *kwnames[] = {
10023 NULL
10024 };
10025
10026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10027 {
10028 PyThreadState* __tstate = wxPyBeginAllowThreads();
10029 result = (unsigned long)wxSysErrorCode();
10030
10031 wxPyEndAllowThreads(__tstate);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 {
10035 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10036 }
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10044 PyObject *resultobj;
10045 unsigned long arg1 = (unsigned long) 0 ;
10046 wxString result;
10047 PyObject * obj0 = 0 ;
10048 char *kwnames[] = {
10049 (char *) "nErrCode", NULL
10050 };
10051
10052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10053 if (obj0) {
10054 {
10055 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10056 if (SWIG_arg_fail(1)) SWIG_fail;
10057 }
10058 }
10059 {
10060 PyThreadState* __tstate = wxPyBeginAllowThreads();
10061 result = wxSysErrorMsg(arg1);
10062
10063 wxPyEndAllowThreads(__tstate);
10064 if (PyErr_Occurred()) SWIG_fail;
10065 }
10066 {
10067 #if wxUSE_UNICODE
10068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10069 #else
10070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10071 #endif
10072 }
10073 return resultobj;
10074 fail:
10075 return NULL;
10076 }
10077
10078
10079 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj;
10081 wxString *arg1 = 0 ;
10082 bool temp1 = false ;
10083 PyObject * obj0 = 0 ;
10084 char *kwnames[] = {
10085 (char *) "msg", NULL
10086 };
10087
10088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10089 {
10090 arg1 = wxString_in_helper(obj0);
10091 if (arg1 == NULL) SWIG_fail;
10092 temp1 = true;
10093 }
10094 {
10095 PyThreadState* __tstate = wxPyBeginAllowThreads();
10096 wxPyLogFatalError((wxString const &)*arg1);
10097
10098 wxPyEndAllowThreads(__tstate);
10099 if (PyErr_Occurred()) SWIG_fail;
10100 }
10101 Py_INCREF(Py_None); resultobj = Py_None;
10102 {
10103 if (temp1)
10104 delete arg1;
10105 }
10106 return resultobj;
10107 fail:
10108 {
10109 if (temp1)
10110 delete arg1;
10111 }
10112 return NULL;
10113 }
10114
10115
10116 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10117 PyObject *resultobj;
10118 wxString *arg1 = 0 ;
10119 bool temp1 = false ;
10120 PyObject * obj0 = 0 ;
10121 char *kwnames[] = {
10122 (char *) "msg", NULL
10123 };
10124
10125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10126 {
10127 arg1 = wxString_in_helper(obj0);
10128 if (arg1 == NULL) SWIG_fail;
10129 temp1 = true;
10130 }
10131 {
10132 PyThreadState* __tstate = wxPyBeginAllowThreads();
10133 wxPyLogError((wxString const &)*arg1);
10134
10135 wxPyEndAllowThreads(__tstate);
10136 if (PyErr_Occurred()) SWIG_fail;
10137 }
10138 Py_INCREF(Py_None); resultobj = Py_None;
10139 {
10140 if (temp1)
10141 delete arg1;
10142 }
10143 return resultobj;
10144 fail:
10145 {
10146 if (temp1)
10147 delete arg1;
10148 }
10149 return NULL;
10150 }
10151
10152
10153 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj;
10155 wxString *arg1 = 0 ;
10156 bool temp1 = false ;
10157 PyObject * obj0 = 0 ;
10158 char *kwnames[] = {
10159 (char *) "msg", NULL
10160 };
10161
10162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10163 {
10164 arg1 = wxString_in_helper(obj0);
10165 if (arg1 == NULL) SWIG_fail;
10166 temp1 = true;
10167 }
10168 {
10169 PyThreadState* __tstate = wxPyBeginAllowThreads();
10170 wxPyLogWarning((wxString const &)*arg1);
10171
10172 wxPyEndAllowThreads(__tstate);
10173 if (PyErr_Occurred()) SWIG_fail;
10174 }
10175 Py_INCREF(Py_None); resultobj = Py_None;
10176 {
10177 if (temp1)
10178 delete arg1;
10179 }
10180 return resultobj;
10181 fail:
10182 {
10183 if (temp1)
10184 delete arg1;
10185 }
10186 return NULL;
10187 }
10188
10189
10190 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10191 PyObject *resultobj;
10192 wxString *arg1 = 0 ;
10193 bool temp1 = false ;
10194 PyObject * obj0 = 0 ;
10195 char *kwnames[] = {
10196 (char *) "msg", NULL
10197 };
10198
10199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10200 {
10201 arg1 = wxString_in_helper(obj0);
10202 if (arg1 == NULL) SWIG_fail;
10203 temp1 = true;
10204 }
10205 {
10206 PyThreadState* __tstate = wxPyBeginAllowThreads();
10207 wxPyLogMessage((wxString const &)*arg1);
10208
10209 wxPyEndAllowThreads(__tstate);
10210 if (PyErr_Occurred()) SWIG_fail;
10211 }
10212 Py_INCREF(Py_None); resultobj = Py_None;
10213 {
10214 if (temp1)
10215 delete arg1;
10216 }
10217 return resultobj;
10218 fail:
10219 {
10220 if (temp1)
10221 delete arg1;
10222 }
10223 return NULL;
10224 }
10225
10226
10227 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj;
10229 wxString *arg1 = 0 ;
10230 bool temp1 = false ;
10231 PyObject * obj0 = 0 ;
10232 char *kwnames[] = {
10233 (char *) "msg", NULL
10234 };
10235
10236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10237 {
10238 arg1 = wxString_in_helper(obj0);
10239 if (arg1 == NULL) SWIG_fail;
10240 temp1 = true;
10241 }
10242 {
10243 PyThreadState* __tstate = wxPyBeginAllowThreads();
10244 wxPyLogInfo((wxString const &)*arg1);
10245
10246 wxPyEndAllowThreads(__tstate);
10247 if (PyErr_Occurred()) SWIG_fail;
10248 }
10249 Py_INCREF(Py_None); resultobj = Py_None;
10250 {
10251 if (temp1)
10252 delete arg1;
10253 }
10254 return resultobj;
10255 fail:
10256 {
10257 if (temp1)
10258 delete arg1;
10259 }
10260 return NULL;
10261 }
10262
10263
10264 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10265 PyObject *resultobj;
10266 wxString *arg1 = 0 ;
10267 bool temp1 = false ;
10268 PyObject * obj0 = 0 ;
10269 char *kwnames[] = {
10270 (char *) "msg", NULL
10271 };
10272
10273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10274 {
10275 arg1 = wxString_in_helper(obj0);
10276 if (arg1 == NULL) SWIG_fail;
10277 temp1 = true;
10278 }
10279 {
10280 PyThreadState* __tstate = wxPyBeginAllowThreads();
10281 wxPyLogDebug((wxString const &)*arg1);
10282
10283 wxPyEndAllowThreads(__tstate);
10284 if (PyErr_Occurred()) SWIG_fail;
10285 }
10286 Py_INCREF(Py_None); resultobj = Py_None;
10287 {
10288 if (temp1)
10289 delete arg1;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp1)
10295 delete arg1;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj;
10303 wxString *arg1 = 0 ;
10304 bool temp1 = false ;
10305 PyObject * obj0 = 0 ;
10306 char *kwnames[] = {
10307 (char *) "msg", NULL
10308 };
10309
10310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10311 {
10312 arg1 = wxString_in_helper(obj0);
10313 if (arg1 == NULL) SWIG_fail;
10314 temp1 = true;
10315 }
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 wxPyLogVerbose((wxString const &)*arg1);
10319
10320 wxPyEndAllowThreads(__tstate);
10321 if (PyErr_Occurred()) SWIG_fail;
10322 }
10323 Py_INCREF(Py_None); resultobj = Py_None;
10324 {
10325 if (temp1)
10326 delete arg1;
10327 }
10328 return resultobj;
10329 fail:
10330 {
10331 if (temp1)
10332 delete arg1;
10333 }
10334 return NULL;
10335 }
10336
10337
10338 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10339 PyObject *resultobj;
10340 wxString *arg1 = 0 ;
10341 bool temp1 = false ;
10342 PyObject * obj0 = 0 ;
10343 char *kwnames[] = {
10344 (char *) "msg", NULL
10345 };
10346
10347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10348 {
10349 arg1 = wxString_in_helper(obj0);
10350 if (arg1 == NULL) SWIG_fail;
10351 temp1 = true;
10352 }
10353 {
10354 PyThreadState* __tstate = wxPyBeginAllowThreads();
10355 wxPyLogStatus((wxString const &)*arg1);
10356
10357 wxPyEndAllowThreads(__tstate);
10358 if (PyErr_Occurred()) SWIG_fail;
10359 }
10360 Py_INCREF(Py_None); resultobj = Py_None;
10361 {
10362 if (temp1)
10363 delete arg1;
10364 }
10365 return resultobj;
10366 fail:
10367 {
10368 if (temp1)
10369 delete arg1;
10370 }
10371 return NULL;
10372 }
10373
10374
10375 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10376 PyObject *resultobj;
10377 wxFrame *arg1 = (wxFrame *) 0 ;
10378 wxString *arg2 = 0 ;
10379 bool temp2 = false ;
10380 PyObject * obj0 = 0 ;
10381 PyObject * obj1 = 0 ;
10382 char *kwnames[] = {
10383 (char *) "pFrame",(char *) "msg", NULL
10384 };
10385
10386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10388 if (SWIG_arg_fail(1)) SWIG_fail;
10389 {
10390 arg2 = wxString_in_helper(obj1);
10391 if (arg2 == NULL) SWIG_fail;
10392 temp2 = true;
10393 }
10394 {
10395 PyThreadState* __tstate = wxPyBeginAllowThreads();
10396 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10397
10398 wxPyEndAllowThreads(__tstate);
10399 if (PyErr_Occurred()) SWIG_fail;
10400 }
10401 Py_INCREF(Py_None); resultobj = Py_None;
10402 {
10403 if (temp2)
10404 delete arg2;
10405 }
10406 return resultobj;
10407 fail:
10408 {
10409 if (temp2)
10410 delete arg2;
10411 }
10412 return NULL;
10413 }
10414
10415
10416 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10417 PyObject *resultobj;
10418 wxString *arg1 = 0 ;
10419 bool temp1 = false ;
10420 PyObject * obj0 = 0 ;
10421 char *kwnames[] = {
10422 (char *) "msg", NULL
10423 };
10424
10425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10426 {
10427 arg1 = wxString_in_helper(obj0);
10428 if (arg1 == NULL) SWIG_fail;
10429 temp1 = true;
10430 }
10431 {
10432 PyThreadState* __tstate = wxPyBeginAllowThreads();
10433 wxPyLogSysError((wxString const &)*arg1);
10434
10435 wxPyEndAllowThreads(__tstate);
10436 if (PyErr_Occurred()) SWIG_fail;
10437 }
10438 Py_INCREF(Py_None); resultobj = Py_None;
10439 {
10440 if (temp1)
10441 delete arg1;
10442 }
10443 return resultobj;
10444 fail:
10445 {
10446 if (temp1)
10447 delete arg1;
10448 }
10449 return NULL;
10450 }
10451
10452
10453 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10454 PyObject *resultobj;
10455 unsigned long arg1 ;
10456 wxString *arg2 = 0 ;
10457 bool temp2 = false ;
10458 PyObject * obj0 = 0 ;
10459 PyObject * obj1 = 0 ;
10460 char *kwnames[] = {
10461 (char *) "level",(char *) "msg", NULL
10462 };
10463
10464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10465 {
10466 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10467 if (SWIG_arg_fail(1)) SWIG_fail;
10468 }
10469 {
10470 arg2 = wxString_in_helper(obj1);
10471 if (arg2 == NULL) SWIG_fail;
10472 temp2 = true;
10473 }
10474 {
10475 PyThreadState* __tstate = wxPyBeginAllowThreads();
10476 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10477
10478 wxPyEndAllowThreads(__tstate);
10479 if (PyErr_Occurred()) SWIG_fail;
10480 }
10481 Py_INCREF(Py_None); resultobj = Py_None;
10482 {
10483 if (temp2)
10484 delete arg2;
10485 }
10486 return resultobj;
10487 fail:
10488 {
10489 if (temp2)
10490 delete arg2;
10491 }
10492 return NULL;
10493 }
10494
10495
10496 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10497 PyObject *resultobj;
10498 unsigned long arg1 ;
10499 wxString *arg2 = 0 ;
10500 bool temp2 = false ;
10501 PyObject * obj0 = 0 ;
10502 PyObject * obj1 = 0 ;
10503
10504 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10505 {
10506 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10507 if (SWIG_arg_fail(1)) SWIG_fail;
10508 }
10509 {
10510 arg2 = wxString_in_helper(obj1);
10511 if (arg2 == NULL) SWIG_fail;
10512 temp2 = true;
10513 }
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 wxPyLogTrace(arg1,(wxString const &)*arg2);
10517
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 Py_INCREF(Py_None); resultobj = Py_None;
10522 {
10523 if (temp2)
10524 delete arg2;
10525 }
10526 return resultobj;
10527 fail:
10528 {
10529 if (temp2)
10530 delete arg2;
10531 }
10532 return NULL;
10533 }
10534
10535
10536 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10537 PyObject *resultobj;
10538 wxString *arg1 = 0 ;
10539 wxString *arg2 = 0 ;
10540 bool temp1 = false ;
10541 bool temp2 = false ;
10542 PyObject * obj0 = 0 ;
10543 PyObject * obj1 = 0 ;
10544
10545 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10546 {
10547 arg1 = wxString_in_helper(obj0);
10548 if (arg1 == NULL) SWIG_fail;
10549 temp1 = true;
10550 }
10551 {
10552 arg2 = wxString_in_helper(obj1);
10553 if (arg2 == NULL) SWIG_fail;
10554 temp2 = true;
10555 }
10556 {
10557 PyThreadState* __tstate = wxPyBeginAllowThreads();
10558 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10559
10560 wxPyEndAllowThreads(__tstate);
10561 if (PyErr_Occurred()) SWIG_fail;
10562 }
10563 Py_INCREF(Py_None); resultobj = Py_None;
10564 {
10565 if (temp1)
10566 delete arg1;
10567 }
10568 {
10569 if (temp2)
10570 delete arg2;
10571 }
10572 return resultobj;
10573 fail:
10574 {
10575 if (temp1)
10576 delete arg1;
10577 }
10578 {
10579 if (temp2)
10580 delete arg2;
10581 }
10582 return NULL;
10583 }
10584
10585
10586 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10587 int argc;
10588 PyObject *argv[3];
10589 int ii;
10590
10591 argc = PyObject_Length(args);
10592 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10593 argv[ii] = PyTuple_GetItem(args,ii);
10594 }
10595 if (argc == 2) {
10596 int _v;
10597 {
10598 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10599 }
10600 if (_v) {
10601 {
10602 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10603 }
10604 if (_v) {
10605 return _wrap_LogTrace__SWIG_1(self,args);
10606 }
10607 }
10608 }
10609 if (argc == 2) {
10610 int _v;
10611 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10612 if (_v) {
10613 {
10614 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10615 }
10616 if (_v) {
10617 return _wrap_LogTrace__SWIG_0(self,args);
10618 }
10619 }
10620 }
10621
10622 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10623 return NULL;
10624 }
10625
10626
10627 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10628 PyObject *resultobj;
10629 wxString *arg1 = 0 ;
10630 wxString *arg2 = 0 ;
10631 bool temp1 = false ;
10632 bool temp2 = false ;
10633 PyObject * obj0 = 0 ;
10634 PyObject * obj1 = 0 ;
10635 char *kwnames[] = {
10636 (char *) "title",(char *) "text", NULL
10637 };
10638
10639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10640 {
10641 arg1 = wxString_in_helper(obj0);
10642 if (arg1 == NULL) SWIG_fail;
10643 temp1 = true;
10644 }
10645 {
10646 arg2 = wxString_in_helper(obj1);
10647 if (arg2 == NULL) SWIG_fail;
10648 temp2 = true;
10649 }
10650 {
10651 PyThreadState* __tstate = wxPyBeginAllowThreads();
10652 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10653
10654 wxPyEndAllowThreads(__tstate);
10655 if (PyErr_Occurred()) SWIG_fail;
10656 }
10657 Py_INCREF(Py_None); resultobj = Py_None;
10658 {
10659 if (temp1)
10660 delete arg1;
10661 }
10662 {
10663 if (temp2)
10664 delete arg2;
10665 }
10666 return resultobj;
10667 fail:
10668 {
10669 if (temp1)
10670 delete arg1;
10671 }
10672 {
10673 if (temp2)
10674 delete arg2;
10675 }
10676 return NULL;
10677 }
10678
10679
10680 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj;
10682 wxLogNull *result;
10683 char *kwnames[] = {
10684 NULL
10685 };
10686
10687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10688 {
10689 PyThreadState* __tstate = wxPyBeginAllowThreads();
10690 result = (wxLogNull *)new wxLogNull();
10691
10692 wxPyEndAllowThreads(__tstate);
10693 if (PyErr_Occurred()) SWIG_fail;
10694 }
10695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10696 return resultobj;
10697 fail:
10698 return NULL;
10699 }
10700
10701
10702 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10703 PyObject *resultobj;
10704 wxLogNull *arg1 = (wxLogNull *) 0 ;
10705 PyObject * obj0 = 0 ;
10706 char *kwnames[] = {
10707 (char *) "self", NULL
10708 };
10709
10710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10712 if (SWIG_arg_fail(1)) SWIG_fail;
10713 {
10714 PyThreadState* __tstate = wxPyBeginAllowThreads();
10715 delete arg1;
10716
10717 wxPyEndAllowThreads(__tstate);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 Py_INCREF(Py_None); resultobj = Py_None;
10721 return resultobj;
10722 fail:
10723 return NULL;
10724 }
10725
10726
10727 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10728 PyObject *obj;
10729 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10730 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10731 Py_INCREF(obj);
10732 return Py_BuildValue((char *)"");
10733 }
10734 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10735 PyObject *resultobj;
10736 wxPyLog *result;
10737 char *kwnames[] = {
10738 NULL
10739 };
10740
10741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (wxPyLog *)new wxPyLog();
10745
10746 wxPyEndAllowThreads(__tstate);
10747 if (PyErr_Occurred()) SWIG_fail;
10748 }
10749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10750 return resultobj;
10751 fail:
10752 return NULL;
10753 }
10754
10755
10756 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10757 PyObject *resultobj;
10758 wxPyLog *arg1 = (wxPyLog *) 0 ;
10759 PyObject *arg2 = (PyObject *) 0 ;
10760 PyObject *arg3 = (PyObject *) 0 ;
10761 PyObject * obj0 = 0 ;
10762 PyObject * obj1 = 0 ;
10763 PyObject * obj2 = 0 ;
10764 char *kwnames[] = {
10765 (char *) "self",(char *) "self",(char *) "_class", NULL
10766 };
10767
10768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10770 if (SWIG_arg_fail(1)) SWIG_fail;
10771 arg2 = obj1;
10772 arg3 = obj2;
10773 {
10774 PyThreadState* __tstate = wxPyBeginAllowThreads();
10775 (arg1)->_setCallbackInfo(arg2,arg3);
10776
10777 wxPyEndAllowThreads(__tstate);
10778 if (PyErr_Occurred()) SWIG_fail;
10779 }
10780 Py_INCREF(Py_None); resultobj = Py_None;
10781 return resultobj;
10782 fail:
10783 return NULL;
10784 }
10785
10786
10787 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10788 PyObject *obj;
10789 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10790 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10791 Py_INCREF(obj);
10792 return Py_BuildValue((char *)"");
10793 }
10794 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10795 PyObject *resultobj;
10796 int arg1 ;
10797 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10798 int arg3 = (int) wxKILL_NOCHILDREN ;
10799 wxKillError result;
10800 PyObject * obj0 = 0 ;
10801 PyObject * obj1 = 0 ;
10802 PyObject * obj2 = 0 ;
10803 char *kwnames[] = {
10804 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10805 };
10806
10807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10808 {
10809 arg1 = (int)(SWIG_As_int(obj0));
10810 if (SWIG_arg_fail(1)) SWIG_fail;
10811 }
10812 if (obj1) {
10813 {
10814 arg2 = (wxSignal)(SWIG_As_int(obj1));
10815 if (SWIG_arg_fail(2)) SWIG_fail;
10816 }
10817 }
10818 if (obj2) {
10819 {
10820 arg3 = (int)(SWIG_As_int(obj2));
10821 if (SWIG_arg_fail(3)) SWIG_fail;
10822 }
10823 }
10824 {
10825 PyThreadState* __tstate = wxPyBeginAllowThreads();
10826 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10827
10828 wxPyEndAllowThreads(__tstate);
10829 if (PyErr_Occurred()) SWIG_fail;
10830 }
10831 resultobj = SWIG_From_int((result));
10832 return resultobj;
10833 fail:
10834 return NULL;
10835 }
10836
10837
10838 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10839 PyObject *resultobj;
10840 int arg1 ;
10841 bool result;
10842 PyObject * obj0 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "pid", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10848 {
10849 arg1 = (int)(SWIG_As_int(obj0));
10850 if (SWIG_arg_fail(1)) SWIG_fail;
10851 }
10852 {
10853 PyThreadState* __tstate = wxPyBeginAllowThreads();
10854 result = (bool)wxPyProcess::Exists(arg1);
10855
10856 wxPyEndAllowThreads(__tstate);
10857 if (PyErr_Occurred()) SWIG_fail;
10858 }
10859 {
10860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10861 }
10862 return resultobj;
10863 fail:
10864 return NULL;
10865 }
10866
10867
10868 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10869 PyObject *resultobj;
10870 wxString *arg1 = 0 ;
10871 int arg2 = (int) wxEXEC_ASYNC ;
10872 wxPyProcess *result;
10873 bool temp1 = false ;
10874 PyObject * obj0 = 0 ;
10875 PyObject * obj1 = 0 ;
10876 char *kwnames[] = {
10877 (char *) "cmd",(char *) "flags", NULL
10878 };
10879
10880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10881 {
10882 arg1 = wxString_in_helper(obj0);
10883 if (arg1 == NULL) SWIG_fail;
10884 temp1 = true;
10885 }
10886 if (obj1) {
10887 {
10888 arg2 = (int)(SWIG_As_int(obj1));
10889 if (SWIG_arg_fail(2)) SWIG_fail;
10890 }
10891 }
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10895
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10900 {
10901 if (temp1)
10902 delete arg1;
10903 }
10904 return resultobj;
10905 fail:
10906 {
10907 if (temp1)
10908 delete arg1;
10909 }
10910 return NULL;
10911 }
10912
10913
10914 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj;
10916 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10917 int arg2 = (int) -1 ;
10918 wxPyProcess *result;
10919 PyObject * obj0 = 0 ;
10920 PyObject * obj1 = 0 ;
10921 char *kwnames[] = {
10922 (char *) "parent",(char *) "id", NULL
10923 };
10924
10925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10926 if (obj0) {
10927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10928 if (SWIG_arg_fail(1)) SWIG_fail;
10929 }
10930 if (obj1) {
10931 {
10932 arg2 = (int)(SWIG_As_int(obj1));
10933 if (SWIG_arg_fail(2)) SWIG_fail;
10934 }
10935 }
10936 {
10937 PyThreadState* __tstate = wxPyBeginAllowThreads();
10938 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10939
10940 wxPyEndAllowThreads(__tstate);
10941 if (PyErr_Occurred()) SWIG_fail;
10942 }
10943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10944 return resultobj;
10945 fail:
10946 return NULL;
10947 }
10948
10949
10950 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10951 PyObject *resultobj;
10952 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10953 PyObject *arg2 = (PyObject *) 0 ;
10954 PyObject *arg3 = (PyObject *) 0 ;
10955 PyObject * obj0 = 0 ;
10956 PyObject * obj1 = 0 ;
10957 PyObject * obj2 = 0 ;
10958 char *kwnames[] = {
10959 (char *) "self",(char *) "self",(char *) "_class", NULL
10960 };
10961
10962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10964 if (SWIG_arg_fail(1)) SWIG_fail;
10965 arg2 = obj1;
10966 arg3 = obj2;
10967 {
10968 PyThreadState* __tstate = wxPyBeginAllowThreads();
10969 (arg1)->_setCallbackInfo(arg2,arg3);
10970
10971 wxPyEndAllowThreads(__tstate);
10972 if (PyErr_Occurred()) SWIG_fail;
10973 }
10974 Py_INCREF(Py_None); resultobj = Py_None;
10975 return resultobj;
10976 fail:
10977 return NULL;
10978 }
10979
10980
10981 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10982 PyObject *resultobj;
10983 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10984 int arg2 ;
10985 int arg3 ;
10986 PyObject * obj0 = 0 ;
10987 PyObject * obj1 = 0 ;
10988 PyObject * obj2 = 0 ;
10989 char *kwnames[] = {
10990 (char *) "self",(char *) "pid",(char *) "status", NULL
10991 };
10992
10993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10995 if (SWIG_arg_fail(1)) SWIG_fail;
10996 {
10997 arg2 = (int)(SWIG_As_int(obj1));
10998 if (SWIG_arg_fail(2)) SWIG_fail;
10999 }
11000 {
11001 arg3 = (int)(SWIG_As_int(obj2));
11002 if (SWIG_arg_fail(3)) SWIG_fail;
11003 }
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 (arg1)->base_OnTerminate(arg2,arg3);
11007
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 Py_INCREF(Py_None); resultobj = Py_None;
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11019 PyObject *resultobj;
11020 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11021 PyObject * obj0 = 0 ;
11022 char *kwnames[] = {
11023 (char *) "self", NULL
11024 };
11025
11026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11028 if (SWIG_arg_fail(1)) SWIG_fail;
11029 {
11030 PyThreadState* __tstate = wxPyBeginAllowThreads();
11031 (arg1)->Redirect();
11032
11033 wxPyEndAllowThreads(__tstate);
11034 if (PyErr_Occurred()) SWIG_fail;
11035 }
11036 Py_INCREF(Py_None); resultobj = Py_None;
11037 return resultobj;
11038 fail:
11039 return NULL;
11040 }
11041
11042
11043 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj;
11045 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11046 bool result;
11047 PyObject * obj0 = 0 ;
11048 char *kwnames[] = {
11049 (char *) "self", NULL
11050 };
11051
11052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11054 if (SWIG_arg_fail(1)) SWIG_fail;
11055 {
11056 PyThreadState* __tstate = wxPyBeginAllowThreads();
11057 result = (bool)(arg1)->IsRedirected();
11058
11059 wxPyEndAllowThreads(__tstate);
11060 if (PyErr_Occurred()) SWIG_fail;
11061 }
11062 {
11063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11064 }
11065 return resultobj;
11066 fail:
11067 return NULL;
11068 }
11069
11070
11071 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11072 PyObject *resultobj;
11073 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11074 PyObject * obj0 = 0 ;
11075 char *kwnames[] = {
11076 (char *) "self", NULL
11077 };
11078
11079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11081 if (SWIG_arg_fail(1)) SWIG_fail;
11082 {
11083 PyThreadState* __tstate = wxPyBeginAllowThreads();
11084 (arg1)->Detach();
11085
11086 wxPyEndAllowThreads(__tstate);
11087 if (PyErr_Occurred()) SWIG_fail;
11088 }
11089 Py_INCREF(Py_None); resultobj = Py_None;
11090 return resultobj;
11091 fail:
11092 return NULL;
11093 }
11094
11095
11096 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11097 PyObject *resultobj;
11098 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11099 wxInputStream *result;
11100 PyObject * obj0 = 0 ;
11101 char *kwnames[] = {
11102 (char *) "self", NULL
11103 };
11104
11105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11107 if (SWIG_arg_fail(1)) SWIG_fail;
11108 {
11109 PyThreadState* __tstate = wxPyBeginAllowThreads();
11110 result = (wxInputStream *)(arg1)->GetInputStream();
11111
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 {
11116 wxPyInputStream * _ptr = NULL;
11117
11118 if (result) {
11119 _ptr = new wxPyInputStream(result);
11120 }
11121 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11122 }
11123 return resultobj;
11124 fail:
11125 return NULL;
11126 }
11127
11128
11129 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11130 PyObject *resultobj;
11131 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11132 wxInputStream *result;
11133 PyObject * obj0 = 0 ;
11134 char *kwnames[] = {
11135 (char *) "self", NULL
11136 };
11137
11138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11140 if (SWIG_arg_fail(1)) SWIG_fail;
11141 {
11142 PyThreadState* __tstate = wxPyBeginAllowThreads();
11143 result = (wxInputStream *)(arg1)->GetErrorStream();
11144
11145 wxPyEndAllowThreads(__tstate);
11146 if (PyErr_Occurred()) SWIG_fail;
11147 }
11148 {
11149 wxPyInputStream * _ptr = NULL;
11150
11151 if (result) {
11152 _ptr = new wxPyInputStream(result);
11153 }
11154 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11155 }
11156 return resultobj;
11157 fail:
11158 return NULL;
11159 }
11160
11161
11162 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11163 PyObject *resultobj;
11164 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11165 wxOutputStream *result;
11166 PyObject * obj0 = 0 ;
11167 char *kwnames[] = {
11168 (char *) "self", NULL
11169 };
11170
11171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11173 if (SWIG_arg_fail(1)) SWIG_fail;
11174 {
11175 PyThreadState* __tstate = wxPyBeginAllowThreads();
11176 result = (wxOutputStream *)(arg1)->GetOutputStream();
11177
11178 wxPyEndAllowThreads(__tstate);
11179 if (PyErr_Occurred()) SWIG_fail;
11180 }
11181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11189 PyObject *resultobj;
11190 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11191 PyObject * obj0 = 0 ;
11192 char *kwnames[] = {
11193 (char *) "self", NULL
11194 };
11195
11196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11198 if (SWIG_arg_fail(1)) SWIG_fail;
11199 {
11200 PyThreadState* __tstate = wxPyBeginAllowThreads();
11201 (arg1)->CloseOutput();
11202
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 Py_INCREF(Py_None); resultobj = Py_None;
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11214 PyObject *resultobj;
11215 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11216 bool result;
11217 PyObject * obj0 = 0 ;
11218 char *kwnames[] = {
11219 (char *) "self", NULL
11220 };
11221
11222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11224 if (SWIG_arg_fail(1)) SWIG_fail;
11225 {
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11228
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 {
11233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11234 }
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj;
11243 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11244 bool result;
11245 PyObject * obj0 = 0 ;
11246 char *kwnames[] = {
11247 (char *) "self", NULL
11248 };
11249
11250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11252 if (SWIG_arg_fail(1)) SWIG_fail;
11253 {
11254 PyThreadState* __tstate = wxPyBeginAllowThreads();
11255 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11256
11257 wxPyEndAllowThreads(__tstate);
11258 if (PyErr_Occurred()) SWIG_fail;
11259 }
11260 {
11261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11262 }
11263 return resultobj;
11264 fail:
11265 return NULL;
11266 }
11267
11268
11269 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11270 PyObject *resultobj;
11271 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11272 bool result;
11273 PyObject * obj0 = 0 ;
11274 char *kwnames[] = {
11275 (char *) "self", NULL
11276 };
11277
11278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11280 if (SWIG_arg_fail(1)) SWIG_fail;
11281 {
11282 PyThreadState* __tstate = wxPyBeginAllowThreads();
11283 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11284
11285 wxPyEndAllowThreads(__tstate);
11286 if (PyErr_Occurred()) SWIG_fail;
11287 }
11288 {
11289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11290 }
11291 return resultobj;
11292 fail:
11293 return NULL;
11294 }
11295
11296
11297 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11298 PyObject *obj;
11299 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11300 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11301 Py_INCREF(obj);
11302 return Py_BuildValue((char *)"");
11303 }
11304 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11305 PyObject *resultobj;
11306 int arg1 = (int) 0 ;
11307 int arg2 = (int) 0 ;
11308 int arg3 = (int) 0 ;
11309 wxProcessEvent *result;
11310 PyObject * obj0 = 0 ;
11311 PyObject * obj1 = 0 ;
11312 PyObject * obj2 = 0 ;
11313 char *kwnames[] = {
11314 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11315 };
11316
11317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11318 if (obj0) {
11319 {
11320 arg1 = (int)(SWIG_As_int(obj0));
11321 if (SWIG_arg_fail(1)) SWIG_fail;
11322 }
11323 }
11324 if (obj1) {
11325 {
11326 arg2 = (int)(SWIG_As_int(obj1));
11327 if (SWIG_arg_fail(2)) SWIG_fail;
11328 }
11329 }
11330 if (obj2) {
11331 {
11332 arg3 = (int)(SWIG_As_int(obj2));
11333 if (SWIG_arg_fail(3)) SWIG_fail;
11334 }
11335 }
11336 {
11337 PyThreadState* __tstate = wxPyBeginAllowThreads();
11338 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11339
11340 wxPyEndAllowThreads(__tstate);
11341 if (PyErr_Occurred()) SWIG_fail;
11342 }
11343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11344 return resultobj;
11345 fail:
11346 return NULL;
11347 }
11348
11349
11350 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11351 PyObject *resultobj;
11352 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11353 int result;
11354 PyObject * obj0 = 0 ;
11355 char *kwnames[] = {
11356 (char *) "self", NULL
11357 };
11358
11359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11361 if (SWIG_arg_fail(1)) SWIG_fail;
11362 {
11363 PyThreadState* __tstate = wxPyBeginAllowThreads();
11364 result = (int)(arg1)->GetPid();
11365
11366 wxPyEndAllowThreads(__tstate);
11367 if (PyErr_Occurred()) SWIG_fail;
11368 }
11369 {
11370 resultobj = SWIG_From_int((int)(result));
11371 }
11372 return resultobj;
11373 fail:
11374 return NULL;
11375 }
11376
11377
11378 static PyObject *_wrap_ProcessEvent_GetExitCode(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_GetExitCode",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 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 result = (int)(arg1)->GetExitCode();
11393
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 {
11398 resultobj = SWIG_From_int((int)(result));
11399 }
11400 return resultobj;
11401 fail:
11402 return NULL;
11403 }
11404
11405
11406 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11407 PyObject *resultobj;
11408 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11409 int arg2 ;
11410 PyObject * obj0 = 0 ;
11411 PyObject * obj1 = 0 ;
11412 char *kwnames[] = {
11413 (char *) "self",(char *) "m_pid", NULL
11414 };
11415
11416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11418 if (SWIG_arg_fail(1)) SWIG_fail;
11419 {
11420 arg2 = (int)(SWIG_As_int(obj1));
11421 if (SWIG_arg_fail(2)) SWIG_fail;
11422 }
11423 if (arg1) (arg1)->m_pid = arg2;
11424
11425 Py_INCREF(Py_None); resultobj = Py_None;
11426 return resultobj;
11427 fail:
11428 return NULL;
11429 }
11430
11431
11432 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11433 PyObject *resultobj;
11434 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11435 int result;
11436 PyObject * obj0 = 0 ;
11437 char *kwnames[] = {
11438 (char *) "self", NULL
11439 };
11440
11441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11443 if (SWIG_arg_fail(1)) SWIG_fail;
11444 result = (int) ((arg1)->m_pid);
11445
11446 {
11447 resultobj = SWIG_From_int((int)(result));
11448 }
11449 return resultobj;
11450 fail:
11451 return NULL;
11452 }
11453
11454
11455 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11456 PyObject *resultobj;
11457 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11458 int arg2 ;
11459 PyObject * obj0 = 0 ;
11460 PyObject * obj1 = 0 ;
11461 char *kwnames[] = {
11462 (char *) "self",(char *) "m_exitcode", NULL
11463 };
11464
11465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11467 if (SWIG_arg_fail(1)) SWIG_fail;
11468 {
11469 arg2 = (int)(SWIG_As_int(obj1));
11470 if (SWIG_arg_fail(2)) SWIG_fail;
11471 }
11472 if (arg1) (arg1)->m_exitcode = arg2;
11473
11474 Py_INCREF(Py_None); resultobj = Py_None;
11475 return resultobj;
11476 fail:
11477 return NULL;
11478 }
11479
11480
11481 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj;
11483 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11484 int result;
11485 PyObject * obj0 = 0 ;
11486 char *kwnames[] = {
11487 (char *) "self", NULL
11488 };
11489
11490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11492 if (SWIG_arg_fail(1)) SWIG_fail;
11493 result = (int) ((arg1)->m_exitcode);
11494
11495 {
11496 resultobj = SWIG_From_int((int)(result));
11497 }
11498 return resultobj;
11499 fail:
11500 return NULL;
11501 }
11502
11503
11504 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11505 PyObject *obj;
11506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11507 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11508 Py_INCREF(obj);
11509 return Py_BuildValue((char *)"");
11510 }
11511 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11512 PyObject *resultobj;
11513 wxString *arg1 = 0 ;
11514 int arg2 = (int) wxEXEC_ASYNC ;
11515 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11516 long result;
11517 bool temp1 = false ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 PyObject * obj2 = 0 ;
11521 char *kwnames[] = {
11522 (char *) "command",(char *) "flags",(char *) "process", NULL
11523 };
11524
11525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11526 {
11527 arg1 = wxString_in_helper(obj0);
11528 if (arg1 == NULL) SWIG_fail;
11529 temp1 = true;
11530 }
11531 if (obj1) {
11532 {
11533 arg2 = (int)(SWIG_As_int(obj1));
11534 if (SWIG_arg_fail(2)) SWIG_fail;
11535 }
11536 }
11537 if (obj2) {
11538 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11539 if (SWIG_arg_fail(3)) SWIG_fail;
11540 }
11541 {
11542 if (!wxPyCheckForApp()) SWIG_fail;
11543 PyThreadState* __tstate = wxPyBeginAllowThreads();
11544 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11545
11546 wxPyEndAllowThreads(__tstate);
11547 if (PyErr_Occurred()) SWIG_fail;
11548 }
11549 {
11550 resultobj = SWIG_From_long((long)(result));
11551 }
11552 {
11553 if (temp1)
11554 delete arg1;
11555 }
11556 return resultobj;
11557 fail:
11558 {
11559 if (temp1)
11560 delete arg1;
11561 }
11562 return NULL;
11563 }
11564
11565
11566 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11567 PyObject *resultobj;
11568 long arg1 ;
11569 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11570 wxKillError *arg3 = (wxKillError *) 0 ;
11571 int arg4 = (int) wxKILL_NOCHILDREN ;
11572 int result;
11573 wxKillError temp3 ;
11574 PyObject * obj0 = 0 ;
11575 PyObject * obj1 = 0 ;
11576 PyObject * obj2 = 0 ;
11577 char *kwnames[] = {
11578 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11579 };
11580
11581 {
11582 arg3 = &temp3;
11583 }
11584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11585 {
11586 arg1 = (long)(SWIG_As_long(obj0));
11587 if (SWIG_arg_fail(1)) SWIG_fail;
11588 }
11589 if (obj1) {
11590 {
11591 arg2 = (wxSignal)(SWIG_As_int(obj1));
11592 if (SWIG_arg_fail(2)) SWIG_fail;
11593 }
11594 }
11595 if (obj2) {
11596 {
11597 arg4 = (int)(SWIG_As_int(obj2));
11598 if (SWIG_arg_fail(4)) SWIG_fail;
11599 }
11600 }
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11604
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 {
11609 resultobj = SWIG_From_int((int)(result));
11610 }
11611 {
11612 PyObject* o;
11613 o = PyInt_FromLong((long) (*arg3));
11614 resultobj = t_output_helper(resultobj, o);
11615 }
11616 return resultobj;
11617 fail:
11618 return NULL;
11619 }
11620
11621
11622 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11623 PyObject *resultobj;
11624 int arg1 = (int) wxJOYSTICK1 ;
11625 wxJoystick *result;
11626 PyObject * obj0 = 0 ;
11627 char *kwnames[] = {
11628 (char *) "joystick", NULL
11629 };
11630
11631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11632 if (obj0) {
11633 {
11634 arg1 = (int)(SWIG_As_int(obj0));
11635 if (SWIG_arg_fail(1)) SWIG_fail;
11636 }
11637 }
11638 {
11639 if (!wxPyCheckForApp()) SWIG_fail;
11640 PyThreadState* __tstate = wxPyBeginAllowThreads();
11641 result = (wxJoystick *)new wxJoystick(arg1);
11642
11643 wxPyEndAllowThreads(__tstate);
11644 if (PyErr_Occurred()) SWIG_fail;
11645 }
11646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11647 return resultobj;
11648 fail:
11649 return NULL;
11650 }
11651
11652
11653 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11654 PyObject *resultobj;
11655 wxJoystick *arg1 = (wxJoystick *) 0 ;
11656 PyObject * obj0 = 0 ;
11657 char *kwnames[] = {
11658 (char *) "self", NULL
11659 };
11660
11661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11663 if (SWIG_arg_fail(1)) SWIG_fail;
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 delete arg1;
11667
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 Py_INCREF(Py_None); resultobj = Py_None;
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11679 PyObject *resultobj;
11680 wxJoystick *arg1 = (wxJoystick *) 0 ;
11681 wxPoint result;
11682 PyObject * obj0 = 0 ;
11683 char *kwnames[] = {
11684 (char *) "self", NULL
11685 };
11686
11687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11689 if (SWIG_arg_fail(1)) SWIG_fail;
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = (arg1)->GetPosition();
11693
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 {
11698 wxPoint * resultptr;
11699 resultptr = new wxPoint((wxPoint &)(result));
11700 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11701 }
11702 return resultobj;
11703 fail:
11704 return NULL;
11705 }
11706
11707
11708 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11709 PyObject *resultobj;
11710 wxJoystick *arg1 = (wxJoystick *) 0 ;
11711 int result;
11712 PyObject * obj0 = 0 ;
11713 char *kwnames[] = {
11714 (char *) "self", NULL
11715 };
11716
11717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11719 if (SWIG_arg_fail(1)) SWIG_fail;
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 result = (int)(arg1)->GetZPosition();
11723
11724 wxPyEndAllowThreads(__tstate);
11725 if (PyErr_Occurred()) SWIG_fail;
11726 }
11727 {
11728 resultobj = SWIG_From_int((int)(result));
11729 }
11730 return resultobj;
11731 fail:
11732 return NULL;
11733 }
11734
11735
11736 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11737 PyObject *resultobj;
11738 wxJoystick *arg1 = (wxJoystick *) 0 ;
11739 int result;
11740 PyObject * obj0 = 0 ;
11741 char *kwnames[] = {
11742 (char *) "self", NULL
11743 };
11744
11745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11747 if (SWIG_arg_fail(1)) SWIG_fail;
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 result = (int)(arg1)->GetButtonState();
11751
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 {
11756 resultobj = SWIG_From_int((int)(result));
11757 }
11758 return resultobj;
11759 fail:
11760 return NULL;
11761 }
11762
11763
11764 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11765 PyObject *resultobj;
11766 wxJoystick *arg1 = (wxJoystick *) 0 ;
11767 int result;
11768 PyObject * obj0 = 0 ;
11769 char *kwnames[] = {
11770 (char *) "self", NULL
11771 };
11772
11773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11775 if (SWIG_arg_fail(1)) SWIG_fail;
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 result = (int)(arg1)->GetPOVPosition();
11779
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 {
11784 resultobj = SWIG_From_int((int)(result));
11785 }
11786 return resultobj;
11787 fail:
11788 return NULL;
11789 }
11790
11791
11792 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11793 PyObject *resultobj;
11794 wxJoystick *arg1 = (wxJoystick *) 0 ;
11795 int result;
11796 PyObject * obj0 = 0 ;
11797 char *kwnames[] = {
11798 (char *) "self", NULL
11799 };
11800
11801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11803 if (SWIG_arg_fail(1)) SWIG_fail;
11804 {
11805 PyThreadState* __tstate = wxPyBeginAllowThreads();
11806 result = (int)(arg1)->GetPOVCTSPosition();
11807
11808 wxPyEndAllowThreads(__tstate);
11809 if (PyErr_Occurred()) SWIG_fail;
11810 }
11811 {
11812 resultobj = SWIG_From_int((int)(result));
11813 }
11814 return resultobj;
11815 fail:
11816 return NULL;
11817 }
11818
11819
11820 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11821 PyObject *resultobj;
11822 wxJoystick *arg1 = (wxJoystick *) 0 ;
11823 int result;
11824 PyObject * obj0 = 0 ;
11825 char *kwnames[] = {
11826 (char *) "self", NULL
11827 };
11828
11829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11831 if (SWIG_arg_fail(1)) SWIG_fail;
11832 {
11833 PyThreadState* __tstate = wxPyBeginAllowThreads();
11834 result = (int)(arg1)->GetRudderPosition();
11835
11836 wxPyEndAllowThreads(__tstate);
11837 if (PyErr_Occurred()) SWIG_fail;
11838 }
11839 {
11840 resultobj = SWIG_From_int((int)(result));
11841 }
11842 return resultobj;
11843 fail:
11844 return NULL;
11845 }
11846
11847
11848 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11849 PyObject *resultobj;
11850 wxJoystick *arg1 = (wxJoystick *) 0 ;
11851 int result;
11852 PyObject * obj0 = 0 ;
11853 char *kwnames[] = {
11854 (char *) "self", NULL
11855 };
11856
11857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11859 if (SWIG_arg_fail(1)) SWIG_fail;
11860 {
11861 PyThreadState* __tstate = wxPyBeginAllowThreads();
11862 result = (int)(arg1)->GetUPosition();
11863
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 {
11868 resultobj = SWIG_From_int((int)(result));
11869 }
11870 return resultobj;
11871 fail:
11872 return NULL;
11873 }
11874
11875
11876 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11877 PyObject *resultobj;
11878 wxJoystick *arg1 = (wxJoystick *) 0 ;
11879 int result;
11880 PyObject * obj0 = 0 ;
11881 char *kwnames[] = {
11882 (char *) "self", NULL
11883 };
11884
11885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11887 if (SWIG_arg_fail(1)) SWIG_fail;
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (int)(arg1)->GetVPosition();
11891
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 {
11896 resultobj = SWIG_From_int((int)(result));
11897 }
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj;
11906 wxJoystick *arg1 = (wxJoystick *) 0 ;
11907 int result;
11908 PyObject * obj0 = 0 ;
11909 char *kwnames[] = {
11910 (char *) "self", NULL
11911 };
11912
11913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11915 if (SWIG_arg_fail(1)) SWIG_fail;
11916 {
11917 PyThreadState* __tstate = wxPyBeginAllowThreads();
11918 result = (int)(arg1)->GetMovementThreshold();
11919
11920 wxPyEndAllowThreads(__tstate);
11921 if (PyErr_Occurred()) SWIG_fail;
11922 }
11923 {
11924 resultobj = SWIG_From_int((int)(result));
11925 }
11926 return resultobj;
11927 fail:
11928 return NULL;
11929 }
11930
11931
11932 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj;
11934 wxJoystick *arg1 = (wxJoystick *) 0 ;
11935 int arg2 ;
11936 PyObject * obj0 = 0 ;
11937 PyObject * obj1 = 0 ;
11938 char *kwnames[] = {
11939 (char *) "self",(char *) "threshold", NULL
11940 };
11941
11942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11944 if (SWIG_arg_fail(1)) SWIG_fail;
11945 {
11946 arg2 = (int)(SWIG_As_int(obj1));
11947 if (SWIG_arg_fail(2)) SWIG_fail;
11948 }
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 (arg1)->SetMovementThreshold(arg2);
11952
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 Py_INCREF(Py_None); resultobj = Py_None;
11957 return resultobj;
11958 fail:
11959 return NULL;
11960 }
11961
11962
11963 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11964 PyObject *resultobj;
11965 wxJoystick *arg1 = (wxJoystick *) 0 ;
11966 bool result;
11967 PyObject * obj0 = 0 ;
11968 char *kwnames[] = {
11969 (char *) "self", NULL
11970 };
11971
11972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11974 if (SWIG_arg_fail(1)) SWIG_fail;
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (bool)(arg1)->IsOk();
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 {
11983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11984 }
11985 return resultobj;
11986 fail:
11987 return NULL;
11988 }
11989
11990
11991 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11992 PyObject *resultobj;
11993 wxJoystick *arg1 = (wxJoystick *) 0 ;
11994 int result;
11995 PyObject * obj0 = 0 ;
11996 char *kwnames[] = {
11997 (char *) "self", NULL
11998 };
11999
12000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12002 if (SWIG_arg_fail(1)) SWIG_fail;
12003 {
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = (int)(arg1)->GetNumberJoysticks();
12006
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 resultobj = SWIG_From_int((int)(result));
12012 }
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12020 PyObject *resultobj;
12021 wxJoystick *arg1 = (wxJoystick *) 0 ;
12022 int result;
12023 PyObject * obj0 = 0 ;
12024 char *kwnames[] = {
12025 (char *) "self", NULL
12026 };
12027
12028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12030 if (SWIG_arg_fail(1)) SWIG_fail;
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = (int)(arg1)->GetManufacturerId();
12034
12035 wxPyEndAllowThreads(__tstate);
12036 if (PyErr_Occurred()) SWIG_fail;
12037 }
12038 {
12039 resultobj = SWIG_From_int((int)(result));
12040 }
12041 return resultobj;
12042 fail:
12043 return NULL;
12044 }
12045
12046
12047 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12048 PyObject *resultobj;
12049 wxJoystick *arg1 = (wxJoystick *) 0 ;
12050 int result;
12051 PyObject * obj0 = 0 ;
12052 char *kwnames[] = {
12053 (char *) "self", NULL
12054 };
12055
12056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12058 if (SWIG_arg_fail(1)) SWIG_fail;
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 result = (int)(arg1)->GetProductId();
12062
12063 wxPyEndAllowThreads(__tstate);
12064 if (PyErr_Occurred()) SWIG_fail;
12065 }
12066 {
12067 resultobj = SWIG_From_int((int)(result));
12068 }
12069 return resultobj;
12070 fail:
12071 return NULL;
12072 }
12073
12074
12075 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12076 PyObject *resultobj;
12077 wxJoystick *arg1 = (wxJoystick *) 0 ;
12078 wxString result;
12079 PyObject * obj0 = 0 ;
12080 char *kwnames[] = {
12081 (char *) "self", NULL
12082 };
12083
12084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12086 if (SWIG_arg_fail(1)) SWIG_fail;
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 result = (arg1)->GetProductName();
12090
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 {
12095 #if wxUSE_UNICODE
12096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12097 #else
12098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12099 #endif
12100 }
12101 return resultobj;
12102 fail:
12103 return NULL;
12104 }
12105
12106
12107 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj;
12109 wxJoystick *arg1 = (wxJoystick *) 0 ;
12110 int result;
12111 PyObject * obj0 = 0 ;
12112 char *kwnames[] = {
12113 (char *) "self", NULL
12114 };
12115
12116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12118 if (SWIG_arg_fail(1)) SWIG_fail;
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = (int)(arg1)->GetXMin();
12122
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 {
12127 resultobj = SWIG_From_int((int)(result));
12128 }
12129 return resultobj;
12130 fail:
12131 return NULL;
12132 }
12133
12134
12135 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12136 PyObject *resultobj;
12137 wxJoystick *arg1 = (wxJoystick *) 0 ;
12138 int result;
12139 PyObject * obj0 = 0 ;
12140 char *kwnames[] = {
12141 (char *) "self", NULL
12142 };
12143
12144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12146 if (SWIG_arg_fail(1)) SWIG_fail;
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 result = (int)(arg1)->GetYMin();
12150
12151 wxPyEndAllowThreads(__tstate);
12152 if (PyErr_Occurred()) SWIG_fail;
12153 }
12154 {
12155 resultobj = SWIG_From_int((int)(result));
12156 }
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj;
12165 wxJoystick *arg1 = (wxJoystick *) 0 ;
12166 int result;
12167 PyObject * obj0 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "self", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 {
12176 PyThreadState* __tstate = wxPyBeginAllowThreads();
12177 result = (int)(arg1)->GetZMin();
12178
12179 wxPyEndAllowThreads(__tstate);
12180 if (PyErr_Occurred()) SWIG_fail;
12181 }
12182 {
12183 resultobj = SWIG_From_int((int)(result));
12184 }
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj;
12193 wxJoystick *arg1 = (wxJoystick *) 0 ;
12194 int result;
12195 PyObject * obj0 = 0 ;
12196 char *kwnames[] = {
12197 (char *) "self", NULL
12198 };
12199
12200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12202 if (SWIG_arg_fail(1)) SWIG_fail;
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 result = (int)(arg1)->GetXMax();
12206
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 {
12211 resultobj = SWIG_From_int((int)(result));
12212 }
12213 return resultobj;
12214 fail:
12215 return NULL;
12216 }
12217
12218
12219 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12220 PyObject *resultobj;
12221 wxJoystick *arg1 = (wxJoystick *) 0 ;
12222 int result;
12223 PyObject * obj0 = 0 ;
12224 char *kwnames[] = {
12225 (char *) "self", NULL
12226 };
12227
12228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12230 if (SWIG_arg_fail(1)) SWIG_fail;
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 result = (int)(arg1)->GetYMax();
12234
12235 wxPyEndAllowThreads(__tstate);
12236 if (PyErr_Occurred()) SWIG_fail;
12237 }
12238 {
12239 resultobj = SWIG_From_int((int)(result));
12240 }
12241 return resultobj;
12242 fail:
12243 return NULL;
12244 }
12245
12246
12247 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12248 PyObject *resultobj;
12249 wxJoystick *arg1 = (wxJoystick *) 0 ;
12250 int result;
12251 PyObject * obj0 = 0 ;
12252 char *kwnames[] = {
12253 (char *) "self", NULL
12254 };
12255
12256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12258 if (SWIG_arg_fail(1)) SWIG_fail;
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 result = (int)(arg1)->GetZMax();
12262
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 {
12267 resultobj = SWIG_From_int((int)(result));
12268 }
12269 return resultobj;
12270 fail:
12271 return NULL;
12272 }
12273
12274
12275 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12276 PyObject *resultobj;
12277 wxJoystick *arg1 = (wxJoystick *) 0 ;
12278 int result;
12279 PyObject * obj0 = 0 ;
12280 char *kwnames[] = {
12281 (char *) "self", NULL
12282 };
12283
12284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12286 if (SWIG_arg_fail(1)) SWIG_fail;
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (int)(arg1)->GetNumberButtons();
12290
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 {
12295 resultobj = SWIG_From_int((int)(result));
12296 }
12297 return resultobj;
12298 fail:
12299 return NULL;
12300 }
12301
12302
12303 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12304 PyObject *resultobj;
12305 wxJoystick *arg1 = (wxJoystick *) 0 ;
12306 int result;
12307 PyObject * obj0 = 0 ;
12308 char *kwnames[] = {
12309 (char *) "self", NULL
12310 };
12311
12312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12314 if (SWIG_arg_fail(1)) SWIG_fail;
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 result = (int)(arg1)->GetNumberAxes();
12318
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 {
12323 resultobj = SWIG_From_int((int)(result));
12324 }
12325 return resultobj;
12326 fail:
12327 return NULL;
12328 }
12329
12330
12331 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12332 PyObject *resultobj;
12333 wxJoystick *arg1 = (wxJoystick *) 0 ;
12334 int result;
12335 PyObject * obj0 = 0 ;
12336 char *kwnames[] = {
12337 (char *) "self", NULL
12338 };
12339
12340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12342 if (SWIG_arg_fail(1)) SWIG_fail;
12343 {
12344 PyThreadState* __tstate = wxPyBeginAllowThreads();
12345 result = (int)(arg1)->GetMaxButtons();
12346
12347 wxPyEndAllowThreads(__tstate);
12348 if (PyErr_Occurred()) SWIG_fail;
12349 }
12350 {
12351 resultobj = SWIG_From_int((int)(result));
12352 }
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj;
12361 wxJoystick *arg1 = (wxJoystick *) 0 ;
12362 int result;
12363 PyObject * obj0 = 0 ;
12364 char *kwnames[] = {
12365 (char *) "self", NULL
12366 };
12367
12368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12370 if (SWIG_arg_fail(1)) SWIG_fail;
12371 {
12372 PyThreadState* __tstate = wxPyBeginAllowThreads();
12373 result = (int)(arg1)->GetMaxAxes();
12374
12375 wxPyEndAllowThreads(__tstate);
12376 if (PyErr_Occurred()) SWIG_fail;
12377 }
12378 {
12379 resultobj = SWIG_From_int((int)(result));
12380 }
12381 return resultobj;
12382 fail:
12383 return NULL;
12384 }
12385
12386
12387 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12388 PyObject *resultobj;
12389 wxJoystick *arg1 = (wxJoystick *) 0 ;
12390 int result;
12391 PyObject * obj0 = 0 ;
12392 char *kwnames[] = {
12393 (char *) "self", NULL
12394 };
12395
12396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12398 if (SWIG_arg_fail(1)) SWIG_fail;
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 result = (int)(arg1)->GetPollingMin();
12402
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 {
12407 resultobj = SWIG_From_int((int)(result));
12408 }
12409 return resultobj;
12410 fail:
12411 return NULL;
12412 }
12413
12414
12415 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12416 PyObject *resultobj;
12417 wxJoystick *arg1 = (wxJoystick *) 0 ;
12418 int result;
12419 PyObject * obj0 = 0 ;
12420 char *kwnames[] = {
12421 (char *) "self", NULL
12422 };
12423
12424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12426 if (SWIG_arg_fail(1)) SWIG_fail;
12427 {
12428 PyThreadState* __tstate = wxPyBeginAllowThreads();
12429 result = (int)(arg1)->GetPollingMax();
12430
12431 wxPyEndAllowThreads(__tstate);
12432 if (PyErr_Occurred()) SWIG_fail;
12433 }
12434 {
12435 resultobj = SWIG_From_int((int)(result));
12436 }
12437 return resultobj;
12438 fail:
12439 return NULL;
12440 }
12441
12442
12443 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12444 PyObject *resultobj;
12445 wxJoystick *arg1 = (wxJoystick *) 0 ;
12446 int result;
12447 PyObject * obj0 = 0 ;
12448 char *kwnames[] = {
12449 (char *) "self", NULL
12450 };
12451
12452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12454 if (SWIG_arg_fail(1)) SWIG_fail;
12455 {
12456 PyThreadState* __tstate = wxPyBeginAllowThreads();
12457 result = (int)(arg1)->GetRudderMin();
12458
12459 wxPyEndAllowThreads(__tstate);
12460 if (PyErr_Occurred()) SWIG_fail;
12461 }
12462 {
12463 resultobj = SWIG_From_int((int)(result));
12464 }
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj;
12473 wxJoystick *arg1 = (wxJoystick *) 0 ;
12474 int result;
12475 PyObject * obj0 = 0 ;
12476 char *kwnames[] = {
12477 (char *) "self", NULL
12478 };
12479
12480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12482 if (SWIG_arg_fail(1)) SWIG_fail;
12483 {
12484 PyThreadState* __tstate = wxPyBeginAllowThreads();
12485 result = (int)(arg1)->GetRudderMax();
12486
12487 wxPyEndAllowThreads(__tstate);
12488 if (PyErr_Occurred()) SWIG_fail;
12489 }
12490 {
12491 resultobj = SWIG_From_int((int)(result));
12492 }
12493 return resultobj;
12494 fail:
12495 return NULL;
12496 }
12497
12498
12499 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12500 PyObject *resultobj;
12501 wxJoystick *arg1 = (wxJoystick *) 0 ;
12502 int result;
12503 PyObject * obj0 = 0 ;
12504 char *kwnames[] = {
12505 (char *) "self", NULL
12506 };
12507
12508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12510 if (SWIG_arg_fail(1)) SWIG_fail;
12511 {
12512 PyThreadState* __tstate = wxPyBeginAllowThreads();
12513 result = (int)(arg1)->GetUMin();
12514
12515 wxPyEndAllowThreads(__tstate);
12516 if (PyErr_Occurred()) SWIG_fail;
12517 }
12518 {
12519 resultobj = SWIG_From_int((int)(result));
12520 }
12521 return resultobj;
12522 fail:
12523 return NULL;
12524 }
12525
12526
12527 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12528 PyObject *resultobj;
12529 wxJoystick *arg1 = (wxJoystick *) 0 ;
12530 int result;
12531 PyObject * obj0 = 0 ;
12532 char *kwnames[] = {
12533 (char *) "self", NULL
12534 };
12535
12536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12538 if (SWIG_arg_fail(1)) SWIG_fail;
12539 {
12540 PyThreadState* __tstate = wxPyBeginAllowThreads();
12541 result = (int)(arg1)->GetUMax();
12542
12543 wxPyEndAllowThreads(__tstate);
12544 if (PyErr_Occurred()) SWIG_fail;
12545 }
12546 {
12547 resultobj = SWIG_From_int((int)(result));
12548 }
12549 return resultobj;
12550 fail:
12551 return NULL;
12552 }
12553
12554
12555 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12556 PyObject *resultobj;
12557 wxJoystick *arg1 = (wxJoystick *) 0 ;
12558 int result;
12559 PyObject * obj0 = 0 ;
12560 char *kwnames[] = {
12561 (char *) "self", NULL
12562 };
12563
12564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12566 if (SWIG_arg_fail(1)) SWIG_fail;
12567 {
12568 PyThreadState* __tstate = wxPyBeginAllowThreads();
12569 result = (int)(arg1)->GetVMin();
12570
12571 wxPyEndAllowThreads(__tstate);
12572 if (PyErr_Occurred()) SWIG_fail;
12573 }
12574 {
12575 resultobj = SWIG_From_int((int)(result));
12576 }
12577 return resultobj;
12578 fail:
12579 return NULL;
12580 }
12581
12582
12583 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12584 PyObject *resultobj;
12585 wxJoystick *arg1 = (wxJoystick *) 0 ;
12586 int result;
12587 PyObject * obj0 = 0 ;
12588 char *kwnames[] = {
12589 (char *) "self", NULL
12590 };
12591
12592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12594 if (SWIG_arg_fail(1)) SWIG_fail;
12595 {
12596 PyThreadState* __tstate = wxPyBeginAllowThreads();
12597 result = (int)(arg1)->GetVMax();
12598
12599 wxPyEndAllowThreads(__tstate);
12600 if (PyErr_Occurred()) SWIG_fail;
12601 }
12602 {
12603 resultobj = SWIG_From_int((int)(result));
12604 }
12605 return resultobj;
12606 fail:
12607 return NULL;
12608 }
12609
12610
12611 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12612 PyObject *resultobj;
12613 wxJoystick *arg1 = (wxJoystick *) 0 ;
12614 bool result;
12615 PyObject * obj0 = 0 ;
12616 char *kwnames[] = {
12617 (char *) "self", NULL
12618 };
12619
12620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12622 if (SWIG_arg_fail(1)) SWIG_fail;
12623 {
12624 PyThreadState* __tstate = wxPyBeginAllowThreads();
12625 result = (bool)(arg1)->HasRudder();
12626
12627 wxPyEndAllowThreads(__tstate);
12628 if (PyErr_Occurred()) SWIG_fail;
12629 }
12630 {
12631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12632 }
12633 return resultobj;
12634 fail:
12635 return NULL;
12636 }
12637
12638
12639 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj;
12641 wxJoystick *arg1 = (wxJoystick *) 0 ;
12642 bool result;
12643 PyObject * obj0 = 0 ;
12644 char *kwnames[] = {
12645 (char *) "self", NULL
12646 };
12647
12648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12650 if (SWIG_arg_fail(1)) SWIG_fail;
12651 {
12652 PyThreadState* __tstate = wxPyBeginAllowThreads();
12653 result = (bool)(arg1)->HasZ();
12654
12655 wxPyEndAllowThreads(__tstate);
12656 if (PyErr_Occurred()) SWIG_fail;
12657 }
12658 {
12659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12660 }
12661 return resultobj;
12662 fail:
12663 return NULL;
12664 }
12665
12666
12667 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12668 PyObject *resultobj;
12669 wxJoystick *arg1 = (wxJoystick *) 0 ;
12670 bool result;
12671 PyObject * obj0 = 0 ;
12672 char *kwnames[] = {
12673 (char *) "self", NULL
12674 };
12675
12676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12678 if (SWIG_arg_fail(1)) SWIG_fail;
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (bool)(arg1)->HasU();
12682
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12688 }
12689 return resultobj;
12690 fail:
12691 return NULL;
12692 }
12693
12694
12695 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12696 PyObject *resultobj;
12697 wxJoystick *arg1 = (wxJoystick *) 0 ;
12698 bool result;
12699 PyObject * obj0 = 0 ;
12700 char *kwnames[] = {
12701 (char *) "self", NULL
12702 };
12703
12704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12706 if (SWIG_arg_fail(1)) SWIG_fail;
12707 {
12708 PyThreadState* __tstate = wxPyBeginAllowThreads();
12709 result = (bool)(arg1)->HasV();
12710
12711 wxPyEndAllowThreads(__tstate);
12712 if (PyErr_Occurred()) SWIG_fail;
12713 }
12714 {
12715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12716 }
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12724 PyObject *resultobj;
12725 wxJoystick *arg1 = (wxJoystick *) 0 ;
12726 bool result;
12727 PyObject * obj0 = 0 ;
12728 char *kwnames[] = {
12729 (char *) "self", NULL
12730 };
12731
12732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12734 if (SWIG_arg_fail(1)) SWIG_fail;
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 result = (bool)(arg1)->HasPOV();
12738
12739 wxPyEndAllowThreads(__tstate);
12740 if (PyErr_Occurred()) SWIG_fail;
12741 }
12742 {
12743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12744 }
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12752 PyObject *resultobj;
12753 wxJoystick *arg1 = (wxJoystick *) 0 ;
12754 bool result;
12755 PyObject * obj0 = 0 ;
12756 char *kwnames[] = {
12757 (char *) "self", NULL
12758 };
12759
12760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12762 if (SWIG_arg_fail(1)) SWIG_fail;
12763 {
12764 PyThreadState* __tstate = wxPyBeginAllowThreads();
12765 result = (bool)(arg1)->HasPOV4Dir();
12766
12767 wxPyEndAllowThreads(__tstate);
12768 if (PyErr_Occurred()) SWIG_fail;
12769 }
12770 {
12771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12772 }
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12780 PyObject *resultobj;
12781 wxJoystick *arg1 = (wxJoystick *) 0 ;
12782 bool result;
12783 PyObject * obj0 = 0 ;
12784 char *kwnames[] = {
12785 (char *) "self", NULL
12786 };
12787
12788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12790 if (SWIG_arg_fail(1)) SWIG_fail;
12791 {
12792 PyThreadState* __tstate = wxPyBeginAllowThreads();
12793 result = (bool)(arg1)->HasPOVCTS();
12794
12795 wxPyEndAllowThreads(__tstate);
12796 if (PyErr_Occurred()) SWIG_fail;
12797 }
12798 {
12799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12800 }
12801 return resultobj;
12802 fail:
12803 return NULL;
12804 }
12805
12806
12807 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12808 PyObject *resultobj;
12809 wxJoystick *arg1 = (wxJoystick *) 0 ;
12810 wxWindow *arg2 = (wxWindow *) 0 ;
12811 int arg3 = (int) 0 ;
12812 bool result;
12813 PyObject * obj0 = 0 ;
12814 PyObject * obj1 = 0 ;
12815 PyObject * obj2 = 0 ;
12816 char *kwnames[] = {
12817 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12818 };
12819
12820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12822 if (SWIG_arg_fail(1)) SWIG_fail;
12823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12824 if (SWIG_arg_fail(2)) SWIG_fail;
12825 if (obj2) {
12826 {
12827 arg3 = (int)(SWIG_As_int(obj2));
12828 if (SWIG_arg_fail(3)) SWIG_fail;
12829 }
12830 }
12831 {
12832 PyThreadState* __tstate = wxPyBeginAllowThreads();
12833 result = (bool)(arg1)->SetCapture(arg2,arg3);
12834
12835 wxPyEndAllowThreads(__tstate);
12836 if (PyErr_Occurred()) SWIG_fail;
12837 }
12838 {
12839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12840 }
12841 return resultobj;
12842 fail:
12843 return NULL;
12844 }
12845
12846
12847 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12848 PyObject *resultobj;
12849 wxJoystick *arg1 = (wxJoystick *) 0 ;
12850 bool result;
12851 PyObject * obj0 = 0 ;
12852 char *kwnames[] = {
12853 (char *) "self", NULL
12854 };
12855
12856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12858 if (SWIG_arg_fail(1)) SWIG_fail;
12859 {
12860 PyThreadState* __tstate = wxPyBeginAllowThreads();
12861 result = (bool)(arg1)->ReleaseCapture();
12862
12863 wxPyEndAllowThreads(__tstate);
12864 if (PyErr_Occurred()) SWIG_fail;
12865 }
12866 {
12867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12868 }
12869 return resultobj;
12870 fail:
12871 return NULL;
12872 }
12873
12874
12875 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12876 PyObject *obj;
12877 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12878 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12879 Py_INCREF(obj);
12880 return Py_BuildValue((char *)"");
12881 }
12882 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12883 PyObject *resultobj;
12884 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12885 int arg2 = (int) 0 ;
12886 int arg3 = (int) wxJOYSTICK1 ;
12887 int arg4 = (int) 0 ;
12888 wxJoystickEvent *result;
12889 PyObject * obj0 = 0 ;
12890 PyObject * obj1 = 0 ;
12891 PyObject * obj2 = 0 ;
12892 PyObject * obj3 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12895 };
12896
12897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12898 if (obj0) {
12899 {
12900 arg1 = (wxEventType)(SWIG_As_int(obj0));
12901 if (SWIG_arg_fail(1)) SWIG_fail;
12902 }
12903 }
12904 if (obj1) {
12905 {
12906 arg2 = (int)(SWIG_As_int(obj1));
12907 if (SWIG_arg_fail(2)) SWIG_fail;
12908 }
12909 }
12910 if (obj2) {
12911 {
12912 arg3 = (int)(SWIG_As_int(obj2));
12913 if (SWIG_arg_fail(3)) SWIG_fail;
12914 }
12915 }
12916 if (obj3) {
12917 {
12918 arg4 = (int)(SWIG_As_int(obj3));
12919 if (SWIG_arg_fail(4)) SWIG_fail;
12920 }
12921 }
12922 {
12923 PyThreadState* __tstate = wxPyBeginAllowThreads();
12924 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12925
12926 wxPyEndAllowThreads(__tstate);
12927 if (PyErr_Occurred()) SWIG_fail;
12928 }
12929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12930 return resultobj;
12931 fail:
12932 return NULL;
12933 }
12934
12935
12936 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12937 PyObject *resultobj;
12938 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12939 wxPoint result;
12940 PyObject * obj0 = 0 ;
12941 char *kwnames[] = {
12942 (char *) "self", NULL
12943 };
12944
12945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12947 if (SWIG_arg_fail(1)) SWIG_fail;
12948 {
12949 PyThreadState* __tstate = wxPyBeginAllowThreads();
12950 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12951
12952 wxPyEndAllowThreads(__tstate);
12953 if (PyErr_Occurred()) SWIG_fail;
12954 }
12955 {
12956 wxPoint * resultptr;
12957 resultptr = new wxPoint((wxPoint &)(result));
12958 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12959 }
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12967 PyObject *resultobj;
12968 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12969 int result;
12970 PyObject * obj0 = 0 ;
12971 char *kwnames[] = {
12972 (char *) "self", NULL
12973 };
12974
12975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12977 if (SWIG_arg_fail(1)) SWIG_fail;
12978 {
12979 PyThreadState* __tstate = wxPyBeginAllowThreads();
12980 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12981
12982 wxPyEndAllowThreads(__tstate);
12983 if (PyErr_Occurred()) SWIG_fail;
12984 }
12985 {
12986 resultobj = SWIG_From_int((int)(result));
12987 }
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12995 PyObject *resultobj;
12996 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12997 int result;
12998 PyObject * obj0 = 0 ;
12999 char *kwnames[] = {
13000 (char *) "self", NULL
13001 };
13002
13003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13005 if (SWIG_arg_fail(1)) SWIG_fail;
13006 {
13007 PyThreadState* __tstate = wxPyBeginAllowThreads();
13008 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13009
13010 wxPyEndAllowThreads(__tstate);
13011 if (PyErr_Occurred()) SWIG_fail;
13012 }
13013 {
13014 resultobj = SWIG_From_int((int)(result));
13015 }
13016 return resultobj;
13017 fail:
13018 return NULL;
13019 }
13020
13021
13022 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13023 PyObject *resultobj;
13024 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13025 int result;
13026 PyObject * obj0 = 0 ;
13027 char *kwnames[] = {
13028 (char *) "self", NULL
13029 };
13030
13031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13033 if (SWIG_arg_fail(1)) SWIG_fail;
13034 {
13035 PyThreadState* __tstate = wxPyBeginAllowThreads();
13036 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13037
13038 wxPyEndAllowThreads(__tstate);
13039 if (PyErr_Occurred()) SWIG_fail;
13040 }
13041 {
13042 resultobj = SWIG_From_int((int)(result));
13043 }
13044 return resultobj;
13045 fail:
13046 return NULL;
13047 }
13048
13049
13050 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13051 PyObject *resultobj;
13052 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13053 int result;
13054 PyObject * obj0 = 0 ;
13055 char *kwnames[] = {
13056 (char *) "self", NULL
13057 };
13058
13059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13061 if (SWIG_arg_fail(1)) SWIG_fail;
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13065
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 {
13070 resultobj = SWIG_From_int((int)(result));
13071 }
13072 return resultobj;
13073 fail:
13074 return NULL;
13075 }
13076
13077
13078 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13079 PyObject *resultobj;
13080 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13081 int arg2 ;
13082 PyObject * obj0 = 0 ;
13083 PyObject * obj1 = 0 ;
13084 char *kwnames[] = {
13085 (char *) "self",(char *) "stick", NULL
13086 };
13087
13088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13090 if (SWIG_arg_fail(1)) SWIG_fail;
13091 {
13092 arg2 = (int)(SWIG_As_int(obj1));
13093 if (SWIG_arg_fail(2)) SWIG_fail;
13094 }
13095 {
13096 PyThreadState* __tstate = wxPyBeginAllowThreads();
13097 (arg1)->SetJoystick(arg2);
13098
13099 wxPyEndAllowThreads(__tstate);
13100 if (PyErr_Occurred()) SWIG_fail;
13101 }
13102 Py_INCREF(Py_None); resultobj = Py_None;
13103 return resultobj;
13104 fail:
13105 return NULL;
13106 }
13107
13108
13109 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13110 PyObject *resultobj;
13111 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13112 int arg2 ;
13113 PyObject * obj0 = 0 ;
13114 PyObject * obj1 = 0 ;
13115 char *kwnames[] = {
13116 (char *) "self",(char *) "state", NULL
13117 };
13118
13119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13121 if (SWIG_arg_fail(1)) SWIG_fail;
13122 {
13123 arg2 = (int)(SWIG_As_int(obj1));
13124 if (SWIG_arg_fail(2)) SWIG_fail;
13125 }
13126 {
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 (arg1)->SetButtonState(arg2);
13129
13130 wxPyEndAllowThreads(__tstate);
13131 if (PyErr_Occurred()) SWIG_fail;
13132 }
13133 Py_INCREF(Py_None); resultobj = Py_None;
13134 return resultobj;
13135 fail:
13136 return NULL;
13137 }
13138
13139
13140 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13141 PyObject *resultobj;
13142 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13143 int arg2 ;
13144 PyObject * obj0 = 0 ;
13145 PyObject * obj1 = 0 ;
13146 char *kwnames[] = {
13147 (char *) "self",(char *) "change", NULL
13148 };
13149
13150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13152 if (SWIG_arg_fail(1)) SWIG_fail;
13153 {
13154 arg2 = (int)(SWIG_As_int(obj1));
13155 if (SWIG_arg_fail(2)) SWIG_fail;
13156 }
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 (arg1)->SetButtonChange(arg2);
13160
13161 wxPyEndAllowThreads(__tstate);
13162 if (PyErr_Occurred()) SWIG_fail;
13163 }
13164 Py_INCREF(Py_None); resultobj = Py_None;
13165 return resultobj;
13166 fail:
13167 return NULL;
13168 }
13169
13170
13171 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13172 PyObject *resultobj;
13173 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13174 wxPoint *arg2 = 0 ;
13175 wxPoint temp2 ;
13176 PyObject * obj0 = 0 ;
13177 PyObject * obj1 = 0 ;
13178 char *kwnames[] = {
13179 (char *) "self",(char *) "pos", NULL
13180 };
13181
13182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13184 if (SWIG_arg_fail(1)) SWIG_fail;
13185 {
13186 arg2 = &temp2;
13187 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 (arg1)->SetPosition((wxPoint const &)*arg2);
13192
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 Py_INCREF(Py_None); resultobj = Py_None;
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj;
13205 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13206 int arg2 ;
13207 PyObject * obj0 = 0 ;
13208 PyObject * obj1 = 0 ;
13209 char *kwnames[] = {
13210 (char *) "self",(char *) "zPos", NULL
13211 };
13212
13213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13215 if (SWIG_arg_fail(1)) SWIG_fail;
13216 {
13217 arg2 = (int)(SWIG_As_int(obj1));
13218 if (SWIG_arg_fail(2)) SWIG_fail;
13219 }
13220 {
13221 PyThreadState* __tstate = wxPyBeginAllowThreads();
13222 (arg1)->SetZPosition(arg2);
13223
13224 wxPyEndAllowThreads(__tstate);
13225 if (PyErr_Occurred()) SWIG_fail;
13226 }
13227 Py_INCREF(Py_None); resultobj = Py_None;
13228 return resultobj;
13229 fail:
13230 return NULL;
13231 }
13232
13233
13234 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13235 PyObject *resultobj;
13236 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13237 bool result;
13238 PyObject * obj0 = 0 ;
13239 char *kwnames[] = {
13240 (char *) "self", NULL
13241 };
13242
13243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13245 if (SWIG_arg_fail(1)) SWIG_fail;
13246 {
13247 PyThreadState* __tstate = wxPyBeginAllowThreads();
13248 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13249
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 {
13254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13255 }
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj;
13264 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13265 bool result;
13266 PyObject * obj0 = 0 ;
13267 char *kwnames[] = {
13268 (char *) "self", NULL
13269 };
13270
13271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13273 if (SWIG_arg_fail(1)) SWIG_fail;
13274 {
13275 PyThreadState* __tstate = wxPyBeginAllowThreads();
13276 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13277
13278 wxPyEndAllowThreads(__tstate);
13279 if (PyErr_Occurred()) SWIG_fail;
13280 }
13281 {
13282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13283 }
13284 return resultobj;
13285 fail:
13286 return NULL;
13287 }
13288
13289
13290 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13291 PyObject *resultobj;
13292 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13293 bool result;
13294 PyObject * obj0 = 0 ;
13295 char *kwnames[] = {
13296 (char *) "self", NULL
13297 };
13298
13299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13301 if (SWIG_arg_fail(1)) SWIG_fail;
13302 {
13303 PyThreadState* __tstate = wxPyBeginAllowThreads();
13304 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13305
13306 wxPyEndAllowThreads(__tstate);
13307 if (PyErr_Occurred()) SWIG_fail;
13308 }
13309 {
13310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13311 }
13312 return resultobj;
13313 fail:
13314 return NULL;
13315 }
13316
13317
13318 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj;
13320 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13321 int arg2 = (int) wxJOY_BUTTON_ANY ;
13322 bool result;
13323 PyObject * obj0 = 0 ;
13324 PyObject * obj1 = 0 ;
13325 char *kwnames[] = {
13326 (char *) "self",(char *) "but", NULL
13327 };
13328
13329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13331 if (SWIG_arg_fail(1)) SWIG_fail;
13332 if (obj1) {
13333 {
13334 arg2 = (int)(SWIG_As_int(obj1));
13335 if (SWIG_arg_fail(2)) SWIG_fail;
13336 }
13337 }
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13341
13342 wxPyEndAllowThreads(__tstate);
13343 if (PyErr_Occurred()) SWIG_fail;
13344 }
13345 {
13346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13347 }
13348 return resultobj;
13349 fail:
13350 return NULL;
13351 }
13352
13353
13354 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13355 PyObject *resultobj;
13356 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13357 int arg2 = (int) wxJOY_BUTTON_ANY ;
13358 bool result;
13359 PyObject * obj0 = 0 ;
13360 PyObject * obj1 = 0 ;
13361 char *kwnames[] = {
13362 (char *) "self",(char *) "but", NULL
13363 };
13364
13365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13367 if (SWIG_arg_fail(1)) SWIG_fail;
13368 if (obj1) {
13369 {
13370 arg2 = (int)(SWIG_As_int(obj1));
13371 if (SWIG_arg_fail(2)) SWIG_fail;
13372 }
13373 }
13374 {
13375 PyThreadState* __tstate = wxPyBeginAllowThreads();
13376 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13377
13378 wxPyEndAllowThreads(__tstate);
13379 if (PyErr_Occurred()) SWIG_fail;
13380 }
13381 {
13382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13383 }
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj;
13392 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13393 int arg2 = (int) wxJOY_BUTTON_ANY ;
13394 bool result;
13395 PyObject * obj0 = 0 ;
13396 PyObject * obj1 = 0 ;
13397 char *kwnames[] = {
13398 (char *) "self",(char *) "but", NULL
13399 };
13400
13401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13403 if (SWIG_arg_fail(1)) SWIG_fail;
13404 if (obj1) {
13405 {
13406 arg2 = (int)(SWIG_As_int(obj1));
13407 if (SWIG_arg_fail(2)) SWIG_fail;
13408 }
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13413
13414 wxPyEndAllowThreads(__tstate);
13415 if (PyErr_Occurred()) SWIG_fail;
13416 }
13417 {
13418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13419 }
13420 return resultobj;
13421 fail:
13422 return NULL;
13423 }
13424
13425
13426 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13427 PyObject *obj;
13428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13429 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13430 Py_INCREF(obj);
13431 return Py_BuildValue((char *)"");
13432 }
13433 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13434 PyObject *resultobj;
13435 wxString const &arg1_defvalue = wxPyEmptyString ;
13436 wxString *arg1 = (wxString *) &arg1_defvalue ;
13437 wxSound *result;
13438 bool temp1 = false ;
13439 PyObject * obj0 = 0 ;
13440 char *kwnames[] = {
13441 (char *) "fileName", NULL
13442 };
13443
13444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13445 if (obj0) {
13446 {
13447 arg1 = wxString_in_helper(obj0);
13448 if (arg1 == NULL) SWIG_fail;
13449 temp1 = true;
13450 }
13451 }
13452 {
13453 if (!wxPyCheckForApp()) SWIG_fail;
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13456
13457 wxPyEndAllowThreads(__tstate);
13458 if (PyErr_Occurred()) SWIG_fail;
13459 }
13460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13461 {
13462 if (temp1)
13463 delete arg1;
13464 }
13465 return resultobj;
13466 fail:
13467 {
13468 if (temp1)
13469 delete arg1;
13470 }
13471 return NULL;
13472 }
13473
13474
13475 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13476 PyObject *resultobj;
13477 PyObject *arg1 = (PyObject *) 0 ;
13478 wxSound *result;
13479 PyObject * obj0 = 0 ;
13480 char *kwnames[] = {
13481 (char *) "data", NULL
13482 };
13483
13484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13485 arg1 = obj0;
13486 {
13487 if (!wxPyCheckForApp()) SWIG_fail;
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 result = (wxSound *)new_wxSound(arg1);
13490
13491 wxPyEndAllowThreads(__tstate);
13492 if (PyErr_Occurred()) SWIG_fail;
13493 }
13494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13495 return resultobj;
13496 fail:
13497 return NULL;
13498 }
13499
13500
13501 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13502 PyObject *resultobj;
13503 wxSound *arg1 = (wxSound *) 0 ;
13504 PyObject * obj0 = 0 ;
13505 char *kwnames[] = {
13506 (char *) "self", NULL
13507 };
13508
13509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13511 if (SWIG_arg_fail(1)) SWIG_fail;
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 delete arg1;
13515
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 Py_INCREF(Py_None); resultobj = Py_None;
13520 return resultobj;
13521 fail:
13522 return NULL;
13523 }
13524
13525
13526 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj;
13528 wxSound *arg1 = (wxSound *) 0 ;
13529 wxString *arg2 = 0 ;
13530 bool result;
13531 bool temp2 = false ;
13532 PyObject * obj0 = 0 ;
13533 PyObject * obj1 = 0 ;
13534 char *kwnames[] = {
13535 (char *) "self",(char *) "fileName", NULL
13536 };
13537
13538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13540 if (SWIG_arg_fail(1)) SWIG_fail;
13541 {
13542 arg2 = wxString_in_helper(obj1);
13543 if (arg2 == NULL) SWIG_fail;
13544 temp2 = true;
13545 }
13546 {
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 result = (bool)(arg1)->Create((wxString const &)*arg2);
13549
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 {
13554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13555 }
13556 {
13557 if (temp2)
13558 delete arg2;
13559 }
13560 return resultobj;
13561 fail:
13562 {
13563 if (temp2)
13564 delete arg2;
13565 }
13566 return NULL;
13567 }
13568
13569
13570 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj;
13572 wxSound *arg1 = (wxSound *) 0 ;
13573 PyObject *arg2 = (PyObject *) 0 ;
13574 bool result;
13575 PyObject * obj0 = 0 ;
13576 PyObject * obj1 = 0 ;
13577 char *kwnames[] = {
13578 (char *) "self",(char *) "data", NULL
13579 };
13580
13581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13583 if (SWIG_arg_fail(1)) SWIG_fail;
13584 arg2 = obj1;
13585 {
13586 PyThreadState* __tstate = wxPyBeginAllowThreads();
13587 result = (bool)wxSound_CreateFromData(arg1,arg2);
13588
13589 wxPyEndAllowThreads(__tstate);
13590 if (PyErr_Occurred()) SWIG_fail;
13591 }
13592 {
13593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13594 }
13595 return resultobj;
13596 fail:
13597 return NULL;
13598 }
13599
13600
13601 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13602 PyObject *resultobj;
13603 wxSound *arg1 = (wxSound *) 0 ;
13604 bool result;
13605 PyObject * obj0 = 0 ;
13606 char *kwnames[] = {
13607 (char *) "self", NULL
13608 };
13609
13610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13612 if (SWIG_arg_fail(1)) SWIG_fail;
13613 {
13614 PyThreadState* __tstate = wxPyBeginAllowThreads();
13615 result = (bool)(arg1)->IsOk();
13616
13617 wxPyEndAllowThreads(__tstate);
13618 if (PyErr_Occurred()) SWIG_fail;
13619 }
13620 {
13621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13622 }
13623 return resultobj;
13624 fail:
13625 return NULL;
13626 }
13627
13628
13629 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13630 PyObject *resultobj;
13631 wxSound *arg1 = (wxSound *) 0 ;
13632 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13633 bool result;
13634 PyObject * obj0 = 0 ;
13635 PyObject * obj1 = 0 ;
13636 char *kwnames[] = {
13637 (char *) "self",(char *) "flags", NULL
13638 };
13639
13640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13642 if (SWIG_arg_fail(1)) SWIG_fail;
13643 if (obj1) {
13644 {
13645 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13646 if (SWIG_arg_fail(2)) SWIG_fail;
13647 }
13648 }
13649 {
13650 if (!wxPyCheckForApp()) SWIG_fail;
13651 PyThreadState* __tstate = wxPyBeginAllowThreads();
13652 result = (bool)((wxSound const *)arg1)->Play(arg2);
13653
13654 wxPyEndAllowThreads(__tstate);
13655 if (PyErr_Occurred()) SWIG_fail;
13656 }
13657 {
13658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13659 }
13660 return resultobj;
13661 fail:
13662 return NULL;
13663 }
13664
13665
13666 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj;
13668 wxString *arg1 = 0 ;
13669 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13670 bool result;
13671 bool temp1 = false ;
13672 PyObject * obj0 = 0 ;
13673 PyObject * obj1 = 0 ;
13674 char *kwnames[] = {
13675 (char *) "filename",(char *) "flags", NULL
13676 };
13677
13678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13679 {
13680 arg1 = wxString_in_helper(obj0);
13681 if (arg1 == NULL) SWIG_fail;
13682 temp1 = true;
13683 }
13684 if (obj1) {
13685 {
13686 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13687 if (SWIG_arg_fail(2)) SWIG_fail;
13688 }
13689 }
13690 {
13691 if (!wxPyCheckForApp()) SWIG_fail;
13692 PyThreadState* __tstate = wxPyBeginAllowThreads();
13693 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13694
13695 wxPyEndAllowThreads(__tstate);
13696 if (PyErr_Occurred()) SWIG_fail;
13697 }
13698 {
13699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13700 }
13701 {
13702 if (temp1)
13703 delete arg1;
13704 }
13705 return resultobj;
13706 fail:
13707 {
13708 if (temp1)
13709 delete arg1;
13710 }
13711 return NULL;
13712 }
13713
13714
13715 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj;
13717 char *kwnames[] = {
13718 NULL
13719 };
13720
13721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13722 {
13723 if (!wxPyCheckForApp()) SWIG_fail;
13724 PyThreadState* __tstate = wxPyBeginAllowThreads();
13725 wxSound::Stop();
13726
13727 wxPyEndAllowThreads(__tstate);
13728 if (PyErr_Occurred()) SWIG_fail;
13729 }
13730 Py_INCREF(Py_None); resultobj = Py_None;
13731 return resultobj;
13732 fail:
13733 return NULL;
13734 }
13735
13736
13737 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13738 PyObject *obj;
13739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13740 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13741 Py_INCREF(obj);
13742 return Py_BuildValue((char *)"");
13743 }
13744 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13745 PyObject *resultobj;
13746 wxString *arg1 = 0 ;
13747 wxString *arg2 = 0 ;
13748 wxString *arg3 = 0 ;
13749 wxString *arg4 = 0 ;
13750 wxFileTypeInfo *result;
13751 bool temp1 = false ;
13752 bool temp2 = false ;
13753 bool temp3 = false ;
13754 bool temp4 = false ;
13755 PyObject * obj0 = 0 ;
13756 PyObject * obj1 = 0 ;
13757 PyObject * obj2 = 0 ;
13758 PyObject * obj3 = 0 ;
13759 char *kwnames[] = {
13760 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13761 };
13762
13763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13764 {
13765 arg1 = wxString_in_helper(obj0);
13766 if (arg1 == NULL) SWIG_fail;
13767 temp1 = true;
13768 }
13769 {
13770 arg2 = wxString_in_helper(obj1);
13771 if (arg2 == NULL) SWIG_fail;
13772 temp2 = true;
13773 }
13774 {
13775 arg3 = wxString_in_helper(obj2);
13776 if (arg3 == NULL) SWIG_fail;
13777 temp3 = true;
13778 }
13779 {
13780 arg4 = wxString_in_helper(obj3);
13781 if (arg4 == NULL) SWIG_fail;
13782 temp4 = true;
13783 }
13784 {
13785 PyThreadState* __tstate = wxPyBeginAllowThreads();
13786 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13787
13788 wxPyEndAllowThreads(__tstate);
13789 if (PyErr_Occurred()) SWIG_fail;
13790 }
13791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13792 {
13793 if (temp1)
13794 delete arg1;
13795 }
13796 {
13797 if (temp2)
13798 delete arg2;
13799 }
13800 {
13801 if (temp3)
13802 delete arg3;
13803 }
13804 {
13805 if (temp4)
13806 delete arg4;
13807 }
13808 return resultobj;
13809 fail:
13810 {
13811 if (temp1)
13812 delete arg1;
13813 }
13814 {
13815 if (temp2)
13816 delete arg2;
13817 }
13818 {
13819 if (temp3)
13820 delete arg3;
13821 }
13822 {
13823 if (temp4)
13824 delete arg4;
13825 }
13826 return NULL;
13827 }
13828
13829
13830 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13831 PyObject *resultobj;
13832 wxArrayString *arg1 = 0 ;
13833 wxFileTypeInfo *result;
13834 bool temp1 = false ;
13835 PyObject * obj0 = 0 ;
13836 char *kwnames[] = {
13837 (char *) "sArray", NULL
13838 };
13839
13840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13841 {
13842 if (! PySequence_Check(obj0)) {
13843 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13844 SWIG_fail;
13845 }
13846 arg1 = new wxArrayString;
13847 temp1 = true;
13848 int i, len=PySequence_Length(obj0);
13849 for (i=0; i<len; i++) {
13850 PyObject* item = PySequence_GetItem(obj0, i);
13851 wxString* s = wxString_in_helper(item);
13852 if (PyErr_Occurred()) SWIG_fail;
13853 arg1->Add(*s);
13854 delete s;
13855 Py_DECREF(item);
13856 }
13857 }
13858 {
13859 PyThreadState* __tstate = wxPyBeginAllowThreads();
13860 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13861
13862 wxPyEndAllowThreads(__tstate);
13863 if (PyErr_Occurred()) SWIG_fail;
13864 }
13865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13866 {
13867 if (temp1) delete arg1;
13868 }
13869 return resultobj;
13870 fail:
13871 {
13872 if (temp1) delete arg1;
13873 }
13874 return NULL;
13875 }
13876
13877
13878 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13879 PyObject *resultobj;
13880 wxFileTypeInfo *result;
13881 char *kwnames[] = {
13882 NULL
13883 };
13884
13885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13886 {
13887 PyThreadState* __tstate = wxPyBeginAllowThreads();
13888 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13889
13890 wxPyEndAllowThreads(__tstate);
13891 if (PyErr_Occurred()) SWIG_fail;
13892 }
13893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13894 return resultobj;
13895 fail:
13896 return NULL;
13897 }
13898
13899
13900 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13901 PyObject *resultobj;
13902 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13903 bool result;
13904 PyObject * obj0 = 0 ;
13905 char *kwnames[] = {
13906 (char *) "self", NULL
13907 };
13908
13909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13911 if (SWIG_arg_fail(1)) SWIG_fail;
13912 {
13913 PyThreadState* __tstate = wxPyBeginAllowThreads();
13914 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13915
13916 wxPyEndAllowThreads(__tstate);
13917 if (PyErr_Occurred()) SWIG_fail;
13918 }
13919 {
13920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13921 }
13922 return resultobj;
13923 fail:
13924 return NULL;
13925 }
13926
13927
13928 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13929 PyObject *resultobj;
13930 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13931 wxString *arg2 = 0 ;
13932 int arg3 = (int) 0 ;
13933 bool temp2 = false ;
13934 PyObject * obj0 = 0 ;
13935 PyObject * obj1 = 0 ;
13936 PyObject * obj2 = 0 ;
13937 char *kwnames[] = {
13938 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13939 };
13940
13941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13943 if (SWIG_arg_fail(1)) SWIG_fail;
13944 {
13945 arg2 = wxString_in_helper(obj1);
13946 if (arg2 == NULL) SWIG_fail;
13947 temp2 = true;
13948 }
13949 if (obj2) {
13950 {
13951 arg3 = (int)(SWIG_As_int(obj2));
13952 if (SWIG_arg_fail(3)) SWIG_fail;
13953 }
13954 }
13955 {
13956 PyThreadState* __tstate = wxPyBeginAllowThreads();
13957 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13958
13959 wxPyEndAllowThreads(__tstate);
13960 if (PyErr_Occurred()) SWIG_fail;
13961 }
13962 Py_INCREF(Py_None); resultobj = Py_None;
13963 {
13964 if (temp2)
13965 delete arg2;
13966 }
13967 return resultobj;
13968 fail:
13969 {
13970 if (temp2)
13971 delete arg2;
13972 }
13973 return NULL;
13974 }
13975
13976
13977 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13978 PyObject *resultobj;
13979 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13980 wxString *arg2 = 0 ;
13981 bool temp2 = false ;
13982 PyObject * obj0 = 0 ;
13983 PyObject * obj1 = 0 ;
13984 char *kwnames[] = {
13985 (char *) "self",(char *) "shortDesc", NULL
13986 };
13987
13988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13990 if (SWIG_arg_fail(1)) SWIG_fail;
13991 {
13992 arg2 = wxString_in_helper(obj1);
13993 if (arg2 == NULL) SWIG_fail;
13994 temp2 = true;
13995 }
13996 {
13997 PyThreadState* __tstate = wxPyBeginAllowThreads();
13998 (arg1)->SetShortDesc((wxString const &)*arg2);
13999
14000 wxPyEndAllowThreads(__tstate);
14001 if (PyErr_Occurred()) SWIG_fail;
14002 }
14003 Py_INCREF(Py_None); resultobj = Py_None;
14004 {
14005 if (temp2)
14006 delete arg2;
14007 }
14008 return resultobj;
14009 fail:
14010 {
14011 if (temp2)
14012 delete arg2;
14013 }
14014 return NULL;
14015 }
14016
14017
14018 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14019 PyObject *resultobj;
14020 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14021 wxString *result;
14022 PyObject * obj0 = 0 ;
14023 char *kwnames[] = {
14024 (char *) "self", NULL
14025 };
14026
14027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14029 if (SWIG_arg_fail(1)) SWIG_fail;
14030 {
14031 PyThreadState* __tstate = wxPyBeginAllowThreads();
14032 {
14033 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14034 result = (wxString *) &_result_ref;
14035 }
14036
14037 wxPyEndAllowThreads(__tstate);
14038 if (PyErr_Occurred()) SWIG_fail;
14039 }
14040 {
14041 #if wxUSE_UNICODE
14042 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14043 #else
14044 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14045 #endif
14046 }
14047 return resultobj;
14048 fail:
14049 return NULL;
14050 }
14051
14052
14053 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14054 PyObject *resultobj;
14055 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14056 wxString *result;
14057 PyObject * obj0 = 0 ;
14058 char *kwnames[] = {
14059 (char *) "self", NULL
14060 };
14061
14062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14064 if (SWIG_arg_fail(1)) SWIG_fail;
14065 {
14066 PyThreadState* __tstate = wxPyBeginAllowThreads();
14067 {
14068 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14069 result = (wxString *) &_result_ref;
14070 }
14071
14072 wxPyEndAllowThreads(__tstate);
14073 if (PyErr_Occurred()) SWIG_fail;
14074 }
14075 {
14076 #if wxUSE_UNICODE
14077 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14078 #else
14079 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14080 #endif
14081 }
14082 return resultobj;
14083 fail:
14084 return NULL;
14085 }
14086
14087
14088 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14089 PyObject *resultobj;
14090 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14091 wxString *result;
14092 PyObject * obj0 = 0 ;
14093 char *kwnames[] = {
14094 (char *) "self", NULL
14095 };
14096
14097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14099 if (SWIG_arg_fail(1)) SWIG_fail;
14100 {
14101 PyThreadState* __tstate = wxPyBeginAllowThreads();
14102 {
14103 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14104 result = (wxString *) &_result_ref;
14105 }
14106
14107 wxPyEndAllowThreads(__tstate);
14108 if (PyErr_Occurred()) SWIG_fail;
14109 }
14110 {
14111 #if wxUSE_UNICODE
14112 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14113 #else
14114 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14115 #endif
14116 }
14117 return resultobj;
14118 fail:
14119 return NULL;
14120 }
14121
14122
14123 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14124 PyObject *resultobj;
14125 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14126 wxString *result;
14127 PyObject * obj0 = 0 ;
14128 char *kwnames[] = {
14129 (char *) "self", NULL
14130 };
14131
14132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14134 if (SWIG_arg_fail(1)) SWIG_fail;
14135 {
14136 PyThreadState* __tstate = wxPyBeginAllowThreads();
14137 {
14138 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14139 result = (wxString *) &_result_ref;
14140 }
14141
14142 wxPyEndAllowThreads(__tstate);
14143 if (PyErr_Occurred()) SWIG_fail;
14144 }
14145 {
14146 #if wxUSE_UNICODE
14147 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14148 #else
14149 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14150 #endif
14151 }
14152 return resultobj;
14153 fail:
14154 return NULL;
14155 }
14156
14157
14158 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14159 PyObject *resultobj;
14160 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14161 wxString *result;
14162 PyObject * obj0 = 0 ;
14163 char *kwnames[] = {
14164 (char *) "self", NULL
14165 };
14166
14167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14169 if (SWIG_arg_fail(1)) SWIG_fail;
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 {
14173 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14174 result = (wxString *) &_result_ref;
14175 }
14176
14177 wxPyEndAllowThreads(__tstate);
14178 if (PyErr_Occurred()) SWIG_fail;
14179 }
14180 {
14181 #if wxUSE_UNICODE
14182 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14183 #else
14184 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14185 #endif
14186 }
14187 return resultobj;
14188 fail:
14189 return NULL;
14190 }
14191
14192
14193 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14194 PyObject *resultobj;
14195 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14196 wxArrayString *result;
14197 PyObject * obj0 = 0 ;
14198 char *kwnames[] = {
14199 (char *) "self", NULL
14200 };
14201
14202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14204 if (SWIG_arg_fail(1)) SWIG_fail;
14205 {
14206 PyThreadState* __tstate = wxPyBeginAllowThreads();
14207 {
14208 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14209 result = (wxArrayString *) &_result_ref;
14210 }
14211
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 {
14216 resultobj = wxArrayString2PyList_helper(*result);
14217 }
14218 return resultobj;
14219 fail:
14220 return NULL;
14221 }
14222
14223
14224 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14225 PyObject *resultobj;
14226 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14227 int result;
14228 PyObject * obj0 = 0 ;
14229 char *kwnames[] = {
14230 (char *) "self", NULL
14231 };
14232
14233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14235 if (SWIG_arg_fail(1)) SWIG_fail;
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14239
14240 wxPyEndAllowThreads(__tstate);
14241 if (PyErr_Occurred()) SWIG_fail;
14242 }
14243 {
14244 resultobj = SWIG_From_int((int)(result));
14245 }
14246 return resultobj;
14247 fail:
14248 return NULL;
14249 }
14250
14251
14252 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14253 PyObject *resultobj;
14254 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14255 wxString *result;
14256 PyObject * obj0 = 0 ;
14257 char *kwnames[] = {
14258 (char *) "self", NULL
14259 };
14260
14261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14263 if (SWIG_arg_fail(1)) SWIG_fail;
14264 {
14265 PyThreadState* __tstate = wxPyBeginAllowThreads();
14266 {
14267 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14268 result = (wxString *) &_result_ref;
14269 }
14270
14271 wxPyEndAllowThreads(__tstate);
14272 if (PyErr_Occurred()) SWIG_fail;
14273 }
14274 {
14275 #if wxUSE_UNICODE
14276 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14277 #else
14278 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14279 #endif
14280 }
14281 return resultobj;
14282 fail:
14283 return NULL;
14284 }
14285
14286
14287 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj;
14289 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14290 int result;
14291 PyObject * obj0 = 0 ;
14292 char *kwnames[] = {
14293 (char *) "self", NULL
14294 };
14295
14296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14298 if (SWIG_arg_fail(1)) SWIG_fail;
14299 {
14300 PyThreadState* __tstate = wxPyBeginAllowThreads();
14301 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14302
14303 wxPyEndAllowThreads(__tstate);
14304 if (PyErr_Occurred()) SWIG_fail;
14305 }
14306 {
14307 resultobj = SWIG_From_int((int)(result));
14308 }
14309 return resultobj;
14310 fail:
14311 return NULL;
14312 }
14313
14314
14315 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14316 PyObject *obj;
14317 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14318 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14319 Py_INCREF(obj);
14320 return Py_BuildValue((char *)"");
14321 }
14322 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14323 PyObject *resultobj;
14324 wxFileTypeInfo *arg1 = 0 ;
14325 wxFileType *result;
14326 PyObject * obj0 = 0 ;
14327 char *kwnames[] = {
14328 (char *) "ftInfo", NULL
14329 };
14330
14331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14332 {
14333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14334 if (SWIG_arg_fail(1)) SWIG_fail;
14335 if (arg1 == NULL) {
14336 SWIG_null_ref("wxFileTypeInfo");
14337 }
14338 if (SWIG_arg_fail(1)) SWIG_fail;
14339 }
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14343
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14348 return resultobj;
14349 fail:
14350 return NULL;
14351 }
14352
14353
14354 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14355 PyObject *resultobj;
14356 wxFileType *arg1 = (wxFileType *) 0 ;
14357 PyObject * obj0 = 0 ;
14358 char *kwnames[] = {
14359 (char *) "self", NULL
14360 };
14361
14362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14364 if (SWIG_arg_fail(1)) SWIG_fail;
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 delete arg1;
14368
14369 wxPyEndAllowThreads(__tstate);
14370 if (PyErr_Occurred()) SWIG_fail;
14371 }
14372 Py_INCREF(Py_None); resultobj = Py_None;
14373 return resultobj;
14374 fail:
14375 return NULL;
14376 }
14377
14378
14379 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14380 PyObject *resultobj;
14381 wxFileType *arg1 = (wxFileType *) 0 ;
14382 PyObject *result;
14383 PyObject * obj0 = 0 ;
14384 char *kwnames[] = {
14385 (char *) "self", NULL
14386 };
14387
14388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14390 if (SWIG_arg_fail(1)) SWIG_fail;
14391 {
14392 PyThreadState* __tstate = wxPyBeginAllowThreads();
14393 result = (PyObject *)wxFileType_GetMimeType(arg1);
14394
14395 wxPyEndAllowThreads(__tstate);
14396 if (PyErr_Occurred()) SWIG_fail;
14397 }
14398 resultobj = result;
14399 return resultobj;
14400 fail:
14401 return NULL;
14402 }
14403
14404
14405 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14406 PyObject *resultobj;
14407 wxFileType *arg1 = (wxFileType *) 0 ;
14408 PyObject *result;
14409 PyObject * obj0 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 {
14418 PyThreadState* __tstate = wxPyBeginAllowThreads();
14419 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14420
14421 wxPyEndAllowThreads(__tstate);
14422 if (PyErr_Occurred()) SWIG_fail;
14423 }
14424 resultobj = result;
14425 return resultobj;
14426 fail:
14427 return NULL;
14428 }
14429
14430
14431 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14432 PyObject *resultobj;
14433 wxFileType *arg1 = (wxFileType *) 0 ;
14434 PyObject *result;
14435 PyObject * obj0 = 0 ;
14436 char *kwnames[] = {
14437 (char *) "self", NULL
14438 };
14439
14440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14442 if (SWIG_arg_fail(1)) SWIG_fail;
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 result = (PyObject *)wxFileType_GetExtensions(arg1);
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 resultobj = result;
14451 return resultobj;
14452 fail:
14453 return NULL;
14454 }
14455
14456
14457 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj;
14459 wxFileType *arg1 = (wxFileType *) 0 ;
14460 wxIcon *result;
14461 PyObject * obj0 = 0 ;
14462 char *kwnames[] = {
14463 (char *) "self", NULL
14464 };
14465
14466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14468 if (SWIG_arg_fail(1)) SWIG_fail;
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 result = (wxIcon *)wxFileType_GetIcon(arg1);
14472
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14477 return resultobj;
14478 fail:
14479 return NULL;
14480 }
14481
14482
14483 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14484 PyObject *resultobj;
14485 wxFileType *arg1 = (wxFileType *) 0 ;
14486 PyObject *result;
14487 PyObject * obj0 = 0 ;
14488 char *kwnames[] = {
14489 (char *) "self", NULL
14490 };
14491
14492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14494 if (SWIG_arg_fail(1)) SWIG_fail;
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14498
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 resultobj = result;
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14510 PyObject *resultobj;
14511 wxFileType *arg1 = (wxFileType *) 0 ;
14512 PyObject *result;
14513 PyObject * obj0 = 0 ;
14514 char *kwnames[] = {
14515 (char *) "self", NULL
14516 };
14517
14518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14520 if (SWIG_arg_fail(1)) SWIG_fail;
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 result = (PyObject *)wxFileType_GetDescription(arg1);
14524
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 resultobj = result;
14529 return resultobj;
14530 fail:
14531 return NULL;
14532 }
14533
14534
14535 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj;
14537 wxFileType *arg1 = (wxFileType *) 0 ;
14538 wxString *arg2 = 0 ;
14539 wxString const &arg3_defvalue = wxPyEmptyString ;
14540 wxString *arg3 = (wxString *) &arg3_defvalue ;
14541 PyObject *result;
14542 bool temp2 = false ;
14543 bool temp3 = false ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 PyObject * obj2 = 0 ;
14547 char *kwnames[] = {
14548 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14549 };
14550
14551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14553 if (SWIG_arg_fail(1)) SWIG_fail;
14554 {
14555 arg2 = wxString_in_helper(obj1);
14556 if (arg2 == NULL) SWIG_fail;
14557 temp2 = true;
14558 }
14559 if (obj2) {
14560 {
14561 arg3 = wxString_in_helper(obj2);
14562 if (arg3 == NULL) SWIG_fail;
14563 temp3 = true;
14564 }
14565 }
14566 {
14567 PyThreadState* __tstate = wxPyBeginAllowThreads();
14568 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14569
14570 wxPyEndAllowThreads(__tstate);
14571 if (PyErr_Occurred()) SWIG_fail;
14572 }
14573 resultobj = result;
14574 {
14575 if (temp2)
14576 delete arg2;
14577 }
14578 {
14579 if (temp3)
14580 delete arg3;
14581 }
14582 return resultobj;
14583 fail:
14584 {
14585 if (temp2)
14586 delete arg2;
14587 }
14588 {
14589 if (temp3)
14590 delete arg3;
14591 }
14592 return NULL;
14593 }
14594
14595
14596 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14597 PyObject *resultobj;
14598 wxFileType *arg1 = (wxFileType *) 0 ;
14599 wxString *arg2 = 0 ;
14600 wxString const &arg3_defvalue = wxPyEmptyString ;
14601 wxString *arg3 = (wxString *) &arg3_defvalue ;
14602 PyObject *result;
14603 bool temp2 = false ;
14604 bool temp3 = false ;
14605 PyObject * obj0 = 0 ;
14606 PyObject * obj1 = 0 ;
14607 PyObject * obj2 = 0 ;
14608 char *kwnames[] = {
14609 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14610 };
14611
14612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14614 if (SWIG_arg_fail(1)) SWIG_fail;
14615 {
14616 arg2 = wxString_in_helper(obj1);
14617 if (arg2 == NULL) SWIG_fail;
14618 temp2 = true;
14619 }
14620 if (obj2) {
14621 {
14622 arg3 = wxString_in_helper(obj2);
14623 if (arg3 == NULL) SWIG_fail;
14624 temp3 = true;
14625 }
14626 }
14627 {
14628 PyThreadState* __tstate = wxPyBeginAllowThreads();
14629 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14630
14631 wxPyEndAllowThreads(__tstate);
14632 if (PyErr_Occurred()) SWIG_fail;
14633 }
14634 resultobj = result;
14635 {
14636 if (temp2)
14637 delete arg2;
14638 }
14639 {
14640 if (temp3)
14641 delete arg3;
14642 }
14643 return resultobj;
14644 fail:
14645 {
14646 if (temp2)
14647 delete arg2;
14648 }
14649 {
14650 if (temp3)
14651 delete arg3;
14652 }
14653 return NULL;
14654 }
14655
14656
14657 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14658 PyObject *resultobj;
14659 wxFileType *arg1 = (wxFileType *) 0 ;
14660 wxString *arg2 = 0 ;
14661 wxString const &arg3_defvalue = wxPyEmptyString ;
14662 wxString *arg3 = (wxString *) &arg3_defvalue ;
14663 PyObject *result;
14664 bool temp2 = false ;
14665 bool temp3 = false ;
14666 PyObject * obj0 = 0 ;
14667 PyObject * obj1 = 0 ;
14668 PyObject * obj2 = 0 ;
14669 char *kwnames[] = {
14670 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14671 };
14672
14673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14675 if (SWIG_arg_fail(1)) SWIG_fail;
14676 {
14677 arg2 = wxString_in_helper(obj1);
14678 if (arg2 == NULL) SWIG_fail;
14679 temp2 = true;
14680 }
14681 if (obj2) {
14682 {
14683 arg3 = wxString_in_helper(obj2);
14684 if (arg3 == NULL) SWIG_fail;
14685 temp3 = true;
14686 }
14687 }
14688 {
14689 PyThreadState* __tstate = wxPyBeginAllowThreads();
14690 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14691
14692 wxPyEndAllowThreads(__tstate);
14693 if (PyErr_Occurred()) SWIG_fail;
14694 }
14695 resultobj = result;
14696 {
14697 if (temp2)
14698 delete arg2;
14699 }
14700 {
14701 if (temp3)
14702 delete arg3;
14703 }
14704 return resultobj;
14705 fail:
14706 {
14707 if (temp2)
14708 delete arg2;
14709 }
14710 {
14711 if (temp3)
14712 delete arg3;
14713 }
14714 return NULL;
14715 }
14716
14717
14718 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14719 PyObject *resultobj;
14720 wxFileType *arg1 = (wxFileType *) 0 ;
14721 wxString *arg2 = 0 ;
14722 wxString *arg3 = 0 ;
14723 bool arg4 = (bool) true ;
14724 bool result;
14725 bool temp2 = false ;
14726 bool temp3 = false ;
14727 PyObject * obj0 = 0 ;
14728 PyObject * obj1 = 0 ;
14729 PyObject * obj2 = 0 ;
14730 PyObject * obj3 = 0 ;
14731 char *kwnames[] = {
14732 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14733 };
14734
14735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14737 if (SWIG_arg_fail(1)) SWIG_fail;
14738 {
14739 arg2 = wxString_in_helper(obj1);
14740 if (arg2 == NULL) SWIG_fail;
14741 temp2 = true;
14742 }
14743 {
14744 arg3 = wxString_in_helper(obj2);
14745 if (arg3 == NULL) SWIG_fail;
14746 temp3 = true;
14747 }
14748 if (obj3) {
14749 {
14750 arg4 = (bool)(SWIG_As_bool(obj3));
14751 if (SWIG_arg_fail(4)) SWIG_fail;
14752 }
14753 }
14754 {
14755 PyThreadState* __tstate = wxPyBeginAllowThreads();
14756 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14757
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 {
14762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14763 }
14764 {
14765 if (temp2)
14766 delete arg2;
14767 }
14768 {
14769 if (temp3)
14770 delete arg3;
14771 }
14772 return resultobj;
14773 fail:
14774 {
14775 if (temp2)
14776 delete arg2;
14777 }
14778 {
14779 if (temp3)
14780 delete arg3;
14781 }
14782 return NULL;
14783 }
14784
14785
14786 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14787 PyObject *resultobj;
14788 wxFileType *arg1 = (wxFileType *) 0 ;
14789 wxString const &arg2_defvalue = wxPyEmptyString ;
14790 wxString *arg2 = (wxString *) &arg2_defvalue ;
14791 int arg3 = (int) 0 ;
14792 bool result;
14793 bool temp2 = false ;
14794 PyObject * obj0 = 0 ;
14795 PyObject * obj1 = 0 ;
14796 PyObject * obj2 = 0 ;
14797 char *kwnames[] = {
14798 (char *) "self",(char *) "cmd",(char *) "index", NULL
14799 };
14800
14801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14803 if (SWIG_arg_fail(1)) SWIG_fail;
14804 if (obj1) {
14805 {
14806 arg2 = wxString_in_helper(obj1);
14807 if (arg2 == NULL) SWIG_fail;
14808 temp2 = true;
14809 }
14810 }
14811 if (obj2) {
14812 {
14813 arg3 = (int)(SWIG_As_int(obj2));
14814 if (SWIG_arg_fail(3)) SWIG_fail;
14815 }
14816 }
14817 {
14818 PyThreadState* __tstate = wxPyBeginAllowThreads();
14819 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14820
14821 wxPyEndAllowThreads(__tstate);
14822 if (PyErr_Occurred()) SWIG_fail;
14823 }
14824 {
14825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14826 }
14827 {
14828 if (temp2)
14829 delete arg2;
14830 }
14831 return resultobj;
14832 fail:
14833 {
14834 if (temp2)
14835 delete arg2;
14836 }
14837 return NULL;
14838 }
14839
14840
14841 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14842 PyObject *resultobj;
14843 wxFileType *arg1 = (wxFileType *) 0 ;
14844 bool result;
14845 PyObject * obj0 = 0 ;
14846 char *kwnames[] = {
14847 (char *) "self", NULL
14848 };
14849
14850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14852 if (SWIG_arg_fail(1)) SWIG_fail;
14853 {
14854 PyThreadState* __tstate = wxPyBeginAllowThreads();
14855 result = (bool)(arg1)->Unassociate();
14856
14857 wxPyEndAllowThreads(__tstate);
14858 if (PyErr_Occurred()) SWIG_fail;
14859 }
14860 {
14861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14862 }
14863 return resultobj;
14864 fail:
14865 return NULL;
14866 }
14867
14868
14869 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14870 PyObject *resultobj;
14871 wxString *arg1 = 0 ;
14872 wxString *arg2 = 0 ;
14873 wxString const &arg3_defvalue = wxPyEmptyString ;
14874 wxString *arg3 = (wxString *) &arg3_defvalue ;
14875 wxString result;
14876 bool temp1 = false ;
14877 bool temp2 = false ;
14878 bool temp3 = false ;
14879 PyObject * obj0 = 0 ;
14880 PyObject * obj1 = 0 ;
14881 PyObject * obj2 = 0 ;
14882 char *kwnames[] = {
14883 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14884 };
14885
14886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14887 {
14888 arg1 = wxString_in_helper(obj0);
14889 if (arg1 == NULL) SWIG_fail;
14890 temp1 = true;
14891 }
14892 {
14893 arg2 = wxString_in_helper(obj1);
14894 if (arg2 == NULL) SWIG_fail;
14895 temp2 = true;
14896 }
14897 if (obj2) {
14898 {
14899 arg3 = wxString_in_helper(obj2);
14900 if (arg3 == NULL) SWIG_fail;
14901 temp3 = true;
14902 }
14903 }
14904 {
14905 PyThreadState* __tstate = wxPyBeginAllowThreads();
14906 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14907
14908 wxPyEndAllowThreads(__tstate);
14909 if (PyErr_Occurred()) SWIG_fail;
14910 }
14911 {
14912 #if wxUSE_UNICODE
14913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14914 #else
14915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14916 #endif
14917 }
14918 {
14919 if (temp1)
14920 delete arg1;
14921 }
14922 {
14923 if (temp2)
14924 delete arg2;
14925 }
14926 {
14927 if (temp3)
14928 delete arg3;
14929 }
14930 return resultobj;
14931 fail:
14932 {
14933 if (temp1)
14934 delete arg1;
14935 }
14936 {
14937 if (temp2)
14938 delete arg2;
14939 }
14940 {
14941 if (temp3)
14942 delete arg3;
14943 }
14944 return NULL;
14945 }
14946
14947
14948 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14949 PyObject *obj;
14950 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14951 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14952 Py_INCREF(obj);
14953 return Py_BuildValue((char *)"");
14954 }
14955 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14956 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14957 return 1;
14958 }
14959
14960
14961 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14962 PyObject *pyobj;
14963
14964 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14965 return pyobj;
14966 }
14967
14968
14969 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14970 PyObject *resultobj;
14971 wxString *arg1 = 0 ;
14972 wxString *arg2 = 0 ;
14973 bool result;
14974 bool temp1 = false ;
14975 bool temp2 = false ;
14976 PyObject * obj0 = 0 ;
14977 PyObject * obj1 = 0 ;
14978 char *kwnames[] = {
14979 (char *) "mimeType",(char *) "wildcard", NULL
14980 };
14981
14982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14983 {
14984 arg1 = wxString_in_helper(obj0);
14985 if (arg1 == NULL) SWIG_fail;
14986 temp1 = true;
14987 }
14988 {
14989 arg2 = wxString_in_helper(obj1);
14990 if (arg2 == NULL) SWIG_fail;
14991 temp2 = true;
14992 }
14993 {
14994 PyThreadState* __tstate = wxPyBeginAllowThreads();
14995 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14996
14997 wxPyEndAllowThreads(__tstate);
14998 if (PyErr_Occurred()) SWIG_fail;
14999 }
15000 {
15001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15002 }
15003 {
15004 if (temp1)
15005 delete arg1;
15006 }
15007 {
15008 if (temp2)
15009 delete arg2;
15010 }
15011 return resultobj;
15012 fail:
15013 {
15014 if (temp1)
15015 delete arg1;
15016 }
15017 {
15018 if (temp2)
15019 delete arg2;
15020 }
15021 return NULL;
15022 }
15023
15024
15025 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15026 PyObject *resultobj;
15027 wxMimeTypesManager *result;
15028 char *kwnames[] = {
15029 NULL
15030 };
15031
15032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15033 {
15034 PyThreadState* __tstate = wxPyBeginAllowThreads();
15035 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15036
15037 wxPyEndAllowThreads(__tstate);
15038 if (PyErr_Occurred()) SWIG_fail;
15039 }
15040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15041 return resultobj;
15042 fail:
15043 return NULL;
15044 }
15045
15046
15047 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15048 PyObject *resultobj;
15049 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15050 int arg2 = (int) wxMAILCAP_ALL ;
15051 wxString const &arg3_defvalue = wxPyEmptyString ;
15052 wxString *arg3 = (wxString *) &arg3_defvalue ;
15053 bool temp3 = false ;
15054 PyObject * obj0 = 0 ;
15055 PyObject * obj1 = 0 ;
15056 PyObject * obj2 = 0 ;
15057 char *kwnames[] = {
15058 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15059 };
15060
15061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15063 if (SWIG_arg_fail(1)) SWIG_fail;
15064 if (obj1) {
15065 {
15066 arg2 = (int)(SWIG_As_int(obj1));
15067 if (SWIG_arg_fail(2)) SWIG_fail;
15068 }
15069 }
15070 if (obj2) {
15071 {
15072 arg3 = wxString_in_helper(obj2);
15073 if (arg3 == NULL) SWIG_fail;
15074 temp3 = true;
15075 }
15076 }
15077 {
15078 PyThreadState* __tstate = wxPyBeginAllowThreads();
15079 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15080
15081 wxPyEndAllowThreads(__tstate);
15082 if (PyErr_Occurred()) SWIG_fail;
15083 }
15084 Py_INCREF(Py_None); resultobj = Py_None;
15085 {
15086 if (temp3)
15087 delete arg3;
15088 }
15089 return resultobj;
15090 fail:
15091 {
15092 if (temp3)
15093 delete arg3;
15094 }
15095 return NULL;
15096 }
15097
15098
15099 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15100 PyObject *resultobj;
15101 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15102 PyObject * obj0 = 0 ;
15103 char *kwnames[] = {
15104 (char *) "self", NULL
15105 };
15106
15107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15109 if (SWIG_arg_fail(1)) SWIG_fail;
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 (arg1)->ClearData();
15113
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 Py_INCREF(Py_None); resultobj = Py_None;
15118 return resultobj;
15119 fail:
15120 return NULL;
15121 }
15122
15123
15124 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj;
15126 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15127 wxString *arg2 = 0 ;
15128 wxFileType *result;
15129 bool temp2 = false ;
15130 PyObject * obj0 = 0 ;
15131 PyObject * obj1 = 0 ;
15132 char *kwnames[] = {
15133 (char *) "self",(char *) "ext", NULL
15134 };
15135
15136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15138 if (SWIG_arg_fail(1)) SWIG_fail;
15139 {
15140 arg2 = wxString_in_helper(obj1);
15141 if (arg2 == NULL) SWIG_fail;
15142 temp2 = true;
15143 }
15144 {
15145 PyThreadState* __tstate = wxPyBeginAllowThreads();
15146 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15147
15148 wxPyEndAllowThreads(__tstate);
15149 if (PyErr_Occurred()) SWIG_fail;
15150 }
15151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15152 {
15153 if (temp2)
15154 delete arg2;
15155 }
15156 return resultobj;
15157 fail:
15158 {
15159 if (temp2)
15160 delete arg2;
15161 }
15162 return NULL;
15163 }
15164
15165
15166 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15167 PyObject *resultobj;
15168 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15169 wxString *arg2 = 0 ;
15170 wxFileType *result;
15171 bool temp2 = false ;
15172 PyObject * obj0 = 0 ;
15173 PyObject * obj1 = 0 ;
15174 char *kwnames[] = {
15175 (char *) "self",(char *) "mimeType", NULL
15176 };
15177
15178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15180 if (SWIG_arg_fail(1)) SWIG_fail;
15181 {
15182 arg2 = wxString_in_helper(obj1);
15183 if (arg2 == NULL) SWIG_fail;
15184 temp2 = true;
15185 }
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15189
15190 wxPyEndAllowThreads(__tstate);
15191 if (PyErr_Occurred()) SWIG_fail;
15192 }
15193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15194 {
15195 if (temp2)
15196 delete arg2;
15197 }
15198 return resultobj;
15199 fail:
15200 {
15201 if (temp2)
15202 delete arg2;
15203 }
15204 return NULL;
15205 }
15206
15207
15208 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15209 PyObject *resultobj;
15210 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15211 wxString *arg2 = 0 ;
15212 bool arg3 = (bool) false ;
15213 bool result;
15214 bool temp2 = false ;
15215 PyObject * obj0 = 0 ;
15216 PyObject * obj1 = 0 ;
15217 PyObject * obj2 = 0 ;
15218 char *kwnames[] = {
15219 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15220 };
15221
15222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15224 if (SWIG_arg_fail(1)) SWIG_fail;
15225 {
15226 arg2 = wxString_in_helper(obj1);
15227 if (arg2 == NULL) SWIG_fail;
15228 temp2 = true;
15229 }
15230 if (obj2) {
15231 {
15232 arg3 = (bool)(SWIG_As_bool(obj2));
15233 if (SWIG_arg_fail(3)) SWIG_fail;
15234 }
15235 }
15236 {
15237 PyThreadState* __tstate = wxPyBeginAllowThreads();
15238 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15239
15240 wxPyEndAllowThreads(__tstate);
15241 if (PyErr_Occurred()) SWIG_fail;
15242 }
15243 {
15244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15245 }
15246 {
15247 if (temp2)
15248 delete arg2;
15249 }
15250 return resultobj;
15251 fail:
15252 {
15253 if (temp2)
15254 delete arg2;
15255 }
15256 return NULL;
15257 }
15258
15259
15260 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15261 PyObject *resultobj;
15262 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15263 wxString *arg2 = 0 ;
15264 bool result;
15265 bool temp2 = false ;
15266 PyObject * obj0 = 0 ;
15267 PyObject * obj1 = 0 ;
15268 char *kwnames[] = {
15269 (char *) "self",(char *) "filename", NULL
15270 };
15271
15272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15274 if (SWIG_arg_fail(1)) SWIG_fail;
15275 {
15276 arg2 = wxString_in_helper(obj1);
15277 if (arg2 == NULL) SWIG_fail;
15278 temp2 = true;
15279 }
15280 {
15281 PyThreadState* __tstate = wxPyBeginAllowThreads();
15282 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15283
15284 wxPyEndAllowThreads(__tstate);
15285 if (PyErr_Occurred()) SWIG_fail;
15286 }
15287 {
15288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15289 }
15290 {
15291 if (temp2)
15292 delete arg2;
15293 }
15294 return resultobj;
15295 fail:
15296 {
15297 if (temp2)
15298 delete arg2;
15299 }
15300 return NULL;
15301 }
15302
15303
15304 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15305 PyObject *resultobj;
15306 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15307 PyObject *result;
15308 PyObject * obj0 = 0 ;
15309 char *kwnames[] = {
15310 (char *) "self", NULL
15311 };
15312
15313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) 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 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15319
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 resultobj = result;
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15331 PyObject *resultobj;
15332 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15333 wxFileTypeInfo *arg2 = 0 ;
15334 PyObject * obj0 = 0 ;
15335 PyObject * obj1 = 0 ;
15336 char *kwnames[] = {
15337 (char *) "self",(char *) "ft", NULL
15338 };
15339
15340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15342 if (SWIG_arg_fail(1)) SWIG_fail;
15343 {
15344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15345 if (SWIG_arg_fail(2)) SWIG_fail;
15346 if (arg2 == NULL) {
15347 SWIG_null_ref("wxFileTypeInfo");
15348 }
15349 if (SWIG_arg_fail(2)) SWIG_fail;
15350 }
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15354
15355 wxPyEndAllowThreads(__tstate);
15356 if (PyErr_Occurred()) SWIG_fail;
15357 }
15358 Py_INCREF(Py_None); resultobj = Py_None;
15359 return resultobj;
15360 fail:
15361 return NULL;
15362 }
15363
15364
15365 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15366 PyObject *resultobj;
15367 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15368 wxFileTypeInfo *arg2 = 0 ;
15369 wxFileType *result;
15370 PyObject * obj0 = 0 ;
15371 PyObject * obj1 = 0 ;
15372 char *kwnames[] = {
15373 (char *) "self",(char *) "ftInfo", NULL
15374 };
15375
15376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15378 if (SWIG_arg_fail(1)) SWIG_fail;
15379 {
15380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15381 if (SWIG_arg_fail(2)) SWIG_fail;
15382 if (arg2 == NULL) {
15383 SWIG_null_ref("wxFileTypeInfo");
15384 }
15385 if (SWIG_arg_fail(2)) SWIG_fail;
15386 }
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15390
15391 wxPyEndAllowThreads(__tstate);
15392 if (PyErr_Occurred()) SWIG_fail;
15393 }
15394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15395 return resultobj;
15396 fail:
15397 return NULL;
15398 }
15399
15400
15401 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15402 PyObject *resultobj;
15403 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15404 wxFileType *arg2 = (wxFileType *) 0 ;
15405 bool result;
15406 PyObject * obj0 = 0 ;
15407 PyObject * obj1 = 0 ;
15408 char *kwnames[] = {
15409 (char *) "self",(char *) "ft", NULL
15410 };
15411
15412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15414 if (SWIG_arg_fail(1)) SWIG_fail;
15415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15416 if (SWIG_arg_fail(2)) SWIG_fail;
15417 {
15418 PyThreadState* __tstate = wxPyBeginAllowThreads();
15419 result = (bool)(arg1)->Unassociate(arg2);
15420
15421 wxPyEndAllowThreads(__tstate);
15422 if (PyErr_Occurred()) SWIG_fail;
15423 }
15424 {
15425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15426 }
15427 return resultobj;
15428 fail:
15429 return NULL;
15430 }
15431
15432
15433 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15434 PyObject *resultobj;
15435 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15436 PyObject * obj0 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 {
15445 PyThreadState* __tstate = wxPyBeginAllowThreads();
15446 delete arg1;
15447
15448 wxPyEndAllowThreads(__tstate);
15449 if (PyErr_Occurred()) SWIG_fail;
15450 }
15451 Py_INCREF(Py_None); resultobj = Py_None;
15452 return resultobj;
15453 fail:
15454 return NULL;
15455 }
15456
15457
15458 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15459 PyObject *obj;
15460 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15461 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15462 Py_INCREF(obj);
15463 return Py_BuildValue((char *)"");
15464 }
15465 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15466 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15467 return 1;
15468 }
15469
15470
15471 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15472 PyObject *pyobj;
15473
15474 {
15475 #if wxUSE_UNICODE
15476 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15477 #else
15478 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15479 #endif
15480 }
15481 return pyobj;
15482 }
15483
15484
15485 static int _wrap_ART_MENU_set(PyObject *) {
15486 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15487 return 1;
15488 }
15489
15490
15491 static PyObject *_wrap_ART_MENU_get(void) {
15492 PyObject *pyobj;
15493
15494 {
15495 #if wxUSE_UNICODE
15496 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15497 #else
15498 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15499 #endif
15500 }
15501 return pyobj;
15502 }
15503
15504
15505 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15506 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15507 return 1;
15508 }
15509
15510
15511 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15512 PyObject *pyobj;
15513
15514 {
15515 #if wxUSE_UNICODE
15516 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15517 #else
15518 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15519 #endif
15520 }
15521 return pyobj;
15522 }
15523
15524
15525 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15526 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15527 return 1;
15528 }
15529
15530
15531 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15532 PyObject *pyobj;
15533
15534 {
15535 #if wxUSE_UNICODE
15536 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15537 #else
15538 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15539 #endif
15540 }
15541 return pyobj;
15542 }
15543
15544
15545 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15546 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15547 return 1;
15548 }
15549
15550
15551 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15552 PyObject *pyobj;
15553
15554 {
15555 #if wxUSE_UNICODE
15556 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15557 #else
15558 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15559 #endif
15560 }
15561 return pyobj;
15562 }
15563
15564
15565 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15566 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15567 return 1;
15568 }
15569
15570
15571 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15572 PyObject *pyobj;
15573
15574 {
15575 #if wxUSE_UNICODE
15576 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15577 #else
15578 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15579 #endif
15580 }
15581 return pyobj;
15582 }
15583
15584
15585 static int _wrap_ART_BUTTON_set(PyObject *) {
15586 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15587 return 1;
15588 }
15589
15590
15591 static PyObject *_wrap_ART_BUTTON_get(void) {
15592 PyObject *pyobj;
15593
15594 {
15595 #if wxUSE_UNICODE
15596 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15597 #else
15598 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15599 #endif
15600 }
15601 return pyobj;
15602 }
15603
15604
15605 static int _wrap_ART_OTHER_set(PyObject *) {
15606 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15607 return 1;
15608 }
15609
15610
15611 static PyObject *_wrap_ART_OTHER_get(void) {
15612 PyObject *pyobj;
15613
15614 {
15615 #if wxUSE_UNICODE
15616 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15617 #else
15618 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15619 #endif
15620 }
15621 return pyobj;
15622 }
15623
15624
15625 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15626 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15627 return 1;
15628 }
15629
15630
15631 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15632 PyObject *pyobj;
15633
15634 {
15635 #if wxUSE_UNICODE
15636 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15637 #else
15638 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15639 #endif
15640 }
15641 return pyobj;
15642 }
15643
15644
15645 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15646 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15647 return 1;
15648 }
15649
15650
15651 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15652 PyObject *pyobj;
15653
15654 {
15655 #if wxUSE_UNICODE
15656 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15657 #else
15658 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15659 #endif
15660 }
15661 return pyobj;
15662 }
15663
15664
15665 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15666 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15667 return 1;
15668 }
15669
15670
15671 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15672 PyObject *pyobj;
15673
15674 {
15675 #if wxUSE_UNICODE
15676 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15677 #else
15678 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15679 #endif
15680 }
15681 return pyobj;
15682 }
15683
15684
15685 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15686 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15687 return 1;
15688 }
15689
15690
15691 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15692 PyObject *pyobj;
15693
15694 {
15695 #if wxUSE_UNICODE
15696 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15697 #else
15698 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15699 #endif
15700 }
15701 return pyobj;
15702 }
15703
15704
15705 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15706 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15707 return 1;
15708 }
15709
15710
15711 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15712 PyObject *pyobj;
15713
15714 {
15715 #if wxUSE_UNICODE
15716 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15717 #else
15718 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15719 #endif
15720 }
15721 return pyobj;
15722 }
15723
15724
15725 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15726 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15727 return 1;
15728 }
15729
15730
15731 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15732 PyObject *pyobj;
15733
15734 {
15735 #if wxUSE_UNICODE
15736 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15737 #else
15738 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15739 #endif
15740 }
15741 return pyobj;
15742 }
15743
15744
15745 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15746 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15747 return 1;
15748 }
15749
15750
15751 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15752 PyObject *pyobj;
15753
15754 {
15755 #if wxUSE_UNICODE
15756 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15757 #else
15758 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15759 #endif
15760 }
15761 return pyobj;
15762 }
15763
15764
15765 static int _wrap_ART_GO_BACK_set(PyObject *) {
15766 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15767 return 1;
15768 }
15769
15770
15771 static PyObject *_wrap_ART_GO_BACK_get(void) {
15772 PyObject *pyobj;
15773
15774 {
15775 #if wxUSE_UNICODE
15776 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15777 #else
15778 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15779 #endif
15780 }
15781 return pyobj;
15782 }
15783
15784
15785 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15786 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15787 return 1;
15788 }
15789
15790
15791 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15792 PyObject *pyobj;
15793
15794 {
15795 #if wxUSE_UNICODE
15796 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15797 #else
15798 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15799 #endif
15800 }
15801 return pyobj;
15802 }
15803
15804
15805 static int _wrap_ART_GO_UP_set(PyObject *) {
15806 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15807 return 1;
15808 }
15809
15810
15811 static PyObject *_wrap_ART_GO_UP_get(void) {
15812 PyObject *pyobj;
15813
15814 {
15815 #if wxUSE_UNICODE
15816 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15817 #else
15818 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15819 #endif
15820 }
15821 return pyobj;
15822 }
15823
15824
15825 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15826 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15827 return 1;
15828 }
15829
15830
15831 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15832 PyObject *pyobj;
15833
15834 {
15835 #if wxUSE_UNICODE
15836 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15837 #else
15838 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15839 #endif
15840 }
15841 return pyobj;
15842 }
15843
15844
15845 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15846 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15847 return 1;
15848 }
15849
15850
15851 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15852 PyObject *pyobj;
15853
15854 {
15855 #if wxUSE_UNICODE
15856 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15857 #else
15858 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15859 #endif
15860 }
15861 return pyobj;
15862 }
15863
15864
15865 static int _wrap_ART_GO_HOME_set(PyObject *) {
15866 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15867 return 1;
15868 }
15869
15870
15871 static PyObject *_wrap_ART_GO_HOME_get(void) {
15872 PyObject *pyobj;
15873
15874 {
15875 #if wxUSE_UNICODE
15876 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15877 #else
15878 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15879 #endif
15880 }
15881 return pyobj;
15882 }
15883
15884
15885 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15886 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15887 return 1;
15888 }
15889
15890
15891 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15892 PyObject *pyobj;
15893
15894 {
15895 #if wxUSE_UNICODE
15896 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15897 #else
15898 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15899 #endif
15900 }
15901 return pyobj;
15902 }
15903
15904
15905 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15906 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15907 return 1;
15908 }
15909
15910
15911 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15912 PyObject *pyobj;
15913
15914 {
15915 #if wxUSE_UNICODE
15916 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15917 #else
15918 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15919 #endif
15920 }
15921 return pyobj;
15922 }
15923
15924
15925 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15926 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15927 return 1;
15928 }
15929
15930
15931 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15932 PyObject *pyobj;
15933
15934 {
15935 #if wxUSE_UNICODE
15936 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15937 #else
15938 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15939 #endif
15940 }
15941 return pyobj;
15942 }
15943
15944
15945 static int _wrap_ART_PRINT_set(PyObject *) {
15946 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15947 return 1;
15948 }
15949
15950
15951 static PyObject *_wrap_ART_PRINT_get(void) {
15952 PyObject *pyobj;
15953
15954 {
15955 #if wxUSE_UNICODE
15956 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15957 #else
15958 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15959 #endif
15960 }
15961 return pyobj;
15962 }
15963
15964
15965 static int _wrap_ART_HELP_set(PyObject *) {
15966 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15967 return 1;
15968 }
15969
15970
15971 static PyObject *_wrap_ART_HELP_get(void) {
15972 PyObject *pyobj;
15973
15974 {
15975 #if wxUSE_UNICODE
15976 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15977 #else
15978 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15979 #endif
15980 }
15981 return pyobj;
15982 }
15983
15984
15985 static int _wrap_ART_TIP_set(PyObject *) {
15986 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15987 return 1;
15988 }
15989
15990
15991 static PyObject *_wrap_ART_TIP_get(void) {
15992 PyObject *pyobj;
15993
15994 {
15995 #if wxUSE_UNICODE
15996 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15997 #else
15998 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15999 #endif
16000 }
16001 return pyobj;
16002 }
16003
16004
16005 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16006 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16007 return 1;
16008 }
16009
16010
16011 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16012 PyObject *pyobj;
16013
16014 {
16015 #if wxUSE_UNICODE
16016 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16017 #else
16018 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16019 #endif
16020 }
16021 return pyobj;
16022 }
16023
16024
16025 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16026 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16027 return 1;
16028 }
16029
16030
16031 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16032 PyObject *pyobj;
16033
16034 {
16035 #if wxUSE_UNICODE
16036 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16037 #else
16038 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16039 #endif
16040 }
16041 return pyobj;
16042 }
16043
16044
16045 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16046 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16047 return 1;
16048 }
16049
16050
16051 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16052 PyObject *pyobj;
16053
16054 {
16055 #if wxUSE_UNICODE
16056 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16057 #else
16058 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16059 #endif
16060 }
16061 return pyobj;
16062 }
16063
16064
16065 static int _wrap_ART_HARDDISK_set(PyObject *) {
16066 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16067 return 1;
16068 }
16069
16070
16071 static PyObject *_wrap_ART_HARDDISK_get(void) {
16072 PyObject *pyobj;
16073
16074 {
16075 #if wxUSE_UNICODE
16076 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16077 #else
16078 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16079 #endif
16080 }
16081 return pyobj;
16082 }
16083
16084
16085 static int _wrap_ART_FLOPPY_set(PyObject *) {
16086 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16087 return 1;
16088 }
16089
16090
16091 static PyObject *_wrap_ART_FLOPPY_get(void) {
16092 PyObject *pyobj;
16093
16094 {
16095 #if wxUSE_UNICODE
16096 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16097 #else
16098 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16099 #endif
16100 }
16101 return pyobj;
16102 }
16103
16104
16105 static int _wrap_ART_CDROM_set(PyObject *) {
16106 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16107 return 1;
16108 }
16109
16110
16111 static PyObject *_wrap_ART_CDROM_get(void) {
16112 PyObject *pyobj;
16113
16114 {
16115 #if wxUSE_UNICODE
16116 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16117 #else
16118 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16119 #endif
16120 }
16121 return pyobj;
16122 }
16123
16124
16125 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16126 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16127 return 1;
16128 }
16129
16130
16131 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16132 PyObject *pyobj;
16133
16134 {
16135 #if wxUSE_UNICODE
16136 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16137 #else
16138 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16139 #endif
16140 }
16141 return pyobj;
16142 }
16143
16144
16145 static int _wrap_ART_FOLDER_set(PyObject *) {
16146 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16147 return 1;
16148 }
16149
16150
16151 static PyObject *_wrap_ART_FOLDER_get(void) {
16152 PyObject *pyobj;
16153
16154 {
16155 #if wxUSE_UNICODE
16156 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16157 #else
16158 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16159 #endif
16160 }
16161 return pyobj;
16162 }
16163
16164
16165 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16166 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16167 return 1;
16168 }
16169
16170
16171 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16172 PyObject *pyobj;
16173
16174 {
16175 #if wxUSE_UNICODE
16176 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16177 #else
16178 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16179 #endif
16180 }
16181 return pyobj;
16182 }
16183
16184
16185 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16186 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16187 return 1;
16188 }
16189
16190
16191 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16192 PyObject *pyobj;
16193
16194 {
16195 #if wxUSE_UNICODE
16196 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16197 #else
16198 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16199 #endif
16200 }
16201 return pyobj;
16202 }
16203
16204
16205 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16206 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16207 return 1;
16208 }
16209
16210
16211 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16212 PyObject *pyobj;
16213
16214 {
16215 #if wxUSE_UNICODE
16216 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16217 #else
16218 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16219 #endif
16220 }
16221 return pyobj;
16222 }
16223
16224
16225 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16226 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16227 return 1;
16228 }
16229
16230
16231 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16232 PyObject *pyobj;
16233
16234 {
16235 #if wxUSE_UNICODE
16236 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16237 #else
16238 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16239 #endif
16240 }
16241 return pyobj;
16242 }
16243
16244
16245 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16246 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16247 return 1;
16248 }
16249
16250
16251 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16252 PyObject *pyobj;
16253
16254 {
16255 #if wxUSE_UNICODE
16256 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16257 #else
16258 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16259 #endif
16260 }
16261 return pyobj;
16262 }
16263
16264
16265 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16266 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16267 return 1;
16268 }
16269
16270
16271 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16272 PyObject *pyobj;
16273
16274 {
16275 #if wxUSE_UNICODE
16276 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16277 #else
16278 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16279 #endif
16280 }
16281 return pyobj;
16282 }
16283
16284
16285 static int _wrap_ART_ERROR_set(PyObject *) {
16286 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16287 return 1;
16288 }
16289
16290
16291 static PyObject *_wrap_ART_ERROR_get(void) {
16292 PyObject *pyobj;
16293
16294 {
16295 #if wxUSE_UNICODE
16296 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16297 #else
16298 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16299 #endif
16300 }
16301 return pyobj;
16302 }
16303
16304
16305 static int _wrap_ART_QUESTION_set(PyObject *) {
16306 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16307 return 1;
16308 }
16309
16310
16311 static PyObject *_wrap_ART_QUESTION_get(void) {
16312 PyObject *pyobj;
16313
16314 {
16315 #if wxUSE_UNICODE
16316 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16317 #else
16318 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16319 #endif
16320 }
16321 return pyobj;
16322 }
16323
16324
16325 static int _wrap_ART_WARNING_set(PyObject *) {
16326 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16327 return 1;
16328 }
16329
16330
16331 static PyObject *_wrap_ART_WARNING_get(void) {
16332 PyObject *pyobj;
16333
16334 {
16335 #if wxUSE_UNICODE
16336 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16337 #else
16338 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16339 #endif
16340 }
16341 return pyobj;
16342 }
16343
16344
16345 static int _wrap_ART_INFORMATION_set(PyObject *) {
16346 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16347 return 1;
16348 }
16349
16350
16351 static PyObject *_wrap_ART_INFORMATION_get(void) {
16352 PyObject *pyobj;
16353
16354 {
16355 #if wxUSE_UNICODE
16356 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16357 #else
16358 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16359 #endif
16360 }
16361 return pyobj;
16362 }
16363
16364
16365 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16366 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16367 return 1;
16368 }
16369
16370
16371 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16372 PyObject *pyobj;
16373
16374 {
16375 #if wxUSE_UNICODE
16376 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16377 #else
16378 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16379 #endif
16380 }
16381 return pyobj;
16382 }
16383
16384
16385 static int _wrap_ART_COPY_set(PyObject *) {
16386 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16387 return 1;
16388 }
16389
16390
16391 static PyObject *_wrap_ART_COPY_get(void) {
16392 PyObject *pyobj;
16393
16394 {
16395 #if wxUSE_UNICODE
16396 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16397 #else
16398 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16399 #endif
16400 }
16401 return pyobj;
16402 }
16403
16404
16405 static int _wrap_ART_CUT_set(PyObject *) {
16406 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16407 return 1;
16408 }
16409
16410
16411 static PyObject *_wrap_ART_CUT_get(void) {
16412 PyObject *pyobj;
16413
16414 {
16415 #if wxUSE_UNICODE
16416 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16417 #else
16418 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16419 #endif
16420 }
16421 return pyobj;
16422 }
16423
16424
16425 static int _wrap_ART_PASTE_set(PyObject *) {
16426 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16427 return 1;
16428 }
16429
16430
16431 static PyObject *_wrap_ART_PASTE_get(void) {
16432 PyObject *pyobj;
16433
16434 {
16435 #if wxUSE_UNICODE
16436 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16437 #else
16438 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16439 #endif
16440 }
16441 return pyobj;
16442 }
16443
16444
16445 static int _wrap_ART_DELETE_set(PyObject *) {
16446 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16447 return 1;
16448 }
16449
16450
16451 static PyObject *_wrap_ART_DELETE_get(void) {
16452 PyObject *pyobj;
16453
16454 {
16455 #if wxUSE_UNICODE
16456 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16457 #else
16458 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16459 #endif
16460 }
16461 return pyobj;
16462 }
16463
16464
16465 static int _wrap_ART_NEW_set(PyObject *) {
16466 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
16467 return 1;
16468 }
16469
16470
16471 static PyObject *_wrap_ART_NEW_get(void) {
16472 PyObject *pyobj;
16473
16474 {
16475 #if wxUSE_UNICODE
16476 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16477 #else
16478 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16479 #endif
16480 }
16481 return pyobj;
16482 }
16483
16484
16485 static int _wrap_ART_UNDO_set(PyObject *) {
16486 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16487 return 1;
16488 }
16489
16490
16491 static PyObject *_wrap_ART_UNDO_get(void) {
16492 PyObject *pyobj;
16493
16494 {
16495 #if wxUSE_UNICODE
16496 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16497 #else
16498 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16499 #endif
16500 }
16501 return pyobj;
16502 }
16503
16504
16505 static int _wrap_ART_REDO_set(PyObject *) {
16506 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16507 return 1;
16508 }
16509
16510
16511 static PyObject *_wrap_ART_REDO_get(void) {
16512 PyObject *pyobj;
16513
16514 {
16515 #if wxUSE_UNICODE
16516 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16517 #else
16518 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16519 #endif
16520 }
16521 return pyobj;
16522 }
16523
16524
16525 static int _wrap_ART_QUIT_set(PyObject *) {
16526 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16527 return 1;
16528 }
16529
16530
16531 static PyObject *_wrap_ART_QUIT_get(void) {
16532 PyObject *pyobj;
16533
16534 {
16535 #if wxUSE_UNICODE
16536 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16537 #else
16538 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16539 #endif
16540 }
16541 return pyobj;
16542 }
16543
16544
16545 static int _wrap_ART_FIND_set(PyObject *) {
16546 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16547 return 1;
16548 }
16549
16550
16551 static PyObject *_wrap_ART_FIND_get(void) {
16552 PyObject *pyobj;
16553
16554 {
16555 #if wxUSE_UNICODE
16556 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16557 #else
16558 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16559 #endif
16560 }
16561 return pyobj;
16562 }
16563
16564
16565 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16566 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16567 return 1;
16568 }
16569
16570
16571 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16572 PyObject *pyobj;
16573
16574 {
16575 #if wxUSE_UNICODE
16576 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16577 #else
16578 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16579 #endif
16580 }
16581 return pyobj;
16582 }
16583
16584
16585 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16586 PyObject *resultobj;
16587 wxPyArtProvider *result;
16588 char *kwnames[] = {
16589 NULL
16590 };
16591
16592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16593 {
16594 if (!wxPyCheckForApp()) SWIG_fail;
16595 PyThreadState* __tstate = wxPyBeginAllowThreads();
16596 result = (wxPyArtProvider *)new wxPyArtProvider();
16597
16598 wxPyEndAllowThreads(__tstate);
16599 if (PyErr_Occurred()) SWIG_fail;
16600 }
16601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16602 return resultobj;
16603 fail:
16604 return NULL;
16605 }
16606
16607
16608 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16609 PyObject *resultobj;
16610 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16611 PyObject *arg2 = (PyObject *) 0 ;
16612 PyObject *arg3 = (PyObject *) 0 ;
16613 PyObject * obj0 = 0 ;
16614 PyObject * obj1 = 0 ;
16615 PyObject * obj2 = 0 ;
16616 char *kwnames[] = {
16617 (char *) "self",(char *) "self",(char *) "_class", NULL
16618 };
16619
16620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16622 if (SWIG_arg_fail(1)) SWIG_fail;
16623 arg2 = obj1;
16624 arg3 = obj2;
16625 {
16626 PyThreadState* __tstate = wxPyBeginAllowThreads();
16627 (arg1)->_setCallbackInfo(arg2,arg3);
16628
16629 wxPyEndAllowThreads(__tstate);
16630 if (PyErr_Occurred()) SWIG_fail;
16631 }
16632 Py_INCREF(Py_None); resultobj = Py_None;
16633 return resultobj;
16634 fail:
16635 return NULL;
16636 }
16637
16638
16639 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16640 PyObject *resultobj;
16641 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16642 PyObject * obj0 = 0 ;
16643 char *kwnames[] = {
16644 (char *) "provider", NULL
16645 };
16646
16647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16649 if (SWIG_arg_fail(1)) SWIG_fail;
16650 {
16651 PyThreadState* __tstate = wxPyBeginAllowThreads();
16652 wxPyArtProvider::PushProvider(arg1);
16653
16654 wxPyEndAllowThreads(__tstate);
16655 if (PyErr_Occurred()) SWIG_fail;
16656 }
16657 Py_INCREF(Py_None); resultobj = Py_None;
16658 return resultobj;
16659 fail:
16660 return NULL;
16661 }
16662
16663
16664 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16665 PyObject *resultobj;
16666 bool result;
16667 char *kwnames[] = {
16668 NULL
16669 };
16670
16671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = (bool)wxPyArtProvider::PopProvider();
16675
16676 wxPyEndAllowThreads(__tstate);
16677 if (PyErr_Occurred()) SWIG_fail;
16678 }
16679 {
16680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16681 }
16682 return resultobj;
16683 fail:
16684 return NULL;
16685 }
16686
16687
16688 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj;
16690 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16691 bool result;
16692 PyObject * obj0 = 0 ;
16693 char *kwnames[] = {
16694 (char *) "provider", NULL
16695 };
16696
16697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16699 if (SWIG_arg_fail(1)) SWIG_fail;
16700 {
16701 PyThreadState* __tstate = wxPyBeginAllowThreads();
16702 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16703
16704 wxPyEndAllowThreads(__tstate);
16705 if (PyErr_Occurred()) SWIG_fail;
16706 }
16707 {
16708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16709 }
16710 return resultobj;
16711 fail:
16712 return NULL;
16713 }
16714
16715
16716 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16717 PyObject *resultobj;
16718 wxString *arg1 = 0 ;
16719 wxString const &arg2_defvalue = wxPyART_OTHER ;
16720 wxString *arg2 = (wxString *) &arg2_defvalue ;
16721 wxSize const &arg3_defvalue = wxDefaultSize ;
16722 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16723 wxBitmap result;
16724 bool temp1 = false ;
16725 bool temp2 = false ;
16726 wxSize temp3 ;
16727 PyObject * obj0 = 0 ;
16728 PyObject * obj1 = 0 ;
16729 PyObject * obj2 = 0 ;
16730 char *kwnames[] = {
16731 (char *) "id",(char *) "client",(char *) "size", NULL
16732 };
16733
16734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16735 {
16736 arg1 = wxString_in_helper(obj0);
16737 if (arg1 == NULL) SWIG_fail;
16738 temp1 = true;
16739 }
16740 if (obj1) {
16741 {
16742 arg2 = wxString_in_helper(obj1);
16743 if (arg2 == NULL) SWIG_fail;
16744 temp2 = true;
16745 }
16746 }
16747 if (obj2) {
16748 {
16749 arg3 = &temp3;
16750 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16751 }
16752 }
16753 {
16754 if (!wxPyCheckForApp()) SWIG_fail;
16755 PyThreadState* __tstate = wxPyBeginAllowThreads();
16756 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16757
16758 wxPyEndAllowThreads(__tstate);
16759 if (PyErr_Occurred()) SWIG_fail;
16760 }
16761 {
16762 wxBitmap * resultptr;
16763 resultptr = new wxBitmap((wxBitmap &)(result));
16764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16765 }
16766 {
16767 if (temp1)
16768 delete arg1;
16769 }
16770 {
16771 if (temp2)
16772 delete arg2;
16773 }
16774 return resultobj;
16775 fail:
16776 {
16777 if (temp1)
16778 delete arg1;
16779 }
16780 {
16781 if (temp2)
16782 delete arg2;
16783 }
16784 return NULL;
16785 }
16786
16787
16788 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16789 PyObject *resultobj;
16790 wxString *arg1 = 0 ;
16791 wxString const &arg2_defvalue = wxPyART_OTHER ;
16792 wxString *arg2 = (wxString *) &arg2_defvalue ;
16793 wxSize const &arg3_defvalue = wxDefaultSize ;
16794 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16795 wxIcon result;
16796 bool temp1 = false ;
16797 bool temp2 = false ;
16798 wxSize temp3 ;
16799 PyObject * obj0 = 0 ;
16800 PyObject * obj1 = 0 ;
16801 PyObject * obj2 = 0 ;
16802 char *kwnames[] = {
16803 (char *) "id",(char *) "client",(char *) "size", NULL
16804 };
16805
16806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16807 {
16808 arg1 = wxString_in_helper(obj0);
16809 if (arg1 == NULL) SWIG_fail;
16810 temp1 = true;
16811 }
16812 if (obj1) {
16813 {
16814 arg2 = wxString_in_helper(obj1);
16815 if (arg2 == NULL) SWIG_fail;
16816 temp2 = true;
16817 }
16818 }
16819 if (obj2) {
16820 {
16821 arg3 = &temp3;
16822 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16823 }
16824 }
16825 {
16826 if (!wxPyCheckForApp()) SWIG_fail;
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16829
16830 wxPyEndAllowThreads(__tstate);
16831 if (PyErr_Occurred()) SWIG_fail;
16832 }
16833 {
16834 wxIcon * resultptr;
16835 resultptr = new wxIcon((wxIcon &)(result));
16836 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16837 }
16838 {
16839 if (temp1)
16840 delete arg1;
16841 }
16842 {
16843 if (temp2)
16844 delete arg2;
16845 }
16846 return resultobj;
16847 fail:
16848 {
16849 if (temp1)
16850 delete arg1;
16851 }
16852 {
16853 if (temp2)
16854 delete arg2;
16855 }
16856 return NULL;
16857 }
16858
16859
16860 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16861 PyObject *resultobj;
16862 wxString *arg1 = 0 ;
16863 bool arg2 = (bool) false ;
16864 wxSize result;
16865 bool temp1 = false ;
16866 PyObject * obj0 = 0 ;
16867 PyObject * obj1 = 0 ;
16868 char *kwnames[] = {
16869 (char *) "client",(char *) "platform_dependent", NULL
16870 };
16871
16872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16873 {
16874 arg1 = wxString_in_helper(obj0);
16875 if (arg1 == NULL) SWIG_fail;
16876 temp1 = true;
16877 }
16878 if (obj1) {
16879 {
16880 arg2 = (bool)(SWIG_As_bool(obj1));
16881 if (SWIG_arg_fail(2)) SWIG_fail;
16882 }
16883 }
16884 {
16885 PyThreadState* __tstate = wxPyBeginAllowThreads();
16886 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16887
16888 wxPyEndAllowThreads(__tstate);
16889 if (PyErr_Occurred()) SWIG_fail;
16890 }
16891 {
16892 wxSize * resultptr;
16893 resultptr = new wxSize((wxSize &)(result));
16894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16895 }
16896 {
16897 if (temp1)
16898 delete arg1;
16899 }
16900 return resultobj;
16901 fail:
16902 {
16903 if (temp1)
16904 delete arg1;
16905 }
16906 return NULL;
16907 }
16908
16909
16910 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16911 PyObject *resultobj;
16912 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16913 PyObject * obj0 = 0 ;
16914 char *kwnames[] = {
16915 (char *) "self", NULL
16916 };
16917
16918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16920 if (SWIG_arg_fail(1)) SWIG_fail;
16921 {
16922 PyThreadState* __tstate = wxPyBeginAllowThreads();
16923 wxPyArtProvider_Destroy(arg1);
16924
16925 wxPyEndAllowThreads(__tstate);
16926 if (PyErr_Occurred()) SWIG_fail;
16927 }
16928 Py_INCREF(Py_None); resultobj = Py_None;
16929 return resultobj;
16930 fail:
16931 return NULL;
16932 }
16933
16934
16935 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16936 PyObject *obj;
16937 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16938 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16939 Py_INCREF(obj);
16940 return Py_BuildValue((char *)"");
16941 }
16942 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16943 PyObject *resultobj;
16944 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16945 PyObject * obj0 = 0 ;
16946 char *kwnames[] = {
16947 (char *) "self", NULL
16948 };
16949
16950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16952 if (SWIG_arg_fail(1)) SWIG_fail;
16953 {
16954 PyThreadState* __tstate = wxPyBeginAllowThreads();
16955 delete arg1;
16956
16957 wxPyEndAllowThreads(__tstate);
16958 if (PyErr_Occurred()) SWIG_fail;
16959 }
16960 Py_INCREF(Py_None); resultobj = Py_None;
16961 return resultobj;
16962 fail:
16963 return NULL;
16964 }
16965
16966
16967 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16968 PyObject *resultobj;
16969 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16970 wxConfigBase *result;
16971 PyObject * obj0 = 0 ;
16972 char *kwnames[] = {
16973 (char *) "config", NULL
16974 };
16975
16976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16978 if (SWIG_arg_fail(1)) SWIG_fail;
16979 {
16980 PyThreadState* __tstate = wxPyBeginAllowThreads();
16981 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16982
16983 wxPyEndAllowThreads(__tstate);
16984 if (PyErr_Occurred()) SWIG_fail;
16985 }
16986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16987 return resultobj;
16988 fail:
16989 return NULL;
16990 }
16991
16992
16993 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16994 PyObject *resultobj;
16995 bool arg1 = (bool) true ;
16996 wxConfigBase *result;
16997 PyObject * obj0 = 0 ;
16998 char *kwnames[] = {
16999 (char *) "createOnDemand", NULL
17000 };
17001
17002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17003 if (obj0) {
17004 {
17005 arg1 = (bool)(SWIG_As_bool(obj0));
17006 if (SWIG_arg_fail(1)) SWIG_fail;
17007 }
17008 }
17009 {
17010 PyThreadState* __tstate = wxPyBeginAllowThreads();
17011 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17012
17013 wxPyEndAllowThreads(__tstate);
17014 if (PyErr_Occurred()) SWIG_fail;
17015 }
17016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17017 return resultobj;
17018 fail:
17019 return NULL;
17020 }
17021
17022
17023 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17024 PyObject *resultobj;
17025 wxConfigBase *result;
17026 char *kwnames[] = {
17027 NULL
17028 };
17029
17030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17031 {
17032 PyThreadState* __tstate = wxPyBeginAllowThreads();
17033 result = (wxConfigBase *)wxConfigBase::Create();
17034
17035 wxPyEndAllowThreads(__tstate);
17036 if (PyErr_Occurred()) SWIG_fail;
17037 }
17038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17039 return resultobj;
17040 fail:
17041 return NULL;
17042 }
17043
17044
17045 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17046 PyObject *resultobj;
17047 char *kwnames[] = {
17048 NULL
17049 };
17050
17051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17052 {
17053 PyThreadState* __tstate = wxPyBeginAllowThreads();
17054 wxConfigBase::DontCreateOnDemand();
17055
17056 wxPyEndAllowThreads(__tstate);
17057 if (PyErr_Occurred()) SWIG_fail;
17058 }
17059 Py_INCREF(Py_None); resultobj = Py_None;
17060 return resultobj;
17061 fail:
17062 return NULL;
17063 }
17064
17065
17066 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17067 PyObject *resultobj;
17068 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17069 wxString *arg2 = 0 ;
17070 bool temp2 = false ;
17071 PyObject * obj0 = 0 ;
17072 PyObject * obj1 = 0 ;
17073 char *kwnames[] = {
17074 (char *) "self",(char *) "path", NULL
17075 };
17076
17077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17079 if (SWIG_arg_fail(1)) SWIG_fail;
17080 {
17081 arg2 = wxString_in_helper(obj1);
17082 if (arg2 == NULL) SWIG_fail;
17083 temp2 = true;
17084 }
17085 {
17086 PyThreadState* __tstate = wxPyBeginAllowThreads();
17087 (arg1)->SetPath((wxString const &)*arg2);
17088
17089 wxPyEndAllowThreads(__tstate);
17090 if (PyErr_Occurred()) SWIG_fail;
17091 }
17092 Py_INCREF(Py_None); resultobj = Py_None;
17093 {
17094 if (temp2)
17095 delete arg2;
17096 }
17097 return resultobj;
17098 fail:
17099 {
17100 if (temp2)
17101 delete arg2;
17102 }
17103 return NULL;
17104 }
17105
17106
17107 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj;
17109 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17110 wxString *result;
17111 PyObject * obj0 = 0 ;
17112 char *kwnames[] = {
17113 (char *) "self", NULL
17114 };
17115
17116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17118 if (SWIG_arg_fail(1)) SWIG_fail;
17119 {
17120 PyThreadState* __tstate = wxPyBeginAllowThreads();
17121 {
17122 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17123 result = (wxString *) &_result_ref;
17124 }
17125
17126 wxPyEndAllowThreads(__tstate);
17127 if (PyErr_Occurred()) SWIG_fail;
17128 }
17129 {
17130 #if wxUSE_UNICODE
17131 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17132 #else
17133 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17134 #endif
17135 }
17136 return resultobj;
17137 fail:
17138 return NULL;
17139 }
17140
17141
17142 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17143 PyObject *resultobj;
17144 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17145 PyObject *result;
17146 PyObject * obj0 = 0 ;
17147 char *kwnames[] = {
17148 (char *) "self", NULL
17149 };
17150
17151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17153 if (SWIG_arg_fail(1)) SWIG_fail;
17154 {
17155 PyThreadState* __tstate = wxPyBeginAllowThreads();
17156 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17157
17158 wxPyEndAllowThreads(__tstate);
17159 if (PyErr_Occurred()) SWIG_fail;
17160 }
17161 resultobj = result;
17162 return resultobj;
17163 fail:
17164 return NULL;
17165 }
17166
17167
17168 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17169 PyObject *resultobj;
17170 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17171 long arg2 ;
17172 PyObject *result;
17173 PyObject * obj0 = 0 ;
17174 PyObject * obj1 = 0 ;
17175 char *kwnames[] = {
17176 (char *) "self",(char *) "index", NULL
17177 };
17178
17179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17181 if (SWIG_arg_fail(1)) SWIG_fail;
17182 {
17183 arg2 = (long)(SWIG_As_long(obj1));
17184 if (SWIG_arg_fail(2)) SWIG_fail;
17185 }
17186 {
17187 PyThreadState* __tstate = wxPyBeginAllowThreads();
17188 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17189
17190 wxPyEndAllowThreads(__tstate);
17191 if (PyErr_Occurred()) SWIG_fail;
17192 }
17193 resultobj = result;
17194 return resultobj;
17195 fail:
17196 return NULL;
17197 }
17198
17199
17200 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17201 PyObject *resultobj;
17202 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17203 PyObject *result;
17204 PyObject * obj0 = 0 ;
17205 char *kwnames[] = {
17206 (char *) "self", NULL
17207 };
17208
17209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17211 if (SWIG_arg_fail(1)) SWIG_fail;
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17215
17216 wxPyEndAllowThreads(__tstate);
17217 if (PyErr_Occurred()) SWIG_fail;
17218 }
17219 resultobj = result;
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj;
17228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17229 long arg2 ;
17230 PyObject *result;
17231 PyObject * obj0 = 0 ;
17232 PyObject * obj1 = 0 ;
17233 char *kwnames[] = {
17234 (char *) "self",(char *) "index", NULL
17235 };
17236
17237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17239 if (SWIG_arg_fail(1)) SWIG_fail;
17240 {
17241 arg2 = (long)(SWIG_As_long(obj1));
17242 if (SWIG_arg_fail(2)) SWIG_fail;
17243 }
17244 {
17245 PyThreadState* __tstate = wxPyBeginAllowThreads();
17246 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17247
17248 wxPyEndAllowThreads(__tstate);
17249 if (PyErr_Occurred()) SWIG_fail;
17250 }
17251 resultobj = result;
17252 return resultobj;
17253 fail:
17254 return NULL;
17255 }
17256
17257
17258 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17259 PyObject *resultobj;
17260 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17261 bool arg2 = (bool) false ;
17262 size_t result;
17263 PyObject * obj0 = 0 ;
17264 PyObject * obj1 = 0 ;
17265 char *kwnames[] = {
17266 (char *) "self",(char *) "recursive", NULL
17267 };
17268
17269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17271 if (SWIG_arg_fail(1)) SWIG_fail;
17272 if (obj1) {
17273 {
17274 arg2 = (bool)(SWIG_As_bool(obj1));
17275 if (SWIG_arg_fail(2)) SWIG_fail;
17276 }
17277 }
17278 {
17279 PyThreadState* __tstate = wxPyBeginAllowThreads();
17280 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17281
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 {
17286 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17287 }
17288 return resultobj;
17289 fail:
17290 return NULL;
17291 }
17292
17293
17294 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17295 PyObject *resultobj;
17296 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17297 bool arg2 = (bool) false ;
17298 size_t result;
17299 PyObject * obj0 = 0 ;
17300 PyObject * obj1 = 0 ;
17301 char *kwnames[] = {
17302 (char *) "self",(char *) "recursive", NULL
17303 };
17304
17305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",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 if (obj1) {
17309 {
17310 arg2 = (bool)(SWIG_As_bool(obj1));
17311 if (SWIG_arg_fail(2)) SWIG_fail;
17312 }
17313 }
17314 {
17315 PyThreadState* __tstate = wxPyBeginAllowThreads();
17316 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17317
17318 wxPyEndAllowThreads(__tstate);
17319 if (PyErr_Occurred()) SWIG_fail;
17320 }
17321 {
17322 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17323 }
17324 return resultobj;
17325 fail:
17326 return NULL;
17327 }
17328
17329
17330 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17331 PyObject *resultobj;
17332 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17333 wxString *arg2 = 0 ;
17334 bool result;
17335 bool temp2 = false ;
17336 PyObject * obj0 = 0 ;
17337 PyObject * obj1 = 0 ;
17338 char *kwnames[] = {
17339 (char *) "self",(char *) "name", NULL
17340 };
17341
17342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17344 if (SWIG_arg_fail(1)) SWIG_fail;
17345 {
17346 arg2 = wxString_in_helper(obj1);
17347 if (arg2 == NULL) SWIG_fail;
17348 temp2 = true;
17349 }
17350 {
17351 PyThreadState* __tstate = wxPyBeginAllowThreads();
17352 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17353
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 {
17358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17359 }
17360 {
17361 if (temp2)
17362 delete arg2;
17363 }
17364 return resultobj;
17365 fail:
17366 {
17367 if (temp2)
17368 delete arg2;
17369 }
17370 return NULL;
17371 }
17372
17373
17374 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17375 PyObject *resultobj;
17376 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17377 wxString *arg2 = 0 ;
17378 bool result;
17379 bool temp2 = false ;
17380 PyObject * obj0 = 0 ;
17381 PyObject * obj1 = 0 ;
17382 char *kwnames[] = {
17383 (char *) "self",(char *) "name", NULL
17384 };
17385
17386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17388 if (SWIG_arg_fail(1)) SWIG_fail;
17389 {
17390 arg2 = wxString_in_helper(obj1);
17391 if (arg2 == NULL) SWIG_fail;
17392 temp2 = true;
17393 }
17394 {
17395 PyThreadState* __tstate = wxPyBeginAllowThreads();
17396 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17397
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 {
17402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17403 }
17404 {
17405 if (temp2)
17406 delete arg2;
17407 }
17408 return resultobj;
17409 fail:
17410 {
17411 if (temp2)
17412 delete arg2;
17413 }
17414 return NULL;
17415 }
17416
17417
17418 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17419 PyObject *resultobj;
17420 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17421 wxString *arg2 = 0 ;
17422 bool result;
17423 bool temp2 = false ;
17424 PyObject * obj0 = 0 ;
17425 PyObject * obj1 = 0 ;
17426 char *kwnames[] = {
17427 (char *) "self",(char *) "name", NULL
17428 };
17429
17430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17432 if (SWIG_arg_fail(1)) SWIG_fail;
17433 {
17434 arg2 = wxString_in_helper(obj1);
17435 if (arg2 == NULL) SWIG_fail;
17436 temp2 = true;
17437 }
17438 {
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17441
17442 wxPyEndAllowThreads(__tstate);
17443 if (PyErr_Occurred()) SWIG_fail;
17444 }
17445 {
17446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17447 }
17448 {
17449 if (temp2)
17450 delete arg2;
17451 }
17452 return resultobj;
17453 fail:
17454 {
17455 if (temp2)
17456 delete arg2;
17457 }
17458 return NULL;
17459 }
17460
17461
17462 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17463 PyObject *resultobj;
17464 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17465 wxString *arg2 = 0 ;
17466 wxConfigBase::EntryType result;
17467 bool temp2 = false ;
17468 PyObject * obj0 = 0 ;
17469 PyObject * obj1 = 0 ;
17470 char *kwnames[] = {
17471 (char *) "self",(char *) "name", NULL
17472 };
17473
17474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17476 if (SWIG_arg_fail(1)) SWIG_fail;
17477 {
17478 arg2 = wxString_in_helper(obj1);
17479 if (arg2 == NULL) SWIG_fail;
17480 temp2 = true;
17481 }
17482 {
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17485
17486 wxPyEndAllowThreads(__tstate);
17487 if (PyErr_Occurred()) SWIG_fail;
17488 }
17489 resultobj = SWIG_From_int((result));
17490 {
17491 if (temp2)
17492 delete arg2;
17493 }
17494 return resultobj;
17495 fail:
17496 {
17497 if (temp2)
17498 delete arg2;
17499 }
17500 return NULL;
17501 }
17502
17503
17504 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17505 PyObject *resultobj;
17506 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17507 wxString *arg2 = 0 ;
17508 wxString const &arg3_defvalue = wxPyEmptyString ;
17509 wxString *arg3 = (wxString *) &arg3_defvalue ;
17510 wxString result;
17511 bool temp2 = false ;
17512 bool temp3 = 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_Read",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 = wxString_in_helper(obj2);
17531 if (arg3 == NULL) SWIG_fail;
17532 temp3 = true;
17533 }
17534 }
17535 {
17536 PyThreadState* __tstate = wxPyBeginAllowThreads();
17537 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17538
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 {
17543 #if wxUSE_UNICODE
17544 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17545 #else
17546 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17547 #endif
17548 }
17549 {
17550 if (temp2)
17551 delete arg2;
17552 }
17553 {
17554 if (temp3)
17555 delete arg3;
17556 }
17557 return resultobj;
17558 fail:
17559 {
17560 if (temp2)
17561 delete arg2;
17562 }
17563 {
17564 if (temp3)
17565 delete arg3;
17566 }
17567 return NULL;
17568 }
17569
17570
17571 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj;
17573 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17574 wxString *arg2 = 0 ;
17575 long arg3 = (long) 0 ;
17576 long result;
17577 bool temp2 = false ;
17578 PyObject * obj0 = 0 ;
17579 PyObject * obj1 = 0 ;
17580 PyObject * obj2 = 0 ;
17581 char *kwnames[] = {
17582 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17583 };
17584
17585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17587 if (SWIG_arg_fail(1)) SWIG_fail;
17588 {
17589 arg2 = wxString_in_helper(obj1);
17590 if (arg2 == NULL) SWIG_fail;
17591 temp2 = true;
17592 }
17593 if (obj2) {
17594 {
17595 arg3 = (long)(SWIG_As_long(obj2));
17596 if (SWIG_arg_fail(3)) SWIG_fail;
17597 }
17598 }
17599 {
17600 PyThreadState* __tstate = wxPyBeginAllowThreads();
17601 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17602
17603 wxPyEndAllowThreads(__tstate);
17604 if (PyErr_Occurred()) SWIG_fail;
17605 }
17606 {
17607 resultobj = SWIG_From_long((long)(result));
17608 }
17609 {
17610 if (temp2)
17611 delete arg2;
17612 }
17613 return resultobj;
17614 fail:
17615 {
17616 if (temp2)
17617 delete arg2;
17618 }
17619 return NULL;
17620 }
17621
17622
17623 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17624 PyObject *resultobj;
17625 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17626 wxString *arg2 = 0 ;
17627 double arg3 = (double) 0.0 ;
17628 double result;
17629 bool temp2 = false ;
17630 PyObject * obj0 = 0 ;
17631 PyObject * obj1 = 0 ;
17632 PyObject * obj2 = 0 ;
17633 char *kwnames[] = {
17634 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17635 };
17636
17637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17639 if (SWIG_arg_fail(1)) SWIG_fail;
17640 {
17641 arg2 = wxString_in_helper(obj1);
17642 if (arg2 == NULL) SWIG_fail;
17643 temp2 = true;
17644 }
17645 if (obj2) {
17646 {
17647 arg3 = (double)(SWIG_As_double(obj2));
17648 if (SWIG_arg_fail(3)) SWIG_fail;
17649 }
17650 }
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17654
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 {
17659 resultobj = SWIG_From_double((double)(result));
17660 }
17661 {
17662 if (temp2)
17663 delete arg2;
17664 }
17665 return resultobj;
17666 fail:
17667 {
17668 if (temp2)
17669 delete arg2;
17670 }
17671 return NULL;
17672 }
17673
17674
17675 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17676 PyObject *resultobj;
17677 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17678 wxString *arg2 = 0 ;
17679 bool arg3 = (bool) false ;
17680 bool result;
17681 bool temp2 = false ;
17682 PyObject * obj0 = 0 ;
17683 PyObject * obj1 = 0 ;
17684 PyObject * obj2 = 0 ;
17685 char *kwnames[] = {
17686 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17687 };
17688
17689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17691 if (SWIG_arg_fail(1)) SWIG_fail;
17692 {
17693 arg2 = wxString_in_helper(obj1);
17694 if (arg2 == NULL) SWIG_fail;
17695 temp2 = true;
17696 }
17697 if (obj2) {
17698 {
17699 arg3 = (bool)(SWIG_As_bool(obj2));
17700 if (SWIG_arg_fail(3)) SWIG_fail;
17701 }
17702 }
17703 {
17704 PyThreadState* __tstate = wxPyBeginAllowThreads();
17705 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17706
17707 wxPyEndAllowThreads(__tstate);
17708 if (PyErr_Occurred()) SWIG_fail;
17709 }
17710 {
17711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17712 }
17713 {
17714 if (temp2)
17715 delete arg2;
17716 }
17717 return resultobj;
17718 fail:
17719 {
17720 if (temp2)
17721 delete arg2;
17722 }
17723 return NULL;
17724 }
17725
17726
17727 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17728 PyObject *resultobj;
17729 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17730 wxString *arg2 = 0 ;
17731 wxString *arg3 = 0 ;
17732 bool result;
17733 bool temp2 = false ;
17734 bool temp3 = false ;
17735 PyObject * obj0 = 0 ;
17736 PyObject * obj1 = 0 ;
17737 PyObject * obj2 = 0 ;
17738 char *kwnames[] = {
17739 (char *) "self",(char *) "key",(char *) "value", NULL
17740 };
17741
17742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17744 if (SWIG_arg_fail(1)) SWIG_fail;
17745 {
17746 arg2 = wxString_in_helper(obj1);
17747 if (arg2 == NULL) SWIG_fail;
17748 temp2 = true;
17749 }
17750 {
17751 arg3 = wxString_in_helper(obj2);
17752 if (arg3 == NULL) SWIG_fail;
17753 temp3 = true;
17754 }
17755 {
17756 PyThreadState* __tstate = wxPyBeginAllowThreads();
17757 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17758
17759 wxPyEndAllowThreads(__tstate);
17760 if (PyErr_Occurred()) SWIG_fail;
17761 }
17762 {
17763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17764 }
17765 {
17766 if (temp2)
17767 delete arg2;
17768 }
17769 {
17770 if (temp3)
17771 delete arg3;
17772 }
17773 return resultobj;
17774 fail:
17775 {
17776 if (temp2)
17777 delete arg2;
17778 }
17779 {
17780 if (temp3)
17781 delete arg3;
17782 }
17783 return NULL;
17784 }
17785
17786
17787 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17788 PyObject *resultobj;
17789 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17790 wxString *arg2 = 0 ;
17791 long arg3 ;
17792 bool result;
17793 bool temp2 = false ;
17794 PyObject * obj0 = 0 ;
17795 PyObject * obj1 = 0 ;
17796 PyObject * obj2 = 0 ;
17797 char *kwnames[] = {
17798 (char *) "self",(char *) "key",(char *) "value", NULL
17799 };
17800
17801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17803 if (SWIG_arg_fail(1)) SWIG_fail;
17804 {
17805 arg2 = wxString_in_helper(obj1);
17806 if (arg2 == NULL) SWIG_fail;
17807 temp2 = true;
17808 }
17809 {
17810 arg3 = (long)(SWIG_As_long(obj2));
17811 if (SWIG_arg_fail(3)) SWIG_fail;
17812 }
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17816
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17822 }
17823 {
17824 if (temp2)
17825 delete arg2;
17826 }
17827 return resultobj;
17828 fail:
17829 {
17830 if (temp2)
17831 delete arg2;
17832 }
17833 return NULL;
17834 }
17835
17836
17837 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17838 PyObject *resultobj;
17839 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17840 wxString *arg2 = 0 ;
17841 double arg3 ;
17842 bool result;
17843 bool temp2 = false ;
17844 PyObject * obj0 = 0 ;
17845 PyObject * obj1 = 0 ;
17846 PyObject * obj2 = 0 ;
17847 char *kwnames[] = {
17848 (char *) "self",(char *) "key",(char *) "value", NULL
17849 };
17850
17851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17853 if (SWIG_arg_fail(1)) SWIG_fail;
17854 {
17855 arg2 = wxString_in_helper(obj1);
17856 if (arg2 == NULL) SWIG_fail;
17857 temp2 = true;
17858 }
17859 {
17860 arg3 = (double)(SWIG_As_double(obj2));
17861 if (SWIG_arg_fail(3)) SWIG_fail;
17862 }
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17866
17867 wxPyEndAllowThreads(__tstate);
17868 if (PyErr_Occurred()) SWIG_fail;
17869 }
17870 {
17871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17872 }
17873 {
17874 if (temp2)
17875 delete arg2;
17876 }
17877 return resultobj;
17878 fail:
17879 {
17880 if (temp2)
17881 delete arg2;
17882 }
17883 return NULL;
17884 }
17885
17886
17887 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17888 PyObject *resultobj;
17889 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17890 wxString *arg2 = 0 ;
17891 bool arg3 ;
17892 bool result;
17893 bool temp2 = false ;
17894 PyObject * obj0 = 0 ;
17895 PyObject * obj1 = 0 ;
17896 PyObject * obj2 = 0 ;
17897 char *kwnames[] = {
17898 (char *) "self",(char *) "key",(char *) "value", NULL
17899 };
17900
17901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17903 if (SWIG_arg_fail(1)) SWIG_fail;
17904 {
17905 arg2 = wxString_in_helper(obj1);
17906 if (arg2 == NULL) SWIG_fail;
17907 temp2 = true;
17908 }
17909 {
17910 arg3 = (bool)(SWIG_As_bool(obj2));
17911 if (SWIG_arg_fail(3)) SWIG_fail;
17912 }
17913 {
17914 PyThreadState* __tstate = wxPyBeginAllowThreads();
17915 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17916
17917 wxPyEndAllowThreads(__tstate);
17918 if (PyErr_Occurred()) SWIG_fail;
17919 }
17920 {
17921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17922 }
17923 {
17924 if (temp2)
17925 delete arg2;
17926 }
17927 return resultobj;
17928 fail:
17929 {
17930 if (temp2)
17931 delete arg2;
17932 }
17933 return NULL;
17934 }
17935
17936
17937 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj;
17939 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17940 bool arg2 = (bool) false ;
17941 bool result;
17942 PyObject * obj0 = 0 ;
17943 PyObject * obj1 = 0 ;
17944 char *kwnames[] = {
17945 (char *) "self",(char *) "currentOnly", NULL
17946 };
17947
17948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17950 if (SWIG_arg_fail(1)) SWIG_fail;
17951 if (obj1) {
17952 {
17953 arg2 = (bool)(SWIG_As_bool(obj1));
17954 if (SWIG_arg_fail(2)) SWIG_fail;
17955 }
17956 }
17957 {
17958 PyThreadState* __tstate = wxPyBeginAllowThreads();
17959 result = (bool)(arg1)->Flush(arg2);
17960
17961 wxPyEndAllowThreads(__tstate);
17962 if (PyErr_Occurred()) SWIG_fail;
17963 }
17964 {
17965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17966 }
17967 return resultobj;
17968 fail:
17969 return NULL;
17970 }
17971
17972
17973 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17974 PyObject *resultobj;
17975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17976 wxString *arg2 = 0 ;
17977 wxString *arg3 = 0 ;
17978 bool result;
17979 bool temp2 = false ;
17980 bool temp3 = false ;
17981 PyObject * obj0 = 0 ;
17982 PyObject * obj1 = 0 ;
17983 PyObject * obj2 = 0 ;
17984 char *kwnames[] = {
17985 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17986 };
17987
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = wxString_in_helper(obj2);
17998 if (arg3 == NULL) SWIG_fail;
17999 temp3 = true;
18000 }
18001 {
18002 PyThreadState* __tstate = wxPyBeginAllowThreads();
18003 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18004
18005 wxPyEndAllowThreads(__tstate);
18006 if (PyErr_Occurred()) SWIG_fail;
18007 }
18008 {
18009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18010 }
18011 {
18012 if (temp2)
18013 delete arg2;
18014 }
18015 {
18016 if (temp3)
18017 delete arg3;
18018 }
18019 return resultobj;
18020 fail:
18021 {
18022 if (temp2)
18023 delete arg2;
18024 }
18025 {
18026 if (temp3)
18027 delete arg3;
18028 }
18029 return NULL;
18030 }
18031
18032
18033 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj;
18035 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18036 wxString *arg2 = 0 ;
18037 wxString *arg3 = 0 ;
18038 bool result;
18039 bool temp2 = false ;
18040 bool temp3 = false ;
18041 PyObject * obj0 = 0 ;
18042 PyObject * obj1 = 0 ;
18043 PyObject * obj2 = 0 ;
18044 char *kwnames[] = {
18045 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18046 };
18047
18048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18050 if (SWIG_arg_fail(1)) SWIG_fail;
18051 {
18052 arg2 = wxString_in_helper(obj1);
18053 if (arg2 == NULL) SWIG_fail;
18054 temp2 = true;
18055 }
18056 {
18057 arg3 = wxString_in_helper(obj2);
18058 if (arg3 == NULL) SWIG_fail;
18059 temp3 = true;
18060 }
18061 {
18062 PyThreadState* __tstate = wxPyBeginAllowThreads();
18063 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18064
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 {
18069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18070 }
18071 {
18072 if (temp2)
18073 delete arg2;
18074 }
18075 {
18076 if (temp3)
18077 delete arg3;
18078 }
18079 return resultobj;
18080 fail:
18081 {
18082 if (temp2)
18083 delete arg2;
18084 }
18085 {
18086 if (temp3)
18087 delete arg3;
18088 }
18089 return NULL;
18090 }
18091
18092
18093 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj;
18095 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18096 wxString *arg2 = 0 ;
18097 bool arg3 = (bool) true ;
18098 bool result;
18099 bool temp2 = false ;
18100 PyObject * obj0 = 0 ;
18101 PyObject * obj1 = 0 ;
18102 PyObject * obj2 = 0 ;
18103 char *kwnames[] = {
18104 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18105 };
18106
18107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18109 if (SWIG_arg_fail(1)) SWIG_fail;
18110 {
18111 arg2 = wxString_in_helper(obj1);
18112 if (arg2 == NULL) SWIG_fail;
18113 temp2 = true;
18114 }
18115 if (obj2) {
18116 {
18117 arg3 = (bool)(SWIG_As_bool(obj2));
18118 if (SWIG_arg_fail(3)) SWIG_fail;
18119 }
18120 }
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18124
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 {
18129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18130 }
18131 {
18132 if (temp2)
18133 delete arg2;
18134 }
18135 return resultobj;
18136 fail:
18137 {
18138 if (temp2)
18139 delete arg2;
18140 }
18141 return NULL;
18142 }
18143
18144
18145 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18146 PyObject *resultobj;
18147 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18148 wxString *arg2 = 0 ;
18149 bool result;
18150 bool temp2 = false ;
18151 PyObject * obj0 = 0 ;
18152 PyObject * obj1 = 0 ;
18153 char *kwnames[] = {
18154 (char *) "self",(char *) "key", NULL
18155 };
18156
18157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18159 if (SWIG_arg_fail(1)) SWIG_fail;
18160 {
18161 arg2 = wxString_in_helper(obj1);
18162 if (arg2 == NULL) SWIG_fail;
18163 temp2 = true;
18164 }
18165 {
18166 PyThreadState* __tstate = wxPyBeginAllowThreads();
18167 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18168
18169 wxPyEndAllowThreads(__tstate);
18170 if (PyErr_Occurred()) SWIG_fail;
18171 }
18172 {
18173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18174 }
18175 {
18176 if (temp2)
18177 delete arg2;
18178 }
18179 return resultobj;
18180 fail:
18181 {
18182 if (temp2)
18183 delete arg2;
18184 }
18185 return NULL;
18186 }
18187
18188
18189 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18190 PyObject *resultobj;
18191 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18192 bool result;
18193 PyObject * obj0 = 0 ;
18194 char *kwnames[] = {
18195 (char *) "self", NULL
18196 };
18197
18198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18200 if (SWIG_arg_fail(1)) SWIG_fail;
18201 {
18202 PyThreadState* __tstate = wxPyBeginAllowThreads();
18203 result = (bool)(arg1)->DeleteAll();
18204
18205 wxPyEndAllowThreads(__tstate);
18206 if (PyErr_Occurred()) SWIG_fail;
18207 }
18208 {
18209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18210 }
18211 return resultobj;
18212 fail:
18213 return NULL;
18214 }
18215
18216
18217 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18218 PyObject *resultobj;
18219 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18220 bool arg2 = (bool) true ;
18221 PyObject * obj0 = 0 ;
18222 PyObject * obj1 = 0 ;
18223 char *kwnames[] = {
18224 (char *) "self",(char *) "doIt", NULL
18225 };
18226
18227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) 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 if (obj1) {
18231 {
18232 arg2 = (bool)(SWIG_As_bool(obj1));
18233 if (SWIG_arg_fail(2)) SWIG_fail;
18234 }
18235 }
18236 {
18237 PyThreadState* __tstate = wxPyBeginAllowThreads();
18238 (arg1)->SetExpandEnvVars(arg2);
18239
18240 wxPyEndAllowThreads(__tstate);
18241 if (PyErr_Occurred()) SWIG_fail;
18242 }
18243 Py_INCREF(Py_None); resultobj = Py_None;
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18251 PyObject *resultobj;
18252 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18253 bool result;
18254 PyObject * obj0 = 0 ;
18255 char *kwnames[] = {
18256 (char *) "self", NULL
18257 };
18258
18259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",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 = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18265
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 {
18270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18271 }
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj;
18280 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18281 bool arg2 = (bool) true ;
18282 PyObject * obj0 = 0 ;
18283 PyObject * obj1 = 0 ;
18284 char *kwnames[] = {
18285 (char *) "self",(char *) "doIt", NULL
18286 };
18287
18288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18290 if (SWIG_arg_fail(1)) SWIG_fail;
18291 if (obj1) {
18292 {
18293 arg2 = (bool)(SWIG_As_bool(obj1));
18294 if (SWIG_arg_fail(2)) SWIG_fail;
18295 }
18296 }
18297 {
18298 PyThreadState* __tstate = wxPyBeginAllowThreads();
18299 (arg1)->SetRecordDefaults(arg2);
18300
18301 wxPyEndAllowThreads(__tstate);
18302 if (PyErr_Occurred()) SWIG_fail;
18303 }
18304 Py_INCREF(Py_None); resultobj = Py_None;
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18312 PyObject *resultobj;
18313 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18314 bool result;
18315 PyObject * obj0 = 0 ;
18316 char *kwnames[] = {
18317 (char *) "self", NULL
18318 };
18319
18320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18322 if (SWIG_arg_fail(1)) SWIG_fail;
18323 {
18324 PyThreadState* __tstate = wxPyBeginAllowThreads();
18325 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18326
18327 wxPyEndAllowThreads(__tstate);
18328 if (PyErr_Occurred()) SWIG_fail;
18329 }
18330 {
18331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18332 }
18333 return resultobj;
18334 fail:
18335 return NULL;
18336 }
18337
18338
18339 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18340 PyObject *resultobj;
18341 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18342 wxString *arg2 = 0 ;
18343 wxString result;
18344 bool temp2 = false ;
18345 PyObject * obj0 = 0 ;
18346 PyObject * obj1 = 0 ;
18347 char *kwnames[] = {
18348 (char *) "self",(char *) "str", NULL
18349 };
18350
18351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18353 if (SWIG_arg_fail(1)) SWIG_fail;
18354 {
18355 arg2 = wxString_in_helper(obj1);
18356 if (arg2 == NULL) SWIG_fail;
18357 temp2 = true;
18358 }
18359 {
18360 PyThreadState* __tstate = wxPyBeginAllowThreads();
18361 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18362
18363 wxPyEndAllowThreads(__tstate);
18364 if (PyErr_Occurred()) SWIG_fail;
18365 }
18366 {
18367 #if wxUSE_UNICODE
18368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18369 #else
18370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18371 #endif
18372 }
18373 {
18374 if (temp2)
18375 delete arg2;
18376 }
18377 return resultobj;
18378 fail:
18379 {
18380 if (temp2)
18381 delete arg2;
18382 }
18383 return NULL;
18384 }
18385
18386
18387 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj;
18389 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18390 wxString result;
18391 PyObject * obj0 = 0 ;
18392 char *kwnames[] = {
18393 (char *) "self", NULL
18394 };
18395
18396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18398 if (SWIG_arg_fail(1)) SWIG_fail;
18399 {
18400 PyThreadState* __tstate = wxPyBeginAllowThreads();
18401 result = ((wxConfigBase const *)arg1)->GetAppName();
18402
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 {
18407 #if wxUSE_UNICODE
18408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18409 #else
18410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18411 #endif
18412 }
18413 return resultobj;
18414 fail:
18415 return NULL;
18416 }
18417
18418
18419 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18420 PyObject *resultobj;
18421 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18422 wxString result;
18423 PyObject * obj0 = 0 ;
18424 char *kwnames[] = {
18425 (char *) "self", NULL
18426 };
18427
18428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18430 if (SWIG_arg_fail(1)) SWIG_fail;
18431 {
18432 PyThreadState* __tstate = wxPyBeginAllowThreads();
18433 result = ((wxConfigBase const *)arg1)->GetVendorName();
18434
18435 wxPyEndAllowThreads(__tstate);
18436 if (PyErr_Occurred()) SWIG_fail;
18437 }
18438 {
18439 #if wxUSE_UNICODE
18440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18441 #else
18442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18443 #endif
18444 }
18445 return resultobj;
18446 fail:
18447 return NULL;
18448 }
18449
18450
18451 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18452 PyObject *resultobj;
18453 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18454 wxString *arg2 = 0 ;
18455 bool temp2 = false ;
18456 PyObject * obj0 = 0 ;
18457 PyObject * obj1 = 0 ;
18458 char *kwnames[] = {
18459 (char *) "self",(char *) "appName", NULL
18460 };
18461
18462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18464 if (SWIG_arg_fail(1)) SWIG_fail;
18465 {
18466 arg2 = wxString_in_helper(obj1);
18467 if (arg2 == NULL) SWIG_fail;
18468 temp2 = true;
18469 }
18470 {
18471 PyThreadState* __tstate = wxPyBeginAllowThreads();
18472 (arg1)->SetAppName((wxString const &)*arg2);
18473
18474 wxPyEndAllowThreads(__tstate);
18475 if (PyErr_Occurred()) SWIG_fail;
18476 }
18477 Py_INCREF(Py_None); resultobj = Py_None;
18478 {
18479 if (temp2)
18480 delete arg2;
18481 }
18482 return resultobj;
18483 fail:
18484 {
18485 if (temp2)
18486 delete arg2;
18487 }
18488 return NULL;
18489 }
18490
18491
18492 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18493 PyObject *resultobj;
18494 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18495 wxString *arg2 = 0 ;
18496 bool temp2 = false ;
18497 PyObject * obj0 = 0 ;
18498 PyObject * obj1 = 0 ;
18499 char *kwnames[] = {
18500 (char *) "self",(char *) "vendorName", NULL
18501 };
18502
18503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18505 if (SWIG_arg_fail(1)) SWIG_fail;
18506 {
18507 arg2 = wxString_in_helper(obj1);
18508 if (arg2 == NULL) SWIG_fail;
18509 temp2 = true;
18510 }
18511 {
18512 PyThreadState* __tstate = wxPyBeginAllowThreads();
18513 (arg1)->SetVendorName((wxString const &)*arg2);
18514
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 Py_INCREF(Py_None); resultobj = Py_None;
18519 {
18520 if (temp2)
18521 delete arg2;
18522 }
18523 return resultobj;
18524 fail:
18525 {
18526 if (temp2)
18527 delete arg2;
18528 }
18529 return NULL;
18530 }
18531
18532
18533 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18534 PyObject *resultobj;
18535 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18536 long arg2 ;
18537 PyObject * obj0 = 0 ;
18538 PyObject * obj1 = 0 ;
18539 char *kwnames[] = {
18540 (char *) "self",(char *) "style", NULL
18541 };
18542
18543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18545 if (SWIG_arg_fail(1)) SWIG_fail;
18546 {
18547 arg2 = (long)(SWIG_As_long(obj1));
18548 if (SWIG_arg_fail(2)) SWIG_fail;
18549 }
18550 {
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 (arg1)->SetStyle(arg2);
18553
18554 wxPyEndAllowThreads(__tstate);
18555 if (PyErr_Occurred()) SWIG_fail;
18556 }
18557 Py_INCREF(Py_None); resultobj = Py_None;
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18565 PyObject *resultobj;
18566 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18567 long result;
18568 PyObject * obj0 = 0 ;
18569 char *kwnames[] = {
18570 (char *) "self", NULL
18571 };
18572
18573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18575 if (SWIG_arg_fail(1)) SWIG_fail;
18576 {
18577 PyThreadState* __tstate = wxPyBeginAllowThreads();
18578 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18579
18580 wxPyEndAllowThreads(__tstate);
18581 if (PyErr_Occurred()) SWIG_fail;
18582 }
18583 {
18584 resultobj = SWIG_From_long((long)(result));
18585 }
18586 return resultobj;
18587 fail:
18588 return NULL;
18589 }
18590
18591
18592 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18593 PyObject *obj;
18594 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18595 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18596 Py_INCREF(obj);
18597 return Py_BuildValue((char *)"");
18598 }
18599 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18600 PyObject *resultobj;
18601 wxString const &arg1_defvalue = wxPyEmptyString ;
18602 wxString *arg1 = (wxString *) &arg1_defvalue ;
18603 wxString const &arg2_defvalue = wxPyEmptyString ;
18604 wxString *arg2 = (wxString *) &arg2_defvalue ;
18605 wxString const &arg3_defvalue = wxPyEmptyString ;
18606 wxString *arg3 = (wxString *) &arg3_defvalue ;
18607 wxString const &arg4_defvalue = wxPyEmptyString ;
18608 wxString *arg4 = (wxString *) &arg4_defvalue ;
18609 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18610 wxConfig *result;
18611 bool temp1 = false ;
18612 bool temp2 = false ;
18613 bool temp3 = false ;
18614 bool temp4 = false ;
18615 PyObject * obj0 = 0 ;
18616 PyObject * obj1 = 0 ;
18617 PyObject * obj2 = 0 ;
18618 PyObject * obj3 = 0 ;
18619 PyObject * obj4 = 0 ;
18620 char *kwnames[] = {
18621 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18622 };
18623
18624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18625 if (obj0) {
18626 {
18627 arg1 = wxString_in_helper(obj0);
18628 if (arg1 == NULL) SWIG_fail;
18629 temp1 = true;
18630 }
18631 }
18632 if (obj1) {
18633 {
18634 arg2 = wxString_in_helper(obj1);
18635 if (arg2 == NULL) SWIG_fail;
18636 temp2 = true;
18637 }
18638 }
18639 if (obj2) {
18640 {
18641 arg3 = wxString_in_helper(obj2);
18642 if (arg3 == NULL) SWIG_fail;
18643 temp3 = true;
18644 }
18645 }
18646 if (obj3) {
18647 {
18648 arg4 = wxString_in_helper(obj3);
18649 if (arg4 == NULL) SWIG_fail;
18650 temp4 = true;
18651 }
18652 }
18653 if (obj4) {
18654 {
18655 arg5 = (long)(SWIG_As_long(obj4));
18656 if (SWIG_arg_fail(5)) SWIG_fail;
18657 }
18658 }
18659 {
18660 PyThreadState* __tstate = wxPyBeginAllowThreads();
18661 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18662
18663 wxPyEndAllowThreads(__tstate);
18664 if (PyErr_Occurred()) SWIG_fail;
18665 }
18666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18667 {
18668 if (temp1)
18669 delete arg1;
18670 }
18671 {
18672 if (temp2)
18673 delete arg2;
18674 }
18675 {
18676 if (temp3)
18677 delete arg3;
18678 }
18679 {
18680 if (temp4)
18681 delete arg4;
18682 }
18683 return resultobj;
18684 fail:
18685 {
18686 if (temp1)
18687 delete arg1;
18688 }
18689 {
18690 if (temp2)
18691 delete arg2;
18692 }
18693 {
18694 if (temp3)
18695 delete arg3;
18696 }
18697 {
18698 if (temp4)
18699 delete arg4;
18700 }
18701 return NULL;
18702 }
18703
18704
18705 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18706 PyObject *resultobj;
18707 wxConfig *arg1 = (wxConfig *) 0 ;
18708 PyObject * obj0 = 0 ;
18709 char *kwnames[] = {
18710 (char *) "self", NULL
18711 };
18712
18713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18715 if (SWIG_arg_fail(1)) SWIG_fail;
18716 {
18717 PyThreadState* __tstate = wxPyBeginAllowThreads();
18718 delete arg1;
18719
18720 wxPyEndAllowThreads(__tstate);
18721 if (PyErr_Occurred()) SWIG_fail;
18722 }
18723 Py_INCREF(Py_None); resultobj = Py_None;
18724 return resultobj;
18725 fail:
18726 return NULL;
18727 }
18728
18729
18730 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18731 PyObject *obj;
18732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18733 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18734 Py_INCREF(obj);
18735 return Py_BuildValue((char *)"");
18736 }
18737 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18738 PyObject *resultobj;
18739 wxString const &arg1_defvalue = wxPyEmptyString ;
18740 wxString *arg1 = (wxString *) &arg1_defvalue ;
18741 wxString const &arg2_defvalue = wxPyEmptyString ;
18742 wxString *arg2 = (wxString *) &arg2_defvalue ;
18743 wxString const &arg3_defvalue = wxPyEmptyString ;
18744 wxString *arg3 = (wxString *) &arg3_defvalue ;
18745 wxString const &arg4_defvalue = wxPyEmptyString ;
18746 wxString *arg4 = (wxString *) &arg4_defvalue ;
18747 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18748 wxFileConfig *result;
18749 bool temp1 = false ;
18750 bool temp2 = false ;
18751 bool temp3 = false ;
18752 bool temp4 = false ;
18753 PyObject * obj0 = 0 ;
18754 PyObject * obj1 = 0 ;
18755 PyObject * obj2 = 0 ;
18756 PyObject * obj3 = 0 ;
18757 PyObject * obj4 = 0 ;
18758 char *kwnames[] = {
18759 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18760 };
18761
18762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18763 if (obj0) {
18764 {
18765 arg1 = wxString_in_helper(obj0);
18766 if (arg1 == NULL) SWIG_fail;
18767 temp1 = true;
18768 }
18769 }
18770 if (obj1) {
18771 {
18772 arg2 = wxString_in_helper(obj1);
18773 if (arg2 == NULL) SWIG_fail;
18774 temp2 = true;
18775 }
18776 }
18777 if (obj2) {
18778 {
18779 arg3 = wxString_in_helper(obj2);
18780 if (arg3 == NULL) SWIG_fail;
18781 temp3 = true;
18782 }
18783 }
18784 if (obj3) {
18785 {
18786 arg4 = wxString_in_helper(obj3);
18787 if (arg4 == NULL) SWIG_fail;
18788 temp4 = true;
18789 }
18790 }
18791 if (obj4) {
18792 {
18793 arg5 = (long)(SWIG_As_long(obj4));
18794 if (SWIG_arg_fail(5)) SWIG_fail;
18795 }
18796 }
18797 {
18798 PyThreadState* __tstate = wxPyBeginAllowThreads();
18799 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18800
18801 wxPyEndAllowThreads(__tstate);
18802 if (PyErr_Occurred()) SWIG_fail;
18803 }
18804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18805 {
18806 if (temp1)
18807 delete arg1;
18808 }
18809 {
18810 if (temp2)
18811 delete arg2;
18812 }
18813 {
18814 if (temp3)
18815 delete arg3;
18816 }
18817 {
18818 if (temp4)
18819 delete arg4;
18820 }
18821 return resultobj;
18822 fail:
18823 {
18824 if (temp1)
18825 delete arg1;
18826 }
18827 {
18828 if (temp2)
18829 delete arg2;
18830 }
18831 {
18832 if (temp3)
18833 delete arg3;
18834 }
18835 {
18836 if (temp4)
18837 delete arg4;
18838 }
18839 return NULL;
18840 }
18841
18842
18843 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj;
18845 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18846 PyObject * obj0 = 0 ;
18847 char *kwnames[] = {
18848 (char *) "self", NULL
18849 };
18850
18851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18853 if (SWIG_arg_fail(1)) SWIG_fail;
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 delete arg1;
18857
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 Py_INCREF(Py_None); resultobj = Py_None;
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18869 PyObject *obj;
18870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18871 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18872 Py_INCREF(obj);
18873 return Py_BuildValue((char *)"");
18874 }
18875 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18876 PyObject *resultobj;
18877 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18878 wxString *arg2 = 0 ;
18879 wxConfigPathChanger *result;
18880 bool temp2 = false ;
18881 PyObject * obj0 = 0 ;
18882 PyObject * obj1 = 0 ;
18883 char *kwnames[] = {
18884 (char *) "config",(char *) "entry", NULL
18885 };
18886
18887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18889 if (SWIG_arg_fail(1)) SWIG_fail;
18890 {
18891 arg2 = wxString_in_helper(obj1);
18892 if (arg2 == NULL) SWIG_fail;
18893 temp2 = true;
18894 }
18895 {
18896 PyThreadState* __tstate = wxPyBeginAllowThreads();
18897 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18898
18899 wxPyEndAllowThreads(__tstate);
18900 if (PyErr_Occurred()) SWIG_fail;
18901 }
18902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18903 {
18904 if (temp2)
18905 delete arg2;
18906 }
18907 return resultobj;
18908 fail:
18909 {
18910 if (temp2)
18911 delete arg2;
18912 }
18913 return NULL;
18914 }
18915
18916
18917 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18918 PyObject *resultobj;
18919 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18920 PyObject * obj0 = 0 ;
18921 char *kwnames[] = {
18922 (char *) "self", NULL
18923 };
18924
18925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18927 if (SWIG_arg_fail(1)) SWIG_fail;
18928 {
18929 PyThreadState* __tstate = wxPyBeginAllowThreads();
18930 delete arg1;
18931
18932 wxPyEndAllowThreads(__tstate);
18933 if (PyErr_Occurred()) SWIG_fail;
18934 }
18935 Py_INCREF(Py_None); resultobj = Py_None;
18936 return resultobj;
18937 fail:
18938 return NULL;
18939 }
18940
18941
18942 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18943 PyObject *resultobj;
18944 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18945 wxString *result;
18946 PyObject * obj0 = 0 ;
18947 char *kwnames[] = {
18948 (char *) "self", NULL
18949 };
18950
18951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18953 if (SWIG_arg_fail(1)) SWIG_fail;
18954 {
18955 PyThreadState* __tstate = wxPyBeginAllowThreads();
18956 {
18957 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18958 result = (wxString *) &_result_ref;
18959 }
18960
18961 wxPyEndAllowThreads(__tstate);
18962 if (PyErr_Occurred()) SWIG_fail;
18963 }
18964 {
18965 #if wxUSE_UNICODE
18966 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18967 #else
18968 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18969 #endif
18970 }
18971 return resultobj;
18972 fail:
18973 return NULL;
18974 }
18975
18976
18977 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18978 PyObject *obj;
18979 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18980 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18981 Py_INCREF(obj);
18982 return Py_BuildValue((char *)"");
18983 }
18984 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18985 PyObject *resultobj;
18986 wxString *arg1 = 0 ;
18987 wxString result;
18988 bool temp1 = false ;
18989 PyObject * obj0 = 0 ;
18990 char *kwnames[] = {
18991 (char *) "sz", NULL
18992 };
18993
18994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18995 {
18996 arg1 = wxString_in_helper(obj0);
18997 if (arg1 == NULL) SWIG_fail;
18998 temp1 = true;
18999 }
19000 {
19001 PyThreadState* __tstate = wxPyBeginAllowThreads();
19002 result = wxExpandEnvVars((wxString const &)*arg1);
19003
19004 wxPyEndAllowThreads(__tstate);
19005 if (PyErr_Occurred()) SWIG_fail;
19006 }
19007 {
19008 #if wxUSE_UNICODE
19009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19010 #else
19011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19012 #endif
19013 }
19014 {
19015 if (temp1)
19016 delete arg1;
19017 }
19018 return resultobj;
19019 fail:
19020 {
19021 if (temp1)
19022 delete arg1;
19023 }
19024 return NULL;
19025 }
19026
19027
19028 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19029 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19030 return 1;
19031 }
19032
19033
19034 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19035 PyObject *pyobj;
19036
19037 {
19038 #if wxUSE_UNICODE
19039 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19040 #else
19041 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19042 #endif
19043 }
19044 return pyobj;
19045 }
19046
19047
19048 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19049 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19050 return 1;
19051 }
19052
19053
19054 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19055 PyObject *pyobj;
19056
19057 {
19058 #if wxUSE_UNICODE
19059 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19060 #else
19061 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19062 #endif
19063 }
19064 return pyobj;
19065 }
19066
19067
19068 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj;
19070 wxDateTime::Country arg1 ;
19071 PyObject * obj0 = 0 ;
19072 char *kwnames[] = {
19073 (char *) "country", NULL
19074 };
19075
19076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19077 {
19078 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19079 if (SWIG_arg_fail(1)) SWIG_fail;
19080 }
19081 {
19082 PyThreadState* __tstate = wxPyBeginAllowThreads();
19083 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19084
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 Py_INCREF(Py_None); resultobj = Py_None;
19089 return resultobj;
19090 fail:
19091 return NULL;
19092 }
19093
19094
19095 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19096 PyObject *resultobj;
19097 wxDateTime::Country result;
19098 char *kwnames[] = {
19099 NULL
19100 };
19101
19102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 result = (wxDateTime::Country)wxDateTime::GetCountry();
19106
19107 wxPyEndAllowThreads(__tstate);
19108 if (PyErr_Occurred()) SWIG_fail;
19109 }
19110 resultobj = SWIG_From_int((result));
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj;
19119 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19120 bool result;
19121 PyObject * obj0 = 0 ;
19122 char *kwnames[] = {
19123 (char *) "country", NULL
19124 };
19125
19126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19127 if (obj0) {
19128 {
19129 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19130 if (SWIG_arg_fail(1)) SWIG_fail;
19131 }
19132 }
19133 {
19134 PyThreadState* __tstate = wxPyBeginAllowThreads();
19135 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19136
19137 wxPyEndAllowThreads(__tstate);
19138 if (PyErr_Occurred()) SWIG_fail;
19139 }
19140 {
19141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19142 }
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj;
19151 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19152 int result;
19153 PyObject * obj0 = 0 ;
19154 char *kwnames[] = {
19155 (char *) "cal", NULL
19156 };
19157
19158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19159 if (obj0) {
19160 {
19161 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19162 if (SWIG_arg_fail(1)) SWIG_fail;
19163 }
19164 }
19165 {
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19168
19169 wxPyEndAllowThreads(__tstate);
19170 if (PyErr_Occurred()) SWIG_fail;
19171 }
19172 {
19173 resultobj = SWIG_From_int((int)(result));
19174 }
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19182 PyObject *resultobj;
19183 int arg1 ;
19184 int result;
19185 PyObject * obj0 = 0 ;
19186 char *kwnames[] = {
19187 (char *) "year", NULL
19188 };
19189
19190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19191 {
19192 arg1 = (int)(SWIG_As_int(obj0));
19193 if (SWIG_arg_fail(1)) SWIG_fail;
19194 }
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (int)wxDateTime::ConvertYearToBC(arg1);
19198
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 {
19203 resultobj = SWIG_From_int((int)(result));
19204 }
19205 return resultobj;
19206 fail:
19207 return NULL;
19208 }
19209
19210
19211 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj;
19213 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19214 wxDateTime::Month result;
19215 PyObject * obj0 = 0 ;
19216 char *kwnames[] = {
19217 (char *) "cal", NULL
19218 };
19219
19220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19221 if (obj0) {
19222 {
19223 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19224 if (SWIG_arg_fail(1)) SWIG_fail;
19225 }
19226 }
19227 {
19228 PyThreadState* __tstate = wxPyBeginAllowThreads();
19229 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19230
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_From_int((result));
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19242 PyObject *resultobj;
19243 int arg1 = (int) wxDateTime::Inv_Year ;
19244 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19245 bool result;
19246 PyObject * obj0 = 0 ;
19247 PyObject * obj1 = 0 ;
19248 char *kwnames[] = {
19249 (char *) "year",(char *) "cal", NULL
19250 };
19251
19252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19253 if (obj0) {
19254 {
19255 arg1 = (int)(SWIG_As_int(obj0));
19256 if (SWIG_arg_fail(1)) SWIG_fail;
19257 }
19258 }
19259 if (obj1) {
19260 {
19261 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19262 if (SWIG_arg_fail(2)) SWIG_fail;
19263 }
19264 }
19265 {
19266 PyThreadState* __tstate = wxPyBeginAllowThreads();
19267 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19268
19269 wxPyEndAllowThreads(__tstate);
19270 if (PyErr_Occurred()) SWIG_fail;
19271 }
19272 {
19273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19274 }
19275 return resultobj;
19276 fail:
19277 return NULL;
19278 }
19279
19280
19281 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19282 PyObject *resultobj;
19283 int arg1 = (int) wxDateTime::Inv_Year ;
19284 int result;
19285 PyObject * obj0 = 0 ;
19286 char *kwnames[] = {
19287 (char *) "year", NULL
19288 };
19289
19290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19291 if (obj0) {
19292 {
19293 arg1 = (int)(SWIG_As_int(obj0));
19294 if (SWIG_arg_fail(1)) SWIG_fail;
19295 }
19296 }
19297 {
19298 PyThreadState* __tstate = wxPyBeginAllowThreads();
19299 result = (int)wxDateTime::GetCentury(arg1);
19300
19301 wxPyEndAllowThreads(__tstate);
19302 if (PyErr_Occurred()) SWIG_fail;
19303 }
19304 {
19305 resultobj = SWIG_From_int((int)(result));
19306 }
19307 return resultobj;
19308 fail:
19309 return NULL;
19310 }
19311
19312
19313 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19314 PyObject *resultobj;
19315 int arg1 ;
19316 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19317 int result;
19318 PyObject * obj0 = 0 ;
19319 PyObject * obj1 = 0 ;
19320 char *kwnames[] = {
19321 (char *) "year",(char *) "cal", NULL
19322 };
19323
19324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19325 {
19326 arg1 = (int)(SWIG_As_int(obj0));
19327 if (SWIG_arg_fail(1)) SWIG_fail;
19328 }
19329 if (obj1) {
19330 {
19331 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19332 if (SWIG_arg_fail(2)) SWIG_fail;
19333 }
19334 }
19335 {
19336 PyThreadState* __tstate = wxPyBeginAllowThreads();
19337 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19338
19339 wxPyEndAllowThreads(__tstate);
19340 if (PyErr_Occurred()) SWIG_fail;
19341 }
19342 {
19343 resultobj = SWIG_From_int((int)(result));
19344 }
19345 return resultobj;
19346 fail:
19347 return NULL;
19348 }
19349
19350
19351 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19352 PyObject *resultobj;
19353 wxDateTime::Month arg1 ;
19354 int arg2 = (int) wxDateTime::Inv_Year ;
19355 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19356 int result;
19357 PyObject * obj0 = 0 ;
19358 PyObject * obj1 = 0 ;
19359 PyObject * obj2 = 0 ;
19360 char *kwnames[] = {
19361 (char *) "month",(char *) "year",(char *) "cal", NULL
19362 };
19363
19364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19365 {
19366 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19367 if (SWIG_arg_fail(1)) SWIG_fail;
19368 }
19369 if (obj1) {
19370 {
19371 arg2 = (int)(SWIG_As_int(obj1));
19372 if (SWIG_arg_fail(2)) SWIG_fail;
19373 }
19374 }
19375 if (obj2) {
19376 {
19377 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19378 if (SWIG_arg_fail(3)) SWIG_fail;
19379 }
19380 }
19381 {
19382 PyThreadState* __tstate = wxPyBeginAllowThreads();
19383 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19384
19385 wxPyEndAllowThreads(__tstate);
19386 if (PyErr_Occurred()) SWIG_fail;
19387 }
19388 {
19389 resultobj = SWIG_From_int((int)(result));
19390 }
19391 return resultobj;
19392 fail:
19393 return NULL;
19394 }
19395
19396
19397 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19398 PyObject *resultobj;
19399 wxDateTime::Month arg1 ;
19400 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19401 wxString result;
19402 PyObject * obj0 = 0 ;
19403 PyObject * obj1 = 0 ;
19404 char *kwnames[] = {
19405 (char *) "month",(char *) "flags", NULL
19406 };
19407
19408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19409 {
19410 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19411 if (SWIG_arg_fail(1)) SWIG_fail;
19412 }
19413 if (obj1) {
19414 {
19415 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19416 if (SWIG_arg_fail(2)) SWIG_fail;
19417 }
19418 }
19419 {
19420 PyThreadState* __tstate = wxPyBeginAllowThreads();
19421 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19422
19423 wxPyEndAllowThreads(__tstate);
19424 if (PyErr_Occurred()) SWIG_fail;
19425 }
19426 {
19427 #if wxUSE_UNICODE
19428 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19429 #else
19430 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19431 #endif
19432 }
19433 return resultobj;
19434 fail:
19435 return NULL;
19436 }
19437
19438
19439 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19440 PyObject *resultobj;
19441 wxDateTime::WeekDay arg1 ;
19442 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19443 wxString result;
19444 PyObject * obj0 = 0 ;
19445 PyObject * obj1 = 0 ;
19446 char *kwnames[] = {
19447 (char *) "weekday",(char *) "flags", NULL
19448 };
19449
19450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19451 {
19452 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19453 if (SWIG_arg_fail(1)) SWIG_fail;
19454 }
19455 if (obj1) {
19456 {
19457 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19458 if (SWIG_arg_fail(2)) SWIG_fail;
19459 }
19460 }
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19464
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 {
19469 #if wxUSE_UNICODE
19470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19471 #else
19472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19473 #endif
19474 }
19475 return resultobj;
19476 fail:
19477 return NULL;
19478 }
19479
19480
19481 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19482 PyObject *resultobj;
19483 PyObject *result;
19484 char *kwnames[] = {
19485 NULL
19486 };
19487
19488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 result = (PyObject *)DateTime_GetAmPmStrings();
19492
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 resultobj = result;
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19504 PyObject *resultobj;
19505 int arg1 = (int) wxDateTime::Inv_Year ;
19506 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19507 bool result;
19508 PyObject * obj0 = 0 ;
19509 PyObject * obj1 = 0 ;
19510 char *kwnames[] = {
19511 (char *) "year",(char *) "country", NULL
19512 };
19513
19514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19515 if (obj0) {
19516 {
19517 arg1 = (int)(SWIG_As_int(obj0));
19518 if (SWIG_arg_fail(1)) SWIG_fail;
19519 }
19520 }
19521 if (obj1) {
19522 {
19523 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19524 if (SWIG_arg_fail(2)) SWIG_fail;
19525 }
19526 }
19527 {
19528 PyThreadState* __tstate = wxPyBeginAllowThreads();
19529 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19530
19531 wxPyEndAllowThreads(__tstate);
19532 if (PyErr_Occurred()) SWIG_fail;
19533 }
19534 {
19535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19536 }
19537 return resultobj;
19538 fail:
19539 return NULL;
19540 }
19541
19542
19543 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19544 PyObject *resultobj;
19545 int arg1 = (int) wxDateTime::Inv_Year ;
19546 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19547 wxDateTime result;
19548 PyObject * obj0 = 0 ;
19549 PyObject * obj1 = 0 ;
19550 char *kwnames[] = {
19551 (char *) "year",(char *) "country", NULL
19552 };
19553
19554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19555 if (obj0) {
19556 {
19557 arg1 = (int)(SWIG_As_int(obj0));
19558 if (SWIG_arg_fail(1)) SWIG_fail;
19559 }
19560 }
19561 if (obj1) {
19562 {
19563 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19564 if (SWIG_arg_fail(2)) SWIG_fail;
19565 }
19566 }
19567 {
19568 PyThreadState* __tstate = wxPyBeginAllowThreads();
19569 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19570
19571 wxPyEndAllowThreads(__tstate);
19572 if (PyErr_Occurred()) SWIG_fail;
19573 }
19574 {
19575 wxDateTime * resultptr;
19576 resultptr = new wxDateTime((wxDateTime &)(result));
19577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19578 }
19579 return resultobj;
19580 fail:
19581 return NULL;
19582 }
19583
19584
19585 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19586 PyObject *resultobj;
19587 int arg1 = (int) wxDateTime::Inv_Year ;
19588 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19589 wxDateTime result;
19590 PyObject * obj0 = 0 ;
19591 PyObject * obj1 = 0 ;
19592 char *kwnames[] = {
19593 (char *) "year",(char *) "country", NULL
19594 };
19595
19596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19597 if (obj0) {
19598 {
19599 arg1 = (int)(SWIG_As_int(obj0));
19600 if (SWIG_arg_fail(1)) SWIG_fail;
19601 }
19602 }
19603 if (obj1) {
19604 {
19605 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19606 if (SWIG_arg_fail(2)) SWIG_fail;
19607 }
19608 }
19609 {
19610 PyThreadState* __tstate = wxPyBeginAllowThreads();
19611 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19612
19613 wxPyEndAllowThreads(__tstate);
19614 if (PyErr_Occurred()) SWIG_fail;
19615 }
19616 {
19617 wxDateTime * resultptr;
19618 resultptr = new wxDateTime((wxDateTime &)(result));
19619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19620 }
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19628 PyObject *resultobj;
19629 wxDateTime result;
19630 char *kwnames[] = {
19631 NULL
19632 };
19633
19634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19635 {
19636 PyThreadState* __tstate = wxPyBeginAllowThreads();
19637 result = wxDateTime::Now();
19638
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 {
19643 wxDateTime * resultptr;
19644 resultptr = new wxDateTime((wxDateTime &)(result));
19645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19646 }
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj;
19655 wxDateTime result;
19656 char *kwnames[] = {
19657 NULL
19658 };
19659
19660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19661 {
19662 PyThreadState* __tstate = wxPyBeginAllowThreads();
19663 result = wxDateTime::UNow();
19664
19665 wxPyEndAllowThreads(__tstate);
19666 if (PyErr_Occurred()) SWIG_fail;
19667 }
19668 {
19669 wxDateTime * resultptr;
19670 resultptr = new wxDateTime((wxDateTime &)(result));
19671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19672 }
19673 return resultobj;
19674 fail:
19675 return NULL;
19676 }
19677
19678
19679 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19680 PyObject *resultobj;
19681 wxDateTime result;
19682 char *kwnames[] = {
19683 NULL
19684 };
19685
19686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19687 {
19688 PyThreadState* __tstate = wxPyBeginAllowThreads();
19689 result = wxDateTime::Today();
19690
19691 wxPyEndAllowThreads(__tstate);
19692 if (PyErr_Occurred()) SWIG_fail;
19693 }
19694 {
19695 wxDateTime * resultptr;
19696 resultptr = new wxDateTime((wxDateTime &)(result));
19697 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19698 }
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19706 PyObject *resultobj;
19707 wxDateTime *result;
19708 char *kwnames[] = {
19709 NULL
19710 };
19711
19712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 result = (wxDateTime *)new wxDateTime();
19716
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19728 PyObject *resultobj;
19729 time_t arg1 ;
19730 wxDateTime *result;
19731 PyObject * obj0 = 0 ;
19732 char *kwnames[] = {
19733 (char *) "timet", NULL
19734 };
19735
19736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19737 {
19738 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19739 if (SWIG_arg_fail(1)) SWIG_fail;
19740 }
19741 {
19742 PyThreadState* __tstate = wxPyBeginAllowThreads();
19743 result = (wxDateTime *)new wxDateTime(arg1);
19744
19745 wxPyEndAllowThreads(__tstate);
19746 if (PyErr_Occurred()) SWIG_fail;
19747 }
19748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19749 return resultobj;
19750 fail:
19751 return NULL;
19752 }
19753
19754
19755 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19756 PyObject *resultobj;
19757 double arg1 ;
19758 wxDateTime *result;
19759 PyObject * obj0 = 0 ;
19760 char *kwnames[] = {
19761 (char *) "jdn", NULL
19762 };
19763
19764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19765 {
19766 arg1 = (double)(SWIG_As_double(obj0));
19767 if (SWIG_arg_fail(1)) SWIG_fail;
19768 }
19769 {
19770 PyThreadState* __tstate = wxPyBeginAllowThreads();
19771 result = (wxDateTime *)new wxDateTime(arg1);
19772
19773 wxPyEndAllowThreads(__tstate);
19774 if (PyErr_Occurred()) SWIG_fail;
19775 }
19776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19777 return resultobj;
19778 fail:
19779 return NULL;
19780 }
19781
19782
19783 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj;
19785 int arg1 ;
19786 int arg2 = (int) 0 ;
19787 int arg3 = (int) 0 ;
19788 int arg4 = (int) 0 ;
19789 wxDateTime *result;
19790 PyObject * obj0 = 0 ;
19791 PyObject * obj1 = 0 ;
19792 PyObject * obj2 = 0 ;
19793 PyObject * obj3 = 0 ;
19794 char *kwnames[] = {
19795 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19796 };
19797
19798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19799 {
19800 arg1 = (int)(SWIG_As_int(obj0));
19801 if (SWIG_arg_fail(1)) SWIG_fail;
19802 }
19803 if (obj1) {
19804 {
19805 arg2 = (int)(SWIG_As_int(obj1));
19806 if (SWIG_arg_fail(2)) SWIG_fail;
19807 }
19808 }
19809 if (obj2) {
19810 {
19811 arg3 = (int)(SWIG_As_int(obj2));
19812 if (SWIG_arg_fail(3)) SWIG_fail;
19813 }
19814 }
19815 if (obj3) {
19816 {
19817 arg4 = (int)(SWIG_As_int(obj3));
19818 if (SWIG_arg_fail(4)) SWIG_fail;
19819 }
19820 }
19821 {
19822 PyThreadState* __tstate = wxPyBeginAllowThreads();
19823 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19824
19825 wxPyEndAllowThreads(__tstate);
19826 if (PyErr_Occurred()) SWIG_fail;
19827 }
19828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19829 return resultobj;
19830 fail:
19831 return NULL;
19832 }
19833
19834
19835 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19836 PyObject *resultobj;
19837 int arg1 ;
19838 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19839 int arg3 = (int) wxDateTime::Inv_Year ;
19840 int arg4 = (int) 0 ;
19841 int arg5 = (int) 0 ;
19842 int arg6 = (int) 0 ;
19843 int arg7 = (int) 0 ;
19844 wxDateTime *result;
19845 PyObject * obj0 = 0 ;
19846 PyObject * obj1 = 0 ;
19847 PyObject * obj2 = 0 ;
19848 PyObject * obj3 = 0 ;
19849 PyObject * obj4 = 0 ;
19850 PyObject * obj5 = 0 ;
19851 PyObject * obj6 = 0 ;
19852 char *kwnames[] = {
19853 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19854 };
19855
19856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19857 {
19858 arg1 = (int)(SWIG_As_int(obj0));
19859 if (SWIG_arg_fail(1)) SWIG_fail;
19860 }
19861 if (obj1) {
19862 {
19863 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19864 if (SWIG_arg_fail(2)) SWIG_fail;
19865 }
19866 }
19867 if (obj2) {
19868 {
19869 arg3 = (int)(SWIG_As_int(obj2));
19870 if (SWIG_arg_fail(3)) SWIG_fail;
19871 }
19872 }
19873 if (obj3) {
19874 {
19875 arg4 = (int)(SWIG_As_int(obj3));
19876 if (SWIG_arg_fail(4)) SWIG_fail;
19877 }
19878 }
19879 if (obj4) {
19880 {
19881 arg5 = (int)(SWIG_As_int(obj4));
19882 if (SWIG_arg_fail(5)) SWIG_fail;
19883 }
19884 }
19885 if (obj5) {
19886 {
19887 arg6 = (int)(SWIG_As_int(obj5));
19888 if (SWIG_arg_fail(6)) SWIG_fail;
19889 }
19890 }
19891 if (obj6) {
19892 {
19893 arg7 = (int)(SWIG_As_int(obj6));
19894 if (SWIG_arg_fail(7)) SWIG_fail;
19895 }
19896 }
19897 {
19898 PyThreadState* __tstate = wxPyBeginAllowThreads();
19899 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19900
19901 wxPyEndAllowThreads(__tstate);
19902 if (PyErr_Occurred()) SWIG_fail;
19903 }
19904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19905 return resultobj;
19906 fail:
19907 return NULL;
19908 }
19909
19910
19911 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19912 PyObject *resultobj;
19913 wxDateTime *arg1 = (wxDateTime *) 0 ;
19914 PyObject * obj0 = 0 ;
19915 char *kwnames[] = {
19916 (char *) "self", NULL
19917 };
19918
19919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19921 if (SWIG_arg_fail(1)) SWIG_fail;
19922 {
19923 PyThreadState* __tstate = wxPyBeginAllowThreads();
19924 delete arg1;
19925
19926 wxPyEndAllowThreads(__tstate);
19927 if (PyErr_Occurred()) SWIG_fail;
19928 }
19929 Py_INCREF(Py_None); resultobj = Py_None;
19930 return resultobj;
19931 fail:
19932 return NULL;
19933 }
19934
19935
19936 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19937 PyObject *resultobj;
19938 wxDateTime *arg1 = (wxDateTime *) 0 ;
19939 wxDateTime *result;
19940 PyObject * obj0 = 0 ;
19941 char *kwnames[] = {
19942 (char *) "self", NULL
19943 };
19944
19945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19947 if (SWIG_arg_fail(1)) SWIG_fail;
19948 {
19949 PyThreadState* __tstate = wxPyBeginAllowThreads();
19950 {
19951 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19952 result = (wxDateTime *) &_result_ref;
19953 }
19954
19955 wxPyEndAllowThreads(__tstate);
19956 if (PyErr_Occurred()) SWIG_fail;
19957 }
19958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19959 return resultobj;
19960 fail:
19961 return NULL;
19962 }
19963
19964
19965 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19966 PyObject *resultobj;
19967 wxDateTime *arg1 = (wxDateTime *) 0 ;
19968 time_t arg2 ;
19969 wxDateTime *result;
19970 PyObject * obj0 = 0 ;
19971 PyObject * obj1 = 0 ;
19972 char *kwnames[] = {
19973 (char *) "self",(char *) "timet", NULL
19974 };
19975
19976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19978 if (SWIG_arg_fail(1)) SWIG_fail;
19979 {
19980 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19981 if (SWIG_arg_fail(2)) SWIG_fail;
19982 }
19983 {
19984 PyThreadState* __tstate = wxPyBeginAllowThreads();
19985 {
19986 wxDateTime &_result_ref = (arg1)->Set(arg2);
19987 result = (wxDateTime *) &_result_ref;
19988 }
19989
19990 wxPyEndAllowThreads(__tstate);
19991 if (PyErr_Occurred()) SWIG_fail;
19992 }
19993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19994 return resultobj;
19995 fail:
19996 return NULL;
19997 }
19998
19999
20000 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20001 PyObject *resultobj;
20002 wxDateTime *arg1 = (wxDateTime *) 0 ;
20003 double arg2 ;
20004 wxDateTime *result;
20005 PyObject * obj0 = 0 ;
20006 PyObject * obj1 = 0 ;
20007 char *kwnames[] = {
20008 (char *) "self",(char *) "jdn", NULL
20009 };
20010
20011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20013 if (SWIG_arg_fail(1)) SWIG_fail;
20014 {
20015 arg2 = (double)(SWIG_As_double(obj1));
20016 if (SWIG_arg_fail(2)) SWIG_fail;
20017 }
20018 {
20019 PyThreadState* __tstate = wxPyBeginAllowThreads();
20020 {
20021 wxDateTime &_result_ref = (arg1)->Set(arg2);
20022 result = (wxDateTime *) &_result_ref;
20023 }
20024
20025 wxPyEndAllowThreads(__tstate);
20026 if (PyErr_Occurred()) SWIG_fail;
20027 }
20028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20029 return resultobj;
20030 fail:
20031 return NULL;
20032 }
20033
20034
20035 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20036 PyObject *resultobj;
20037 wxDateTime *arg1 = (wxDateTime *) 0 ;
20038 int arg2 ;
20039 int arg3 = (int) 0 ;
20040 int arg4 = (int) 0 ;
20041 int arg5 = (int) 0 ;
20042 wxDateTime *result;
20043 PyObject * obj0 = 0 ;
20044 PyObject * obj1 = 0 ;
20045 PyObject * obj2 = 0 ;
20046 PyObject * obj3 = 0 ;
20047 PyObject * obj4 = 0 ;
20048 char *kwnames[] = {
20049 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20050 };
20051
20052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20054 if (SWIG_arg_fail(1)) SWIG_fail;
20055 {
20056 arg2 = (int)(SWIG_As_int(obj1));
20057 if (SWIG_arg_fail(2)) SWIG_fail;
20058 }
20059 if (obj2) {
20060 {
20061 arg3 = (int)(SWIG_As_int(obj2));
20062 if (SWIG_arg_fail(3)) SWIG_fail;
20063 }
20064 }
20065 if (obj3) {
20066 {
20067 arg4 = (int)(SWIG_As_int(obj3));
20068 if (SWIG_arg_fail(4)) SWIG_fail;
20069 }
20070 }
20071 if (obj4) {
20072 {
20073 arg5 = (int)(SWIG_As_int(obj4));
20074 if (SWIG_arg_fail(5)) SWIG_fail;
20075 }
20076 }
20077 {
20078 PyThreadState* __tstate = wxPyBeginAllowThreads();
20079 {
20080 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20081 result = (wxDateTime *) &_result_ref;
20082 }
20083
20084 wxPyEndAllowThreads(__tstate);
20085 if (PyErr_Occurred()) SWIG_fail;
20086 }
20087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20088 return resultobj;
20089 fail:
20090 return NULL;
20091 }
20092
20093
20094 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20095 PyObject *resultobj;
20096 wxDateTime *arg1 = (wxDateTime *) 0 ;
20097 int arg2 ;
20098 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20099 int arg4 = (int) wxDateTime::Inv_Year ;
20100 int arg5 = (int) 0 ;
20101 int arg6 = (int) 0 ;
20102 int arg7 = (int) 0 ;
20103 int arg8 = (int) 0 ;
20104 wxDateTime *result;
20105 PyObject * obj0 = 0 ;
20106 PyObject * obj1 = 0 ;
20107 PyObject * obj2 = 0 ;
20108 PyObject * obj3 = 0 ;
20109 PyObject * obj4 = 0 ;
20110 PyObject * obj5 = 0 ;
20111 PyObject * obj6 = 0 ;
20112 PyObject * obj7 = 0 ;
20113 char *kwnames[] = {
20114 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20115 };
20116
20117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20119 if (SWIG_arg_fail(1)) SWIG_fail;
20120 {
20121 arg2 = (int)(SWIG_As_int(obj1));
20122 if (SWIG_arg_fail(2)) SWIG_fail;
20123 }
20124 if (obj2) {
20125 {
20126 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20127 if (SWIG_arg_fail(3)) SWIG_fail;
20128 }
20129 }
20130 if (obj3) {
20131 {
20132 arg4 = (int)(SWIG_As_int(obj3));
20133 if (SWIG_arg_fail(4)) SWIG_fail;
20134 }
20135 }
20136 if (obj4) {
20137 {
20138 arg5 = (int)(SWIG_As_int(obj4));
20139 if (SWIG_arg_fail(5)) SWIG_fail;
20140 }
20141 }
20142 if (obj5) {
20143 {
20144 arg6 = (int)(SWIG_As_int(obj5));
20145 if (SWIG_arg_fail(6)) SWIG_fail;
20146 }
20147 }
20148 if (obj6) {
20149 {
20150 arg7 = (int)(SWIG_As_int(obj6));
20151 if (SWIG_arg_fail(7)) SWIG_fail;
20152 }
20153 }
20154 if (obj7) {
20155 {
20156 arg8 = (int)(SWIG_As_int(obj7));
20157 if (SWIG_arg_fail(8)) SWIG_fail;
20158 }
20159 }
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 {
20163 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
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_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20178 PyObject *resultobj;
20179 wxDateTime *arg1 = (wxDateTime *) 0 ;
20180 wxDateTime *result;
20181 PyObject * obj0 = 0 ;
20182 char *kwnames[] = {
20183 (char *) "self", NULL
20184 };
20185
20186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20188 if (SWIG_arg_fail(1)) SWIG_fail;
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 {
20192 wxDateTime &_result_ref = (arg1)->ResetTime();
20193 result = (wxDateTime *) &_result_ref;
20194 }
20195
20196 wxPyEndAllowThreads(__tstate);
20197 if (PyErr_Occurred()) SWIG_fail;
20198 }
20199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20200 return resultobj;
20201 fail:
20202 return NULL;
20203 }
20204
20205
20206 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20207 PyObject *resultobj;
20208 wxDateTime *arg1 = (wxDateTime *) 0 ;
20209 int arg2 ;
20210 wxDateTime *result;
20211 PyObject * obj0 = 0 ;
20212 PyObject * obj1 = 0 ;
20213 char *kwnames[] = {
20214 (char *) "self",(char *) "year", NULL
20215 };
20216
20217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20219 if (SWIG_arg_fail(1)) SWIG_fail;
20220 {
20221 arg2 = (int)(SWIG_As_int(obj1));
20222 if (SWIG_arg_fail(2)) SWIG_fail;
20223 }
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 {
20227 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20228 result = (wxDateTime *) &_result_ref;
20229 }
20230
20231 wxPyEndAllowThreads(__tstate);
20232 if (PyErr_Occurred()) SWIG_fail;
20233 }
20234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20235 return resultobj;
20236 fail:
20237 return NULL;
20238 }
20239
20240
20241 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20242 PyObject *resultobj;
20243 wxDateTime *arg1 = (wxDateTime *) 0 ;
20244 wxDateTime::Month arg2 ;
20245 wxDateTime *result;
20246 PyObject * obj0 = 0 ;
20247 PyObject * obj1 = 0 ;
20248 char *kwnames[] = {
20249 (char *) "self",(char *) "month", NULL
20250 };
20251
20252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20254 if (SWIG_arg_fail(1)) SWIG_fail;
20255 {
20256 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20257 if (SWIG_arg_fail(2)) SWIG_fail;
20258 }
20259 {
20260 PyThreadState* __tstate = wxPyBeginAllowThreads();
20261 {
20262 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20263 result = (wxDateTime *) &_result_ref;
20264 }
20265
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20277 PyObject *resultobj;
20278 wxDateTime *arg1 = (wxDateTime *) 0 ;
20279 int arg2 ;
20280 wxDateTime *result;
20281 PyObject * obj0 = 0 ;
20282 PyObject * obj1 = 0 ;
20283 char *kwnames[] = {
20284 (char *) "self",(char *) "day", NULL
20285 };
20286
20287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20289 if (SWIG_arg_fail(1)) SWIG_fail;
20290 {
20291 arg2 = (int)(SWIG_As_int(obj1));
20292 if (SWIG_arg_fail(2)) SWIG_fail;
20293 }
20294 {
20295 PyThreadState* __tstate = wxPyBeginAllowThreads();
20296 {
20297 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20298 result = (wxDateTime *) &_result_ref;
20299 }
20300
20301 wxPyEndAllowThreads(__tstate);
20302 if (PyErr_Occurred()) SWIG_fail;
20303 }
20304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20305 return resultobj;
20306 fail:
20307 return NULL;
20308 }
20309
20310
20311 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20312 PyObject *resultobj;
20313 wxDateTime *arg1 = (wxDateTime *) 0 ;
20314 int arg2 ;
20315 wxDateTime *result;
20316 PyObject * obj0 = 0 ;
20317 PyObject * obj1 = 0 ;
20318 char *kwnames[] = {
20319 (char *) "self",(char *) "hour", NULL
20320 };
20321
20322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20324 if (SWIG_arg_fail(1)) SWIG_fail;
20325 {
20326 arg2 = (int)(SWIG_As_int(obj1));
20327 if (SWIG_arg_fail(2)) SWIG_fail;
20328 }
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 {
20332 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20333 result = (wxDateTime *) &_result_ref;
20334 }
20335
20336 wxPyEndAllowThreads(__tstate);
20337 if (PyErr_Occurred()) SWIG_fail;
20338 }
20339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20340 return resultobj;
20341 fail:
20342 return NULL;
20343 }
20344
20345
20346 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20347 PyObject *resultobj;
20348 wxDateTime *arg1 = (wxDateTime *) 0 ;
20349 int arg2 ;
20350 wxDateTime *result;
20351 PyObject * obj0 = 0 ;
20352 PyObject * obj1 = 0 ;
20353 char *kwnames[] = {
20354 (char *) "self",(char *) "minute", NULL
20355 };
20356
20357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20359 if (SWIG_arg_fail(1)) SWIG_fail;
20360 {
20361 arg2 = (int)(SWIG_As_int(obj1));
20362 if (SWIG_arg_fail(2)) SWIG_fail;
20363 }
20364 {
20365 PyThreadState* __tstate = wxPyBeginAllowThreads();
20366 {
20367 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20368 result = (wxDateTime *) &_result_ref;
20369 }
20370
20371 wxPyEndAllowThreads(__tstate);
20372 if (PyErr_Occurred()) SWIG_fail;
20373 }
20374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20375 return resultobj;
20376 fail:
20377 return NULL;
20378 }
20379
20380
20381 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20382 PyObject *resultobj;
20383 wxDateTime *arg1 = (wxDateTime *) 0 ;
20384 int arg2 ;
20385 wxDateTime *result;
20386 PyObject * obj0 = 0 ;
20387 PyObject * obj1 = 0 ;
20388 char *kwnames[] = {
20389 (char *) "self",(char *) "second", NULL
20390 };
20391
20392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20394 if (SWIG_arg_fail(1)) SWIG_fail;
20395 {
20396 arg2 = (int)(SWIG_As_int(obj1));
20397 if (SWIG_arg_fail(2)) SWIG_fail;
20398 }
20399 {
20400 PyThreadState* __tstate = wxPyBeginAllowThreads();
20401 {
20402 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20403 result = (wxDateTime *) &_result_ref;
20404 }
20405
20406 wxPyEndAllowThreads(__tstate);
20407 if (PyErr_Occurred()) SWIG_fail;
20408 }
20409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20410 return resultobj;
20411 fail:
20412 return NULL;
20413 }
20414
20415
20416 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20417 PyObject *resultobj;
20418 wxDateTime *arg1 = (wxDateTime *) 0 ;
20419 int arg2 ;
20420 wxDateTime *result;
20421 PyObject * obj0 = 0 ;
20422 PyObject * obj1 = 0 ;
20423 char *kwnames[] = {
20424 (char *) "self",(char *) "millisecond", NULL
20425 };
20426
20427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20429 if (SWIG_arg_fail(1)) SWIG_fail;
20430 {
20431 arg2 = (int)(SWIG_As_int(obj1));
20432 if (SWIG_arg_fail(2)) SWIG_fail;
20433 }
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 {
20437 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20438 result = (wxDateTime *) &_result_ref;
20439 }
20440
20441 wxPyEndAllowThreads(__tstate);
20442 if (PyErr_Occurred()) SWIG_fail;
20443 }
20444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20445 return resultobj;
20446 fail:
20447 return NULL;
20448 }
20449
20450
20451 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20452 PyObject *resultobj;
20453 wxDateTime *arg1 = (wxDateTime *) 0 ;
20454 wxDateTime::WeekDay arg2 ;
20455 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20456 wxDateTime *result;
20457 PyObject * obj0 = 0 ;
20458 PyObject * obj1 = 0 ;
20459 PyObject * obj2 = 0 ;
20460 char *kwnames[] = {
20461 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20462 };
20463
20464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20466 if (SWIG_arg_fail(1)) SWIG_fail;
20467 {
20468 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20469 if (SWIG_arg_fail(2)) SWIG_fail;
20470 }
20471 if (obj2) {
20472 {
20473 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20474 if (SWIG_arg_fail(3)) SWIG_fail;
20475 }
20476 }
20477 {
20478 PyThreadState* __tstate = wxPyBeginAllowThreads();
20479 {
20480 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20481 result = (wxDateTime *) &_result_ref;
20482 }
20483
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj;
20496 wxDateTime *arg1 = (wxDateTime *) 0 ;
20497 wxDateTime::WeekDay arg2 ;
20498 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20499 wxDateTime result;
20500 PyObject * obj0 = 0 ;
20501 PyObject * obj1 = 0 ;
20502 PyObject * obj2 = 0 ;
20503 char *kwnames[] = {
20504 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20505 };
20506
20507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20509 if (SWIG_arg_fail(1)) SWIG_fail;
20510 {
20511 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20512 if (SWIG_arg_fail(2)) SWIG_fail;
20513 }
20514 if (obj2) {
20515 {
20516 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20517 if (SWIG_arg_fail(3)) SWIG_fail;
20518 }
20519 }
20520 {
20521 PyThreadState* __tstate = wxPyBeginAllowThreads();
20522 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20523
20524 wxPyEndAllowThreads(__tstate);
20525 if (PyErr_Occurred()) SWIG_fail;
20526 }
20527 {
20528 wxDateTime * resultptr;
20529 resultptr = new wxDateTime((wxDateTime &)(result));
20530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20531 }
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20539 PyObject *resultobj;
20540 wxDateTime *arg1 = (wxDateTime *) 0 ;
20541 wxDateTime::WeekDay arg2 ;
20542 wxDateTime *result;
20543 PyObject * obj0 = 0 ;
20544 PyObject * obj1 = 0 ;
20545 char *kwnames[] = {
20546 (char *) "self",(char *) "weekday", NULL
20547 };
20548
20549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20551 if (SWIG_arg_fail(1)) SWIG_fail;
20552 {
20553 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20554 if (SWIG_arg_fail(2)) SWIG_fail;
20555 }
20556 {
20557 PyThreadState* __tstate = wxPyBeginAllowThreads();
20558 {
20559 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20560 result = (wxDateTime *) &_result_ref;
20561 }
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj;
20575 wxDateTime *arg1 = (wxDateTime *) 0 ;
20576 wxDateTime::WeekDay arg2 ;
20577 wxDateTime result;
20578 PyObject * obj0 = 0 ;
20579 PyObject * obj1 = 0 ;
20580 char *kwnames[] = {
20581 (char *) "self",(char *) "weekday", NULL
20582 };
20583
20584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) 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 {
20592 PyThreadState* __tstate = wxPyBeginAllowThreads();
20593 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20594
20595 wxPyEndAllowThreads(__tstate);
20596 if (PyErr_Occurred()) SWIG_fail;
20597 }
20598 {
20599 wxDateTime * resultptr;
20600 resultptr = new wxDateTime((wxDateTime &)(result));
20601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20602 }
20603 return resultobj;
20604 fail:
20605 return NULL;
20606 }
20607
20608
20609 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20610 PyObject *resultobj;
20611 wxDateTime *arg1 = (wxDateTime *) 0 ;
20612 wxDateTime::WeekDay arg2 ;
20613 wxDateTime *result;
20614 PyObject * obj0 = 0 ;
20615 PyObject * obj1 = 0 ;
20616 char *kwnames[] = {
20617 (char *) "self",(char *) "weekday", NULL
20618 };
20619
20620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20622 if (SWIG_arg_fail(1)) SWIG_fail;
20623 {
20624 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20625 if (SWIG_arg_fail(2)) SWIG_fail;
20626 }
20627 {
20628 PyThreadState* __tstate = wxPyBeginAllowThreads();
20629 {
20630 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20631 result = (wxDateTime *) &_result_ref;
20632 }
20633
20634 wxPyEndAllowThreads(__tstate);
20635 if (PyErr_Occurred()) SWIG_fail;
20636 }
20637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20645 PyObject *resultobj;
20646 wxDateTime *arg1 = (wxDateTime *) 0 ;
20647 wxDateTime::WeekDay arg2 ;
20648 wxDateTime result;
20649 PyObject * obj0 = 0 ;
20650 PyObject * obj1 = 0 ;
20651 char *kwnames[] = {
20652 (char *) "self",(char *) "weekday", NULL
20653 };
20654
20655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20657 if (SWIG_arg_fail(1)) SWIG_fail;
20658 {
20659 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20660 if (SWIG_arg_fail(2)) SWIG_fail;
20661 }
20662 {
20663 PyThreadState* __tstate = wxPyBeginAllowThreads();
20664 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20665
20666 wxPyEndAllowThreads(__tstate);
20667 if (PyErr_Occurred()) SWIG_fail;
20668 }
20669 {
20670 wxDateTime * resultptr;
20671 resultptr = new wxDateTime((wxDateTime &)(result));
20672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20673 }
20674 return resultobj;
20675 fail:
20676 return NULL;
20677 }
20678
20679
20680 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20681 PyObject *resultobj;
20682 wxDateTime *arg1 = (wxDateTime *) 0 ;
20683 wxDateTime::WeekDay arg2 ;
20684 int arg3 = (int) 1 ;
20685 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20686 int arg5 = (int) wxDateTime::Inv_Year ;
20687 bool result;
20688 PyObject * obj0 = 0 ;
20689 PyObject * obj1 = 0 ;
20690 PyObject * obj2 = 0 ;
20691 PyObject * obj3 = 0 ;
20692 PyObject * obj4 = 0 ;
20693 char *kwnames[] = {
20694 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20695 };
20696
20697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20699 if (SWIG_arg_fail(1)) SWIG_fail;
20700 {
20701 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20702 if (SWIG_arg_fail(2)) SWIG_fail;
20703 }
20704 if (obj2) {
20705 {
20706 arg3 = (int)(SWIG_As_int(obj2));
20707 if (SWIG_arg_fail(3)) SWIG_fail;
20708 }
20709 }
20710 if (obj3) {
20711 {
20712 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20713 if (SWIG_arg_fail(4)) SWIG_fail;
20714 }
20715 }
20716 if (obj4) {
20717 {
20718 arg5 = (int)(SWIG_As_int(obj4));
20719 if (SWIG_arg_fail(5)) SWIG_fail;
20720 }
20721 }
20722 {
20723 PyThreadState* __tstate = wxPyBeginAllowThreads();
20724 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20725
20726 wxPyEndAllowThreads(__tstate);
20727 if (PyErr_Occurred()) SWIG_fail;
20728 }
20729 {
20730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20731 }
20732 return resultobj;
20733 fail:
20734 return NULL;
20735 }
20736
20737
20738 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20739 PyObject *resultobj;
20740 wxDateTime *arg1 = (wxDateTime *) 0 ;
20741 wxDateTime::WeekDay arg2 ;
20742 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20743 int arg4 = (int) wxDateTime::Inv_Year ;
20744 bool result;
20745 PyObject * obj0 = 0 ;
20746 PyObject * obj1 = 0 ;
20747 PyObject * obj2 = 0 ;
20748 PyObject * obj3 = 0 ;
20749 char *kwnames[] = {
20750 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20751 };
20752
20753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20755 if (SWIG_arg_fail(1)) SWIG_fail;
20756 {
20757 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20758 if (SWIG_arg_fail(2)) SWIG_fail;
20759 }
20760 if (obj2) {
20761 {
20762 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20763 if (SWIG_arg_fail(3)) SWIG_fail;
20764 }
20765 }
20766 if (obj3) {
20767 {
20768 arg4 = (int)(SWIG_As_int(obj3));
20769 if (SWIG_arg_fail(4)) SWIG_fail;
20770 }
20771 }
20772 {
20773 PyThreadState* __tstate = wxPyBeginAllowThreads();
20774 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20775
20776 wxPyEndAllowThreads(__tstate);
20777 if (PyErr_Occurred()) SWIG_fail;
20778 }
20779 {
20780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20781 }
20782 return resultobj;
20783 fail:
20784 return NULL;
20785 }
20786
20787
20788 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20789 PyObject *resultobj;
20790 wxDateTime *arg1 = (wxDateTime *) 0 ;
20791 wxDateTime::WeekDay arg2 ;
20792 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20793 int arg4 = (int) wxDateTime::Inv_Year ;
20794 wxDateTime result;
20795 PyObject * obj0 = 0 ;
20796 PyObject * obj1 = 0 ;
20797 PyObject * obj2 = 0 ;
20798 PyObject * obj3 = 0 ;
20799 char *kwnames[] = {
20800 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20801 };
20802
20803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20805 if (SWIG_arg_fail(1)) SWIG_fail;
20806 {
20807 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20808 if (SWIG_arg_fail(2)) SWIG_fail;
20809 }
20810 if (obj2) {
20811 {
20812 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20813 if (SWIG_arg_fail(3)) SWIG_fail;
20814 }
20815 }
20816 if (obj3) {
20817 {
20818 arg4 = (int)(SWIG_As_int(obj3));
20819 if (SWIG_arg_fail(4)) SWIG_fail;
20820 }
20821 }
20822 {
20823 PyThreadState* __tstate = wxPyBeginAllowThreads();
20824 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20825
20826 wxPyEndAllowThreads(__tstate);
20827 if (PyErr_Occurred()) SWIG_fail;
20828 }
20829 {
20830 wxDateTime * resultptr;
20831 resultptr = new wxDateTime((wxDateTime &)(result));
20832 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20833 }
20834 return resultobj;
20835 fail:
20836 return NULL;
20837 }
20838
20839
20840 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20841 PyObject *resultobj;
20842 wxDateTime *arg1 = (wxDateTime *) 0 ;
20843 int arg2 ;
20844 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20845 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20846 bool result;
20847 PyObject * obj0 = 0 ;
20848 PyObject * obj1 = 0 ;
20849 PyObject * obj2 = 0 ;
20850 PyObject * obj3 = 0 ;
20851 char *kwnames[] = {
20852 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20853 };
20854
20855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20857 if (SWIG_arg_fail(1)) SWIG_fail;
20858 {
20859 arg2 = (int)(SWIG_As_int(obj1));
20860 if (SWIG_arg_fail(2)) SWIG_fail;
20861 }
20862 if (obj2) {
20863 {
20864 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20865 if (SWIG_arg_fail(3)) SWIG_fail;
20866 }
20867 }
20868 if (obj3) {
20869 {
20870 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20871 if (SWIG_arg_fail(4)) SWIG_fail;
20872 }
20873 }
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20877
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 {
20882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20883 }
20884 return resultobj;
20885 fail:
20886 return NULL;
20887 }
20888
20889
20890 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20891 PyObject *resultobj;
20892 wxDateTime *arg1 = (wxDateTime *) 0 ;
20893 int arg2 ;
20894 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20895 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20896 wxDateTime result;
20897 PyObject * obj0 = 0 ;
20898 PyObject * obj1 = 0 ;
20899 PyObject * obj2 = 0 ;
20900 PyObject * obj3 = 0 ;
20901 char *kwnames[] = {
20902 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20903 };
20904
20905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20907 if (SWIG_arg_fail(1)) SWIG_fail;
20908 {
20909 arg2 = (int)(SWIG_As_int(obj1));
20910 if (SWIG_arg_fail(2)) SWIG_fail;
20911 }
20912 if (obj2) {
20913 {
20914 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20915 if (SWIG_arg_fail(3)) SWIG_fail;
20916 }
20917 }
20918 if (obj3) {
20919 {
20920 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20921 if (SWIG_arg_fail(4)) SWIG_fail;
20922 }
20923 }
20924 {
20925 PyThreadState* __tstate = wxPyBeginAllowThreads();
20926 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20927
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 {
20932 wxDateTime * resultptr;
20933 resultptr = new wxDateTime((wxDateTime &)(result));
20934 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20935 }
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20943 PyObject *resultobj;
20944 int arg1 ;
20945 int arg2 ;
20946 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20947 wxDateTime result;
20948 PyObject * obj0 = 0 ;
20949 PyObject * obj1 = 0 ;
20950 PyObject * obj2 = 0 ;
20951 char *kwnames[] = {
20952 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20953 };
20954
20955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20956 {
20957 arg1 = (int)(SWIG_As_int(obj0));
20958 if (SWIG_arg_fail(1)) SWIG_fail;
20959 }
20960 {
20961 arg2 = (int)(SWIG_As_int(obj1));
20962 if (SWIG_arg_fail(2)) SWIG_fail;
20963 }
20964 if (obj2) {
20965 {
20966 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20967 if (SWIG_arg_fail(3)) SWIG_fail;
20968 }
20969 }
20970 {
20971 PyThreadState* __tstate = wxPyBeginAllowThreads();
20972 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20973
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 {
20978 wxDateTime * resultptr;
20979 resultptr = new wxDateTime((wxDateTime &)(result));
20980 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20981 }
20982 return resultobj;
20983 fail:
20984 return NULL;
20985 }
20986
20987
20988 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20989 PyObject *resultobj;
20990 wxDateTime *arg1 = (wxDateTime *) 0 ;
20991 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20992 int arg3 = (int) wxDateTime::Inv_Year ;
20993 wxDateTime *result;
20994 PyObject * obj0 = 0 ;
20995 PyObject * obj1 = 0 ;
20996 PyObject * obj2 = 0 ;
20997 char *kwnames[] = {
20998 (char *) "self",(char *) "month",(char *) "year", NULL
20999 };
21000
21001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21003 if (SWIG_arg_fail(1)) SWIG_fail;
21004 if (obj1) {
21005 {
21006 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21007 if (SWIG_arg_fail(2)) SWIG_fail;
21008 }
21009 }
21010 if (obj2) {
21011 {
21012 arg3 = (int)(SWIG_As_int(obj2));
21013 if (SWIG_arg_fail(3)) SWIG_fail;
21014 }
21015 }
21016 {
21017 PyThreadState* __tstate = wxPyBeginAllowThreads();
21018 {
21019 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21020 result = (wxDateTime *) &_result_ref;
21021 }
21022
21023 wxPyEndAllowThreads(__tstate);
21024 if (PyErr_Occurred()) SWIG_fail;
21025 }
21026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21027 return resultobj;
21028 fail:
21029 return NULL;
21030 }
21031
21032
21033 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21034 PyObject *resultobj;
21035 wxDateTime *arg1 = (wxDateTime *) 0 ;
21036 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21037 int arg3 = (int) wxDateTime::Inv_Year ;
21038 wxDateTime result;
21039 PyObject * obj0 = 0 ;
21040 PyObject * obj1 = 0 ;
21041 PyObject * obj2 = 0 ;
21042 char *kwnames[] = {
21043 (char *) "self",(char *) "month",(char *) "year", NULL
21044 };
21045
21046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) 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 if (obj1) {
21050 {
21051 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21052 if (SWIG_arg_fail(2)) SWIG_fail;
21053 }
21054 }
21055 if (obj2) {
21056 {
21057 arg3 = (int)(SWIG_As_int(obj2));
21058 if (SWIG_arg_fail(3)) SWIG_fail;
21059 }
21060 }
21061 {
21062 PyThreadState* __tstate = wxPyBeginAllowThreads();
21063 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21064
21065 wxPyEndAllowThreads(__tstate);
21066 if (PyErr_Occurred()) SWIG_fail;
21067 }
21068 {
21069 wxDateTime * resultptr;
21070 resultptr = new wxDateTime((wxDateTime &)(result));
21071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21072 }
21073 return resultobj;
21074 fail:
21075 return NULL;
21076 }
21077
21078
21079 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21080 PyObject *resultobj;
21081 wxDateTime *arg1 = (wxDateTime *) 0 ;
21082 int arg2 ;
21083 wxDateTime *result;
21084 PyObject * obj0 = 0 ;
21085 PyObject * obj1 = 0 ;
21086 char *kwnames[] = {
21087 (char *) "self",(char *) "yday", NULL
21088 };
21089
21090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21092 if (SWIG_arg_fail(1)) SWIG_fail;
21093 {
21094 arg2 = (int)(SWIG_As_int(obj1));
21095 if (SWIG_arg_fail(2)) SWIG_fail;
21096 }
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 {
21100 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21101 result = (wxDateTime *) &_result_ref;
21102 }
21103
21104 wxPyEndAllowThreads(__tstate);
21105 if (PyErr_Occurred()) SWIG_fail;
21106 }
21107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21108 return resultobj;
21109 fail:
21110 return NULL;
21111 }
21112
21113
21114 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21115 PyObject *resultobj;
21116 wxDateTime *arg1 = (wxDateTime *) 0 ;
21117 int arg2 ;
21118 wxDateTime result;
21119 PyObject * obj0 = 0 ;
21120 PyObject * obj1 = 0 ;
21121 char *kwnames[] = {
21122 (char *) "self",(char *) "yday", NULL
21123 };
21124
21125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21127 if (SWIG_arg_fail(1)) SWIG_fail;
21128 {
21129 arg2 = (int)(SWIG_As_int(obj1));
21130 if (SWIG_arg_fail(2)) SWIG_fail;
21131 }
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = (arg1)->GetYearDay(arg2);
21135
21136 wxPyEndAllowThreads(__tstate);
21137 if (PyErr_Occurred()) SWIG_fail;
21138 }
21139 {
21140 wxDateTime * resultptr;
21141 resultptr = new wxDateTime((wxDateTime &)(result));
21142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21143 }
21144 return resultobj;
21145 fail:
21146 return NULL;
21147 }
21148
21149
21150 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21151 PyObject *resultobj;
21152 wxDateTime *arg1 = (wxDateTime *) 0 ;
21153 double result;
21154 PyObject * obj0 = 0 ;
21155 char *kwnames[] = {
21156 (char *) "self", NULL
21157 };
21158
21159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21161 if (SWIG_arg_fail(1)) SWIG_fail;
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (double)(arg1)->GetJulianDayNumber();
21165
21166 wxPyEndAllowThreads(__tstate);
21167 if (PyErr_Occurred()) SWIG_fail;
21168 }
21169 {
21170 resultobj = SWIG_From_double((double)(result));
21171 }
21172 return resultobj;
21173 fail:
21174 return NULL;
21175 }
21176
21177
21178 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21179 PyObject *resultobj;
21180 wxDateTime *arg1 = (wxDateTime *) 0 ;
21181 double result;
21182 PyObject * obj0 = 0 ;
21183 char *kwnames[] = {
21184 (char *) "self", NULL
21185 };
21186
21187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21189 if (SWIG_arg_fail(1)) SWIG_fail;
21190 {
21191 PyThreadState* __tstate = wxPyBeginAllowThreads();
21192 result = (double)(arg1)->GetJDN();
21193
21194 wxPyEndAllowThreads(__tstate);
21195 if (PyErr_Occurred()) SWIG_fail;
21196 }
21197 {
21198 resultobj = SWIG_From_double((double)(result));
21199 }
21200 return resultobj;
21201 fail:
21202 return NULL;
21203 }
21204
21205
21206 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21207 PyObject *resultobj;
21208 wxDateTime *arg1 = (wxDateTime *) 0 ;
21209 double result;
21210 PyObject * obj0 = 0 ;
21211 char *kwnames[] = {
21212 (char *) "self", NULL
21213 };
21214
21215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21217 if (SWIG_arg_fail(1)) SWIG_fail;
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21221
21222 wxPyEndAllowThreads(__tstate);
21223 if (PyErr_Occurred()) SWIG_fail;
21224 }
21225 {
21226 resultobj = SWIG_From_double((double)(result));
21227 }
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj;
21236 wxDateTime *arg1 = (wxDateTime *) 0 ;
21237 double result;
21238 PyObject * obj0 = 0 ;
21239 char *kwnames[] = {
21240 (char *) "self", NULL
21241 };
21242
21243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21245 if (SWIG_arg_fail(1)) SWIG_fail;
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (double)(arg1)->GetMJD();
21249
21250 wxPyEndAllowThreads(__tstate);
21251 if (PyErr_Occurred()) SWIG_fail;
21252 }
21253 {
21254 resultobj = SWIG_From_double((double)(result));
21255 }
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21263 PyObject *resultobj;
21264 wxDateTime *arg1 = (wxDateTime *) 0 ;
21265 double result;
21266 PyObject * obj0 = 0 ;
21267 char *kwnames[] = {
21268 (char *) "self", NULL
21269 };
21270
21271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) 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 {
21275 PyThreadState* __tstate = wxPyBeginAllowThreads();
21276 result = (double)(arg1)->GetRataDie();
21277
21278 wxPyEndAllowThreads(__tstate);
21279 if (PyErr_Occurred()) SWIG_fail;
21280 }
21281 {
21282 resultobj = SWIG_From_double((double)(result));
21283 }
21284 return resultobj;
21285 fail:
21286 return NULL;
21287 }
21288
21289
21290 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21291 PyObject *resultobj;
21292 wxDateTime *arg1 = (wxDateTime *) 0 ;
21293 wxDateTime::TimeZone *arg2 = 0 ;
21294 bool arg3 = (bool) false ;
21295 wxDateTime result;
21296 bool temp2 = false ;
21297 PyObject * obj0 = 0 ;
21298 PyObject * obj1 = 0 ;
21299 PyObject * obj2 = 0 ;
21300 char *kwnames[] = {
21301 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21302 };
21303
21304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21306 if (SWIG_arg_fail(1)) SWIG_fail;
21307 {
21308 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21309 temp2 = true;
21310 }
21311 if (obj2) {
21312 {
21313 arg3 = (bool)(SWIG_As_bool(obj2));
21314 if (SWIG_arg_fail(3)) SWIG_fail;
21315 }
21316 }
21317 {
21318 PyThreadState* __tstate = wxPyBeginAllowThreads();
21319 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21320
21321 wxPyEndAllowThreads(__tstate);
21322 if (PyErr_Occurred()) SWIG_fail;
21323 }
21324 {
21325 wxDateTime * resultptr;
21326 resultptr = new wxDateTime((wxDateTime &)(result));
21327 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21328 }
21329 {
21330 if (temp2) delete arg2;
21331 }
21332 return resultobj;
21333 fail:
21334 {
21335 if (temp2) delete arg2;
21336 }
21337 return NULL;
21338 }
21339
21340
21341 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21342 PyObject *resultobj;
21343 wxDateTime *arg1 = (wxDateTime *) 0 ;
21344 wxDateTime::TimeZone *arg2 = 0 ;
21345 bool arg3 = (bool) false ;
21346 wxDateTime *result;
21347 bool temp2 = false ;
21348 PyObject * obj0 = 0 ;
21349 PyObject * obj1 = 0 ;
21350 PyObject * obj2 = 0 ;
21351 char *kwnames[] = {
21352 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21353 };
21354
21355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21357 if (SWIG_arg_fail(1)) SWIG_fail;
21358 {
21359 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21360 temp2 = true;
21361 }
21362 if (obj2) {
21363 {
21364 arg3 = (bool)(SWIG_As_bool(obj2));
21365 if (SWIG_arg_fail(3)) SWIG_fail;
21366 }
21367 }
21368 {
21369 PyThreadState* __tstate = wxPyBeginAllowThreads();
21370 {
21371 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21372 result = (wxDateTime *) &_result_ref;
21373 }
21374
21375 wxPyEndAllowThreads(__tstate);
21376 if (PyErr_Occurred()) SWIG_fail;
21377 }
21378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21379 {
21380 if (temp2) delete arg2;
21381 }
21382 return resultobj;
21383 fail:
21384 {
21385 if (temp2) delete arg2;
21386 }
21387 return NULL;
21388 }
21389
21390
21391 static PyObject *_wrap_DateTime_FromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21392 PyObject *resultobj;
21393 wxDateTime *arg1 = (wxDateTime *) 0 ;
21394 wxDateTime::TimeZone *arg2 = 0 ;
21395 bool arg3 = (bool) false ;
21396 wxDateTime result;
21397 bool temp2 = false ;
21398 PyObject * obj0 = 0 ;
21399 PyObject * obj1 = 0 ;
21400 PyObject * obj2 = 0 ;
21401 char *kwnames[] = {
21402 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21403 };
21404
21405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21407 if (SWIG_arg_fail(1)) SWIG_fail;
21408 {
21409 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21410 temp2 = true;
21411 }
21412 if (obj2) {
21413 {
21414 arg3 = (bool)(SWIG_As_bool(obj2));
21415 if (SWIG_arg_fail(3)) SWIG_fail;
21416 }
21417 }
21418 {
21419 PyThreadState* __tstate = wxPyBeginAllowThreads();
21420 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21421
21422 wxPyEndAllowThreads(__tstate);
21423 if (PyErr_Occurred()) SWIG_fail;
21424 }
21425 {
21426 wxDateTime * resultptr;
21427 resultptr = new wxDateTime((wxDateTime &)(result));
21428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21429 }
21430 {
21431 if (temp2) delete arg2;
21432 }
21433 return resultobj;
21434 fail:
21435 {
21436 if (temp2) delete arg2;
21437 }
21438 return NULL;
21439 }
21440
21441
21442 static PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21443 PyObject *resultobj;
21444 wxDateTime *arg1 = (wxDateTime *) 0 ;
21445 wxDateTime::TimeZone *arg2 = 0 ;
21446 bool arg3 = (bool) false ;
21447 wxDateTime *result;
21448 bool temp2 = false ;
21449 PyObject * obj0 = 0 ;
21450 PyObject * obj1 = 0 ;
21451 PyObject * obj2 = 0 ;
21452 char *kwnames[] = {
21453 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21454 };
21455
21456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21458 if (SWIG_arg_fail(1)) SWIG_fail;
21459 {
21460 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21461 temp2 = true;
21462 }
21463 if (obj2) {
21464 {
21465 arg3 = (bool)(SWIG_As_bool(obj2));
21466 if (SWIG_arg_fail(3)) SWIG_fail;
21467 }
21468 }
21469 {
21470 PyThreadState* __tstate = wxPyBeginAllowThreads();
21471 {
21472 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21473 result = (wxDateTime *) &_result_ref;
21474 }
21475
21476 wxPyEndAllowThreads(__tstate);
21477 if (PyErr_Occurred()) SWIG_fail;
21478 }
21479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21480 {
21481 if (temp2) delete arg2;
21482 }
21483 return resultobj;
21484 fail:
21485 {
21486 if (temp2) delete arg2;
21487 }
21488 return NULL;
21489 }
21490
21491
21492 static PyObject *_wrap_DateTime_ToUTC(PyObject *, PyObject *args, PyObject *kwargs) {
21493 PyObject *resultobj;
21494 wxDateTime *arg1 = (wxDateTime *) 0 ;
21495 bool arg2 = (bool) false ;
21496 wxDateTime result;
21497 PyObject * obj0 = 0 ;
21498 PyObject * obj1 = 0 ;
21499 char *kwnames[] = {
21500 (char *) "self",(char *) "noDST", NULL
21501 };
21502
21503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) goto fail;
21504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21505 if (SWIG_arg_fail(1)) SWIG_fail;
21506 if (obj1) {
21507 {
21508 arg2 = (bool)(SWIG_As_bool(obj1));
21509 if (SWIG_arg_fail(2)) SWIG_fail;
21510 }
21511 }
21512 {
21513 PyThreadState* __tstate = wxPyBeginAllowThreads();
21514 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
21515
21516 wxPyEndAllowThreads(__tstate);
21517 if (PyErr_Occurred()) SWIG_fail;
21518 }
21519 {
21520 wxDateTime * resultptr;
21521 resultptr = new wxDateTime((wxDateTime &)(result));
21522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21523 }
21524 return resultobj;
21525 fail:
21526 return NULL;
21527 }
21528
21529
21530 static PyObject *_wrap_DateTime_MakeUTC(PyObject *, PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj;
21532 wxDateTime *arg1 = (wxDateTime *) 0 ;
21533 bool arg2 = (bool) false ;
21534 wxDateTime *result;
21535 PyObject * obj0 = 0 ;
21536 PyObject * obj1 = 0 ;
21537 char *kwnames[] = {
21538 (char *) "self",(char *) "noDST", NULL
21539 };
21540
21541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) goto fail;
21542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21543 if (SWIG_arg_fail(1)) SWIG_fail;
21544 if (obj1) {
21545 {
21546 arg2 = (bool)(SWIG_As_bool(obj1));
21547 if (SWIG_arg_fail(2)) SWIG_fail;
21548 }
21549 }
21550 {
21551 PyThreadState* __tstate = wxPyBeginAllowThreads();
21552 {
21553 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
21554 result = (wxDateTime *) &_result_ref;
21555 }
21556
21557 wxPyEndAllowThreads(__tstate);
21558 if (PyErr_Occurred()) SWIG_fail;
21559 }
21560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21561 return resultobj;
21562 fail:
21563 return NULL;
21564 }
21565
21566
21567 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21568 PyObject *resultobj;
21569 wxDateTime *arg1 = (wxDateTime *) 0 ;
21570 bool arg2 = (bool) false ;
21571 wxDateTime result;
21572 PyObject * obj0 = 0 ;
21573 PyObject * obj1 = 0 ;
21574 char *kwnames[] = {
21575 (char *) "self",(char *) "noDST", NULL
21576 };
21577
21578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21580 if (SWIG_arg_fail(1)) SWIG_fail;
21581 if (obj1) {
21582 {
21583 arg2 = (bool)(SWIG_As_bool(obj1));
21584 if (SWIG_arg_fail(2)) SWIG_fail;
21585 }
21586 }
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
21590
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 {
21595 wxDateTime * resultptr;
21596 resultptr = new wxDateTime((wxDateTime &)(result));
21597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21598 }
21599 return resultobj;
21600 fail:
21601 return NULL;
21602 }
21603
21604
21605 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21606 PyObject *resultobj;
21607 wxDateTime *arg1 = (wxDateTime *) 0 ;
21608 bool arg2 = (bool) false ;
21609 wxDateTime *result;
21610 PyObject * obj0 = 0 ;
21611 PyObject * obj1 = 0 ;
21612 char *kwnames[] = {
21613 (char *) "self",(char *) "noDST", NULL
21614 };
21615
21616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21618 if (SWIG_arg_fail(1)) SWIG_fail;
21619 if (obj1) {
21620 {
21621 arg2 = (bool)(SWIG_As_bool(obj1));
21622 if (SWIG_arg_fail(2)) SWIG_fail;
21623 }
21624 }
21625 {
21626 PyThreadState* __tstate = wxPyBeginAllowThreads();
21627 {
21628 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21629 result = (wxDateTime *) &_result_ref;
21630 }
21631
21632 wxPyEndAllowThreads(__tstate);
21633 if (PyErr_Occurred()) SWIG_fail;
21634 }
21635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21636 return resultobj;
21637 fail:
21638 return NULL;
21639 }
21640
21641
21642 static PyObject *_wrap_DateTime_FromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
21643 PyObject *resultobj;
21644 wxDateTime *arg1 = (wxDateTime *) 0 ;
21645 bool arg2 = (bool) false ;
21646 wxDateTime result;
21647 PyObject * obj0 = 0 ;
21648 PyObject * obj1 = 0 ;
21649 char *kwnames[] = {
21650 (char *) "self",(char *) "noDST", NULL
21651 };
21652
21653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) goto fail;
21654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21655 if (SWIG_arg_fail(1)) SWIG_fail;
21656 if (obj1) {
21657 {
21658 arg2 = (bool)(SWIG_As_bool(obj1));
21659 if (SWIG_arg_fail(2)) SWIG_fail;
21660 }
21661 }
21662 {
21663 PyThreadState* __tstate = wxPyBeginAllowThreads();
21664 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
21665
21666 wxPyEndAllowThreads(__tstate);
21667 if (PyErr_Occurred()) SWIG_fail;
21668 }
21669 {
21670 wxDateTime * resultptr;
21671 resultptr = new wxDateTime((wxDateTime &)(result));
21672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21673 }
21674 return resultobj;
21675 fail:
21676 return NULL;
21677 }
21678
21679
21680 static PyObject *_wrap_DateTime_MakeFromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
21681 PyObject *resultobj;
21682 wxDateTime *arg1 = (wxDateTime *) 0 ;
21683 bool arg2 = (bool) false ;
21684 wxDateTime *result;
21685 PyObject * obj0 = 0 ;
21686 PyObject * obj1 = 0 ;
21687 char *kwnames[] = {
21688 (char *) "self",(char *) "noDST", NULL
21689 };
21690
21691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) goto fail;
21692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21693 if (SWIG_arg_fail(1)) SWIG_fail;
21694 if (obj1) {
21695 {
21696 arg2 = (bool)(SWIG_As_bool(obj1));
21697 if (SWIG_arg_fail(2)) SWIG_fail;
21698 }
21699 }
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 {
21703 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
21704 result = (wxDateTime *) &_result_ref;
21705 }
21706
21707 wxPyEndAllowThreads(__tstate);
21708 if (PyErr_Occurred()) SWIG_fail;
21709 }
21710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21711 return resultobj;
21712 fail:
21713 return NULL;
21714 }
21715
21716
21717 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21718 PyObject *resultobj;
21719 wxDateTime *arg1 = (wxDateTime *) 0 ;
21720 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21721 int result;
21722 PyObject * obj0 = 0 ;
21723 PyObject * obj1 = 0 ;
21724 char *kwnames[] = {
21725 (char *) "self",(char *) "country", NULL
21726 };
21727
21728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21730 if (SWIG_arg_fail(1)) SWIG_fail;
21731 if (obj1) {
21732 {
21733 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21734 if (SWIG_arg_fail(2)) SWIG_fail;
21735 }
21736 }
21737 {
21738 PyThreadState* __tstate = wxPyBeginAllowThreads();
21739 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21740
21741 wxPyEndAllowThreads(__tstate);
21742 if (PyErr_Occurred()) SWIG_fail;
21743 }
21744 {
21745 resultobj = SWIG_From_int((int)(result));
21746 }
21747 return resultobj;
21748 fail:
21749 return NULL;
21750 }
21751
21752
21753 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21754 PyObject *resultobj;
21755 wxDateTime *arg1 = (wxDateTime *) 0 ;
21756 bool result;
21757 PyObject * obj0 = 0 ;
21758 char *kwnames[] = {
21759 (char *) "self", NULL
21760 };
21761
21762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21764 if (SWIG_arg_fail(1)) SWIG_fail;
21765 {
21766 PyThreadState* __tstate = wxPyBeginAllowThreads();
21767 result = (bool)((wxDateTime const *)arg1)->IsValid();
21768
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 {
21773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21774 }
21775 return resultobj;
21776 fail:
21777 return NULL;
21778 }
21779
21780
21781 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21782 PyObject *resultobj;
21783 wxDateTime *arg1 = (wxDateTime *) 0 ;
21784 time_t result;
21785 PyObject * obj0 = 0 ;
21786 char *kwnames[] = {
21787 (char *) "self", NULL
21788 };
21789
21790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21792 if (SWIG_arg_fail(1)) SWIG_fail;
21793 {
21794 PyThreadState* __tstate = wxPyBeginAllowThreads();
21795 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21796
21797 wxPyEndAllowThreads(__tstate);
21798 if (PyErr_Occurred()) SWIG_fail;
21799 }
21800 {
21801 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21802 }
21803 return resultobj;
21804 fail:
21805 return NULL;
21806 }
21807
21808
21809 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21810 PyObject *resultobj;
21811 wxDateTime *arg1 = (wxDateTime *) 0 ;
21812 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21813 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21814 int result;
21815 bool temp2 = false ;
21816 PyObject * obj0 = 0 ;
21817 PyObject * obj1 = 0 ;
21818 char *kwnames[] = {
21819 (char *) "self",(char *) "tz", NULL
21820 };
21821
21822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21824 if (SWIG_arg_fail(1)) SWIG_fail;
21825 if (obj1) {
21826 {
21827 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21828 temp2 = true;
21829 }
21830 }
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21834
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 {
21839 resultobj = SWIG_From_int((int)(result));
21840 }
21841 {
21842 if (temp2) delete arg2;
21843 }
21844 return resultobj;
21845 fail:
21846 {
21847 if (temp2) delete arg2;
21848 }
21849 return NULL;
21850 }
21851
21852
21853 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21854 PyObject *resultobj;
21855 wxDateTime *arg1 = (wxDateTime *) 0 ;
21856 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21857 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21858 wxDateTime::Month result;
21859 bool temp2 = false ;
21860 PyObject * obj0 = 0 ;
21861 PyObject * obj1 = 0 ;
21862 char *kwnames[] = {
21863 (char *) "self",(char *) "tz", NULL
21864 };
21865
21866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21868 if (SWIG_arg_fail(1)) SWIG_fail;
21869 if (obj1) {
21870 {
21871 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21872 temp2 = true;
21873 }
21874 }
21875 {
21876 PyThreadState* __tstate = wxPyBeginAllowThreads();
21877 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21878
21879 wxPyEndAllowThreads(__tstate);
21880 if (PyErr_Occurred()) SWIG_fail;
21881 }
21882 resultobj = SWIG_From_int((result));
21883 {
21884 if (temp2) delete arg2;
21885 }
21886 return resultobj;
21887 fail:
21888 {
21889 if (temp2) delete arg2;
21890 }
21891 return NULL;
21892 }
21893
21894
21895 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21896 PyObject *resultobj;
21897 wxDateTime *arg1 = (wxDateTime *) 0 ;
21898 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21899 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21900 int result;
21901 bool temp2 = false ;
21902 PyObject * obj0 = 0 ;
21903 PyObject * obj1 = 0 ;
21904 char *kwnames[] = {
21905 (char *) "self",(char *) "tz", NULL
21906 };
21907
21908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21910 if (SWIG_arg_fail(1)) SWIG_fail;
21911 if (obj1) {
21912 {
21913 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21914 temp2 = true;
21915 }
21916 }
21917 {
21918 PyThreadState* __tstate = wxPyBeginAllowThreads();
21919 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21920
21921 wxPyEndAllowThreads(__tstate);
21922 if (PyErr_Occurred()) SWIG_fail;
21923 }
21924 {
21925 resultobj = SWIG_From_int((int)(result));
21926 }
21927 {
21928 if (temp2) delete arg2;
21929 }
21930 return resultobj;
21931 fail:
21932 {
21933 if (temp2) delete arg2;
21934 }
21935 return NULL;
21936 }
21937
21938
21939 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21940 PyObject *resultobj;
21941 wxDateTime *arg1 = (wxDateTime *) 0 ;
21942 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21943 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21944 wxDateTime::WeekDay result;
21945 bool temp2 = false ;
21946 PyObject * obj0 = 0 ;
21947 PyObject * obj1 = 0 ;
21948 char *kwnames[] = {
21949 (char *) "self",(char *) "tz", NULL
21950 };
21951
21952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21954 if (SWIG_arg_fail(1)) SWIG_fail;
21955 if (obj1) {
21956 {
21957 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21958 temp2 = true;
21959 }
21960 }
21961 {
21962 PyThreadState* __tstate = wxPyBeginAllowThreads();
21963 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21964
21965 wxPyEndAllowThreads(__tstate);
21966 if (PyErr_Occurred()) SWIG_fail;
21967 }
21968 resultobj = SWIG_From_int((result));
21969 {
21970 if (temp2) delete arg2;
21971 }
21972 return resultobj;
21973 fail:
21974 {
21975 if (temp2) delete arg2;
21976 }
21977 return NULL;
21978 }
21979
21980
21981 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21982 PyObject *resultobj;
21983 wxDateTime *arg1 = (wxDateTime *) 0 ;
21984 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21985 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21986 int result;
21987 bool temp2 = false ;
21988 PyObject * obj0 = 0 ;
21989 PyObject * obj1 = 0 ;
21990 char *kwnames[] = {
21991 (char *) "self",(char *) "tz", NULL
21992 };
21993
21994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21996 if (SWIG_arg_fail(1)) SWIG_fail;
21997 if (obj1) {
21998 {
21999 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22000 temp2 = true;
22001 }
22002 }
22003 {
22004 PyThreadState* __tstate = wxPyBeginAllowThreads();
22005 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
22006
22007 wxPyEndAllowThreads(__tstate);
22008 if (PyErr_Occurred()) SWIG_fail;
22009 }
22010 {
22011 resultobj = SWIG_From_int((int)(result));
22012 }
22013 {
22014 if (temp2) delete arg2;
22015 }
22016 return resultobj;
22017 fail:
22018 {
22019 if (temp2) delete arg2;
22020 }
22021 return NULL;
22022 }
22023
22024
22025 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
22026 PyObject *resultobj;
22027 wxDateTime *arg1 = (wxDateTime *) 0 ;
22028 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22029 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22030 int result;
22031 bool temp2 = false ;
22032 PyObject * obj0 = 0 ;
22033 PyObject * obj1 = 0 ;
22034 char *kwnames[] = {
22035 (char *) "self",(char *) "tz", NULL
22036 };
22037
22038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
22039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22040 if (SWIG_arg_fail(1)) SWIG_fail;
22041 if (obj1) {
22042 {
22043 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22044 temp2 = true;
22045 }
22046 }
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
22050
22051 wxPyEndAllowThreads(__tstate);
22052 if (PyErr_Occurred()) SWIG_fail;
22053 }
22054 {
22055 resultobj = SWIG_From_int((int)(result));
22056 }
22057 {
22058 if (temp2) delete arg2;
22059 }
22060 return resultobj;
22061 fail:
22062 {
22063 if (temp2) delete arg2;
22064 }
22065 return NULL;
22066 }
22067
22068
22069 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
22070 PyObject *resultobj;
22071 wxDateTime *arg1 = (wxDateTime *) 0 ;
22072 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22073 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22074 int result;
22075 bool temp2 = false ;
22076 PyObject * obj0 = 0 ;
22077 PyObject * obj1 = 0 ;
22078 char *kwnames[] = {
22079 (char *) "self",(char *) "tz", NULL
22080 };
22081
22082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
22083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22084 if (SWIG_arg_fail(1)) SWIG_fail;
22085 if (obj1) {
22086 {
22087 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22088 temp2 = true;
22089 }
22090 }
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
22094
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 {
22099 resultobj = SWIG_From_int((int)(result));
22100 }
22101 {
22102 if (temp2) delete arg2;
22103 }
22104 return resultobj;
22105 fail:
22106 {
22107 if (temp2) delete arg2;
22108 }
22109 return NULL;
22110 }
22111
22112
22113 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
22114 PyObject *resultobj;
22115 wxDateTime *arg1 = (wxDateTime *) 0 ;
22116 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22117 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22118 int result;
22119 bool temp2 = false ;
22120 PyObject * obj0 = 0 ;
22121 PyObject * obj1 = 0 ;
22122 char *kwnames[] = {
22123 (char *) "self",(char *) "tz", NULL
22124 };
22125
22126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
22127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22128 if (SWIG_arg_fail(1)) SWIG_fail;
22129 if (obj1) {
22130 {
22131 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22132 temp2 = true;
22133 }
22134 }
22135 {
22136 PyThreadState* __tstate = wxPyBeginAllowThreads();
22137 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
22138
22139 wxPyEndAllowThreads(__tstate);
22140 if (PyErr_Occurred()) SWIG_fail;
22141 }
22142 {
22143 resultobj = SWIG_From_int((int)(result));
22144 }
22145 {
22146 if (temp2) delete arg2;
22147 }
22148 return resultobj;
22149 fail:
22150 {
22151 if (temp2) delete arg2;
22152 }
22153 return NULL;
22154 }
22155
22156
22157 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
22158 PyObject *resultobj;
22159 wxDateTime *arg1 = (wxDateTime *) 0 ;
22160 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22161 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22162 int result;
22163 bool temp2 = false ;
22164 PyObject * obj0 = 0 ;
22165 PyObject * obj1 = 0 ;
22166 char *kwnames[] = {
22167 (char *) "self",(char *) "tz", NULL
22168 };
22169
22170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
22171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22172 if (SWIG_arg_fail(1)) SWIG_fail;
22173 if (obj1) {
22174 {
22175 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22176 temp2 = true;
22177 }
22178 }
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
22182
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 {
22187 resultobj = SWIG_From_int((int)(result));
22188 }
22189 {
22190 if (temp2) delete arg2;
22191 }
22192 return resultobj;
22193 fail:
22194 {
22195 if (temp2) delete arg2;
22196 }
22197 return NULL;
22198 }
22199
22200
22201 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
22202 PyObject *resultobj;
22203 wxDateTime *arg1 = (wxDateTime *) 0 ;
22204 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22205 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22206 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22207 int result;
22208 bool temp3 = false ;
22209 PyObject * obj0 = 0 ;
22210 PyObject * obj1 = 0 ;
22211 PyObject * obj2 = 0 ;
22212 char *kwnames[] = {
22213 (char *) "self",(char *) "flags",(char *) "tz", NULL
22214 };
22215
22216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
22217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22218 if (SWIG_arg_fail(1)) SWIG_fail;
22219 if (obj1) {
22220 {
22221 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22222 if (SWIG_arg_fail(2)) SWIG_fail;
22223 }
22224 }
22225 if (obj2) {
22226 {
22227 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22228 temp3 = true;
22229 }
22230 }
22231 {
22232 PyThreadState* __tstate = wxPyBeginAllowThreads();
22233 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22234
22235 wxPyEndAllowThreads(__tstate);
22236 if (PyErr_Occurred()) SWIG_fail;
22237 }
22238 {
22239 resultobj = SWIG_From_int((int)(result));
22240 }
22241 {
22242 if (temp3) delete arg3;
22243 }
22244 return resultobj;
22245 fail:
22246 {
22247 if (temp3) delete arg3;
22248 }
22249 return NULL;
22250 }
22251
22252
22253 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22254 PyObject *resultobj;
22255 wxDateTime *arg1 = (wxDateTime *) 0 ;
22256 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22257 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22258 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22259 int result;
22260 bool temp3 = false ;
22261 PyObject * obj0 = 0 ;
22262 PyObject * obj1 = 0 ;
22263 PyObject * obj2 = 0 ;
22264 char *kwnames[] = {
22265 (char *) "self",(char *) "flags",(char *) "tz", NULL
22266 };
22267
22268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22270 if (SWIG_arg_fail(1)) SWIG_fail;
22271 if (obj1) {
22272 {
22273 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22274 if (SWIG_arg_fail(2)) SWIG_fail;
22275 }
22276 }
22277 if (obj2) {
22278 {
22279 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22280 temp3 = true;
22281 }
22282 }
22283 {
22284 PyThreadState* __tstate = wxPyBeginAllowThreads();
22285 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22286
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 {
22291 resultobj = SWIG_From_int((int)(result));
22292 }
22293 {
22294 if (temp3) delete arg3;
22295 }
22296 return resultobj;
22297 fail:
22298 {
22299 if (temp3) delete arg3;
22300 }
22301 return NULL;
22302 }
22303
22304
22305 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22306 PyObject *resultobj;
22307 wxDateTime *arg1 = (wxDateTime *) 0 ;
22308 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22309 bool result;
22310 PyObject * obj0 = 0 ;
22311 PyObject * obj1 = 0 ;
22312 char *kwnames[] = {
22313 (char *) "self",(char *) "country", NULL
22314 };
22315
22316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22318 if (SWIG_arg_fail(1)) SWIG_fail;
22319 if (obj1) {
22320 {
22321 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22322 if (SWIG_arg_fail(2)) SWIG_fail;
22323 }
22324 }
22325 {
22326 PyThreadState* __tstate = wxPyBeginAllowThreads();
22327 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22328
22329 wxPyEndAllowThreads(__tstate);
22330 if (PyErr_Occurred()) SWIG_fail;
22331 }
22332 {
22333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22334 }
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22342 PyObject *resultobj;
22343 wxDateTime *arg1 = (wxDateTime *) 0 ;
22344 wxDateTime *arg2 = 0 ;
22345 bool result;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348 char *kwnames[] = {
22349 (char *) "self",(char *) "datetime", NULL
22350 };
22351
22352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22354 if (SWIG_arg_fail(1)) SWIG_fail;
22355 {
22356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22357 if (SWIG_arg_fail(2)) SWIG_fail;
22358 if (arg2 == NULL) {
22359 SWIG_null_ref("wxDateTime");
22360 }
22361 if (SWIG_arg_fail(2)) SWIG_fail;
22362 }
22363 {
22364 PyThreadState* __tstate = wxPyBeginAllowThreads();
22365 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22366
22367 wxPyEndAllowThreads(__tstate);
22368 if (PyErr_Occurred()) SWIG_fail;
22369 }
22370 {
22371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22372 }
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22380 PyObject *resultobj;
22381 wxDateTime *arg1 = (wxDateTime *) 0 ;
22382 wxDateTime *arg2 = 0 ;
22383 bool result;
22384 PyObject * obj0 = 0 ;
22385 PyObject * obj1 = 0 ;
22386 char *kwnames[] = {
22387 (char *) "self",(char *) "datetime", NULL
22388 };
22389
22390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22392 if (SWIG_arg_fail(1)) SWIG_fail;
22393 {
22394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22395 if (SWIG_arg_fail(2)) SWIG_fail;
22396 if (arg2 == NULL) {
22397 SWIG_null_ref("wxDateTime");
22398 }
22399 if (SWIG_arg_fail(2)) SWIG_fail;
22400 }
22401 {
22402 PyThreadState* __tstate = wxPyBeginAllowThreads();
22403 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22404
22405 wxPyEndAllowThreads(__tstate);
22406 if (PyErr_Occurred()) SWIG_fail;
22407 }
22408 {
22409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22410 }
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22418 PyObject *resultobj;
22419 wxDateTime *arg1 = (wxDateTime *) 0 ;
22420 wxDateTime *arg2 = 0 ;
22421 bool result;
22422 PyObject * obj0 = 0 ;
22423 PyObject * obj1 = 0 ;
22424 char *kwnames[] = {
22425 (char *) "self",(char *) "datetime", NULL
22426 };
22427
22428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22430 if (SWIG_arg_fail(1)) SWIG_fail;
22431 {
22432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22433 if (SWIG_arg_fail(2)) SWIG_fail;
22434 if (arg2 == NULL) {
22435 SWIG_null_ref("wxDateTime");
22436 }
22437 if (SWIG_arg_fail(2)) SWIG_fail;
22438 }
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22442
22443 wxPyEndAllowThreads(__tstate);
22444 if (PyErr_Occurred()) SWIG_fail;
22445 }
22446 {
22447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22448 }
22449 return resultobj;
22450 fail:
22451 return NULL;
22452 }
22453
22454
22455 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22456 PyObject *resultobj;
22457 wxDateTime *arg1 = (wxDateTime *) 0 ;
22458 wxDateTime *arg2 = 0 ;
22459 wxDateTime *arg3 = 0 ;
22460 bool result;
22461 PyObject * obj0 = 0 ;
22462 PyObject * obj1 = 0 ;
22463 PyObject * obj2 = 0 ;
22464 char *kwnames[] = {
22465 (char *) "self",(char *) "t1",(char *) "t2", NULL
22466 };
22467
22468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22470 if (SWIG_arg_fail(1)) SWIG_fail;
22471 {
22472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22473 if (SWIG_arg_fail(2)) SWIG_fail;
22474 if (arg2 == NULL) {
22475 SWIG_null_ref("wxDateTime");
22476 }
22477 if (SWIG_arg_fail(2)) SWIG_fail;
22478 }
22479 {
22480 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22481 if (SWIG_arg_fail(3)) SWIG_fail;
22482 if (arg3 == NULL) {
22483 SWIG_null_ref("wxDateTime");
22484 }
22485 if (SWIG_arg_fail(3)) SWIG_fail;
22486 }
22487 {
22488 PyThreadState* __tstate = wxPyBeginAllowThreads();
22489 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22490
22491 wxPyEndAllowThreads(__tstate);
22492 if (PyErr_Occurred()) SWIG_fail;
22493 }
22494 {
22495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22496 }
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22504 PyObject *resultobj;
22505 wxDateTime *arg1 = (wxDateTime *) 0 ;
22506 wxDateTime *arg2 = 0 ;
22507 wxDateTime *arg3 = 0 ;
22508 bool result;
22509 PyObject * obj0 = 0 ;
22510 PyObject * obj1 = 0 ;
22511 PyObject * obj2 = 0 ;
22512 char *kwnames[] = {
22513 (char *) "self",(char *) "t1",(char *) "t2", NULL
22514 };
22515
22516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22518 if (SWIG_arg_fail(1)) SWIG_fail;
22519 {
22520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22521 if (SWIG_arg_fail(2)) SWIG_fail;
22522 if (arg2 == NULL) {
22523 SWIG_null_ref("wxDateTime");
22524 }
22525 if (SWIG_arg_fail(2)) SWIG_fail;
22526 }
22527 {
22528 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22529 if (SWIG_arg_fail(3)) SWIG_fail;
22530 if (arg3 == NULL) {
22531 SWIG_null_ref("wxDateTime");
22532 }
22533 if (SWIG_arg_fail(3)) SWIG_fail;
22534 }
22535 {
22536 PyThreadState* __tstate = wxPyBeginAllowThreads();
22537 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22538
22539 wxPyEndAllowThreads(__tstate);
22540 if (PyErr_Occurred()) SWIG_fail;
22541 }
22542 {
22543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22544 }
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22552 PyObject *resultobj;
22553 wxDateTime *arg1 = (wxDateTime *) 0 ;
22554 wxDateTime *arg2 = 0 ;
22555 bool result;
22556 PyObject * obj0 = 0 ;
22557 PyObject * obj1 = 0 ;
22558 char *kwnames[] = {
22559 (char *) "self",(char *) "dt", NULL
22560 };
22561
22562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22564 if (SWIG_arg_fail(1)) SWIG_fail;
22565 {
22566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22567 if (SWIG_arg_fail(2)) SWIG_fail;
22568 if (arg2 == NULL) {
22569 SWIG_null_ref("wxDateTime");
22570 }
22571 if (SWIG_arg_fail(2)) SWIG_fail;
22572 }
22573 {
22574 PyThreadState* __tstate = wxPyBeginAllowThreads();
22575 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22576
22577 wxPyEndAllowThreads(__tstate);
22578 if (PyErr_Occurred()) SWIG_fail;
22579 }
22580 {
22581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22582 }
22583 return resultobj;
22584 fail:
22585 return NULL;
22586 }
22587
22588
22589 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22590 PyObject *resultobj;
22591 wxDateTime *arg1 = (wxDateTime *) 0 ;
22592 wxDateTime *arg2 = 0 ;
22593 bool result;
22594 PyObject * obj0 = 0 ;
22595 PyObject * obj1 = 0 ;
22596 char *kwnames[] = {
22597 (char *) "self",(char *) "dt", NULL
22598 };
22599
22600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22602 if (SWIG_arg_fail(1)) SWIG_fail;
22603 {
22604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22605 if (SWIG_arg_fail(2)) SWIG_fail;
22606 if (arg2 == NULL) {
22607 SWIG_null_ref("wxDateTime");
22608 }
22609 if (SWIG_arg_fail(2)) SWIG_fail;
22610 }
22611 {
22612 PyThreadState* __tstate = wxPyBeginAllowThreads();
22613 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22614
22615 wxPyEndAllowThreads(__tstate);
22616 if (PyErr_Occurred()) SWIG_fail;
22617 }
22618 {
22619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22620 }
22621 return resultobj;
22622 fail:
22623 return NULL;
22624 }
22625
22626
22627 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22628 PyObject *resultobj;
22629 wxDateTime *arg1 = (wxDateTime *) 0 ;
22630 wxDateTime *arg2 = 0 ;
22631 wxTimeSpan *arg3 = 0 ;
22632 bool result;
22633 PyObject * obj0 = 0 ;
22634 PyObject * obj1 = 0 ;
22635 PyObject * obj2 = 0 ;
22636 char *kwnames[] = {
22637 (char *) "self",(char *) "dt",(char *) "ts", NULL
22638 };
22639
22640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22642 if (SWIG_arg_fail(1)) SWIG_fail;
22643 {
22644 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22645 if (SWIG_arg_fail(2)) SWIG_fail;
22646 if (arg2 == NULL) {
22647 SWIG_null_ref("wxDateTime");
22648 }
22649 if (SWIG_arg_fail(2)) SWIG_fail;
22650 }
22651 {
22652 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22653 if (SWIG_arg_fail(3)) SWIG_fail;
22654 if (arg3 == NULL) {
22655 SWIG_null_ref("wxTimeSpan");
22656 }
22657 if (SWIG_arg_fail(3)) SWIG_fail;
22658 }
22659 {
22660 PyThreadState* __tstate = wxPyBeginAllowThreads();
22661 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22662
22663 wxPyEndAllowThreads(__tstate);
22664 if (PyErr_Occurred()) SWIG_fail;
22665 }
22666 {
22667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22668 }
22669 return resultobj;
22670 fail:
22671 return NULL;
22672 }
22673
22674
22675 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22676 PyObject *resultobj;
22677 wxDateTime *arg1 = (wxDateTime *) 0 ;
22678 wxTimeSpan *arg2 = 0 ;
22679 wxDateTime *result;
22680 PyObject * obj0 = 0 ;
22681 PyObject * obj1 = 0 ;
22682 char *kwnames[] = {
22683 (char *) "self",(char *) "diff", NULL
22684 };
22685
22686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22688 if (SWIG_arg_fail(1)) SWIG_fail;
22689 {
22690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22691 if (SWIG_arg_fail(2)) SWIG_fail;
22692 if (arg2 == NULL) {
22693 SWIG_null_ref("wxTimeSpan");
22694 }
22695 if (SWIG_arg_fail(2)) SWIG_fail;
22696 }
22697 {
22698 PyThreadState* __tstate = wxPyBeginAllowThreads();
22699 {
22700 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22701 result = (wxDateTime *) &_result_ref;
22702 }
22703
22704 wxPyEndAllowThreads(__tstate);
22705 if (PyErr_Occurred()) SWIG_fail;
22706 }
22707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22715 PyObject *resultobj;
22716 wxDateTime *arg1 = (wxDateTime *) 0 ;
22717 wxDateSpan *arg2 = 0 ;
22718 wxDateTime *result;
22719 PyObject * obj0 = 0 ;
22720 PyObject * obj1 = 0 ;
22721 char *kwnames[] = {
22722 (char *) "self",(char *) "diff", NULL
22723 };
22724
22725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22727 if (SWIG_arg_fail(1)) SWIG_fail;
22728 {
22729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22730 if (SWIG_arg_fail(2)) SWIG_fail;
22731 if (arg2 == NULL) {
22732 SWIG_null_ref("wxDateSpan");
22733 }
22734 if (SWIG_arg_fail(2)) SWIG_fail;
22735 }
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 {
22739 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22740 result = (wxDateTime *) &_result_ref;
22741 }
22742
22743 wxPyEndAllowThreads(__tstate);
22744 if (PyErr_Occurred()) SWIG_fail;
22745 }
22746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22747 return resultobj;
22748 fail:
22749 return NULL;
22750 }
22751
22752
22753 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22754 PyObject *resultobj;
22755 wxDateTime *arg1 = (wxDateTime *) 0 ;
22756 wxTimeSpan *arg2 = 0 ;
22757 wxDateTime *result;
22758 PyObject * obj0 = 0 ;
22759 PyObject * obj1 = 0 ;
22760 char *kwnames[] = {
22761 (char *) "self",(char *) "diff", NULL
22762 };
22763
22764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22766 if (SWIG_arg_fail(1)) SWIG_fail;
22767 {
22768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22769 if (SWIG_arg_fail(2)) SWIG_fail;
22770 if (arg2 == NULL) {
22771 SWIG_null_ref("wxTimeSpan");
22772 }
22773 if (SWIG_arg_fail(2)) SWIG_fail;
22774 }
22775 {
22776 PyThreadState* __tstate = wxPyBeginAllowThreads();
22777 {
22778 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22779 result = (wxDateTime *) &_result_ref;
22780 }
22781
22782 wxPyEndAllowThreads(__tstate);
22783 if (PyErr_Occurred()) SWIG_fail;
22784 }
22785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22786 return resultobj;
22787 fail:
22788 return NULL;
22789 }
22790
22791
22792 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22793 PyObject *resultobj;
22794 wxDateTime *arg1 = (wxDateTime *) 0 ;
22795 wxDateSpan *arg2 = 0 ;
22796 wxDateTime *result;
22797 PyObject * obj0 = 0 ;
22798 PyObject * obj1 = 0 ;
22799 char *kwnames[] = {
22800 (char *) "self",(char *) "diff", NULL
22801 };
22802
22803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22805 if (SWIG_arg_fail(1)) SWIG_fail;
22806 {
22807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22808 if (SWIG_arg_fail(2)) SWIG_fail;
22809 if (arg2 == NULL) {
22810 SWIG_null_ref("wxDateSpan");
22811 }
22812 if (SWIG_arg_fail(2)) SWIG_fail;
22813 }
22814 {
22815 PyThreadState* __tstate = wxPyBeginAllowThreads();
22816 {
22817 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22818 result = (wxDateTime *) &_result_ref;
22819 }
22820
22821 wxPyEndAllowThreads(__tstate);
22822 if (PyErr_Occurred()) SWIG_fail;
22823 }
22824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22825 return resultobj;
22826 fail:
22827 return NULL;
22828 }
22829
22830
22831 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22832 PyObject *resultobj;
22833 wxDateTime *arg1 = (wxDateTime *) 0 ;
22834 wxDateTime *arg2 = 0 ;
22835 wxTimeSpan result;
22836 PyObject * obj0 = 0 ;
22837 PyObject * obj1 = 0 ;
22838 char *kwnames[] = {
22839 (char *) "self",(char *) "dt", NULL
22840 };
22841
22842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22844 if (SWIG_arg_fail(1)) SWIG_fail;
22845 {
22846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22847 if (SWIG_arg_fail(2)) SWIG_fail;
22848 if (arg2 == NULL) {
22849 SWIG_null_ref("wxDateTime");
22850 }
22851 if (SWIG_arg_fail(2)) SWIG_fail;
22852 }
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22856
22857 wxPyEndAllowThreads(__tstate);
22858 if (PyErr_Occurred()) SWIG_fail;
22859 }
22860 {
22861 wxTimeSpan * resultptr;
22862 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22864 }
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22872 PyObject *resultobj;
22873 wxDateTime *arg1 = (wxDateTime *) 0 ;
22874 wxTimeSpan *arg2 = 0 ;
22875 wxDateTime *result;
22876 PyObject * obj0 = 0 ;
22877 PyObject * obj1 = 0 ;
22878
22879 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22881 if (SWIG_arg_fail(1)) SWIG_fail;
22882 {
22883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22884 if (SWIG_arg_fail(2)) SWIG_fail;
22885 if (arg2 == NULL) {
22886 SWIG_null_ref("wxTimeSpan");
22887 }
22888 if (SWIG_arg_fail(2)) SWIG_fail;
22889 }
22890 {
22891 PyThreadState* __tstate = wxPyBeginAllowThreads();
22892 {
22893 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22894 result = (wxDateTime *) &_result_ref;
22895 }
22896
22897 wxPyEndAllowThreads(__tstate);
22898 if (PyErr_Occurred()) SWIG_fail;
22899 }
22900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22908 PyObject *resultobj;
22909 wxDateTime *arg1 = (wxDateTime *) 0 ;
22910 wxDateSpan *arg2 = 0 ;
22911 wxDateTime *result;
22912 PyObject * obj0 = 0 ;
22913 PyObject * obj1 = 0 ;
22914
22915 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22917 if (SWIG_arg_fail(1)) SWIG_fail;
22918 {
22919 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22920 if (SWIG_arg_fail(2)) SWIG_fail;
22921 if (arg2 == NULL) {
22922 SWIG_null_ref("wxDateSpan");
22923 }
22924 if (SWIG_arg_fail(2)) SWIG_fail;
22925 }
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 {
22929 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22930 result = (wxDateTime *) &_result_ref;
22931 }
22932
22933 wxPyEndAllowThreads(__tstate);
22934 if (PyErr_Occurred()) SWIG_fail;
22935 }
22936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22937 return resultobj;
22938 fail:
22939 return NULL;
22940 }
22941
22942
22943 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22944 int argc;
22945 PyObject *argv[3];
22946 int ii;
22947
22948 argc = PyObject_Length(args);
22949 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22950 argv[ii] = PyTuple_GetItem(args,ii);
22951 }
22952 if (argc == 2) {
22953 int _v;
22954 {
22955 void *ptr;
22956 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22957 _v = 0;
22958 PyErr_Clear();
22959 } else {
22960 _v = 1;
22961 }
22962 }
22963 if (_v) {
22964 {
22965 void *ptr = 0;
22966 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22967 _v = 0;
22968 PyErr_Clear();
22969 } else {
22970 _v = (ptr != 0);
22971 }
22972 }
22973 if (_v) {
22974 return _wrap_DateTime___iadd____SWIG_0(self,args);
22975 }
22976 }
22977 }
22978 if (argc == 2) {
22979 int _v;
22980 {
22981 void *ptr;
22982 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22983 _v = 0;
22984 PyErr_Clear();
22985 } else {
22986 _v = 1;
22987 }
22988 }
22989 if (_v) {
22990 {
22991 void *ptr = 0;
22992 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22993 _v = 0;
22994 PyErr_Clear();
22995 } else {
22996 _v = (ptr != 0);
22997 }
22998 }
22999 if (_v) {
23000 return _wrap_DateTime___iadd____SWIG_1(self,args);
23001 }
23002 }
23003 }
23004
23005 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
23006 return NULL;
23007 }
23008
23009
23010 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
23011 PyObject *resultobj;
23012 wxDateTime *arg1 = (wxDateTime *) 0 ;
23013 wxTimeSpan *arg2 = 0 ;
23014 wxDateTime *result;
23015 PyObject * obj0 = 0 ;
23016 PyObject * obj1 = 0 ;
23017
23018 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
23019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23020 if (SWIG_arg_fail(1)) SWIG_fail;
23021 {
23022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23023 if (SWIG_arg_fail(2)) SWIG_fail;
23024 if (arg2 == NULL) {
23025 SWIG_null_ref("wxTimeSpan");
23026 }
23027 if (SWIG_arg_fail(2)) SWIG_fail;
23028 }
23029 {
23030 PyThreadState* __tstate = wxPyBeginAllowThreads();
23031 {
23032 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23033 result = (wxDateTime *) &_result_ref;
23034 }
23035
23036 wxPyEndAllowThreads(__tstate);
23037 if (PyErr_Occurred()) SWIG_fail;
23038 }
23039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23040 return resultobj;
23041 fail:
23042 return NULL;
23043 }
23044
23045
23046 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
23047 PyObject *resultobj;
23048 wxDateTime *arg1 = (wxDateTime *) 0 ;
23049 wxDateSpan *arg2 = 0 ;
23050 wxDateTime *result;
23051 PyObject * obj0 = 0 ;
23052 PyObject * obj1 = 0 ;
23053
23054 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
23055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23056 if (SWIG_arg_fail(1)) SWIG_fail;
23057 {
23058 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23059 if (SWIG_arg_fail(2)) SWIG_fail;
23060 if (arg2 == NULL) {
23061 SWIG_null_ref("wxDateSpan");
23062 }
23063 if (SWIG_arg_fail(2)) SWIG_fail;
23064 }
23065 {
23066 PyThreadState* __tstate = wxPyBeginAllowThreads();
23067 {
23068 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
23069 result = (wxDateTime *) &_result_ref;
23070 }
23071
23072 wxPyEndAllowThreads(__tstate);
23073 if (PyErr_Occurred()) SWIG_fail;
23074 }
23075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
23083 int argc;
23084 PyObject *argv[3];
23085 int ii;
23086
23087 argc = PyObject_Length(args);
23088 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23089 argv[ii] = PyTuple_GetItem(args,ii);
23090 }
23091 if (argc == 2) {
23092 int _v;
23093 {
23094 void *ptr;
23095 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23096 _v = 0;
23097 PyErr_Clear();
23098 } else {
23099 _v = 1;
23100 }
23101 }
23102 if (_v) {
23103 {
23104 void *ptr = 0;
23105 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23106 _v = 0;
23107 PyErr_Clear();
23108 } else {
23109 _v = (ptr != 0);
23110 }
23111 }
23112 if (_v) {
23113 return _wrap_DateTime___isub____SWIG_0(self,args);
23114 }
23115 }
23116 }
23117 if (argc == 2) {
23118 int _v;
23119 {
23120 void *ptr;
23121 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23122 _v = 0;
23123 PyErr_Clear();
23124 } else {
23125 _v = 1;
23126 }
23127 }
23128 if (_v) {
23129 {
23130 void *ptr = 0;
23131 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23132 _v = 0;
23133 PyErr_Clear();
23134 } else {
23135 _v = (ptr != 0);
23136 }
23137 }
23138 if (_v) {
23139 return _wrap_DateTime___isub____SWIG_1(self,args);
23140 }
23141 }
23142 }
23143
23144 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
23145 return NULL;
23146 }
23147
23148
23149 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
23150 PyObject *resultobj;
23151 wxDateTime *arg1 = (wxDateTime *) 0 ;
23152 wxTimeSpan *arg2 = 0 ;
23153 wxDateTime result;
23154 PyObject * obj0 = 0 ;
23155 PyObject * obj1 = 0 ;
23156
23157 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
23158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23159 if (SWIG_arg_fail(1)) SWIG_fail;
23160 {
23161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23162 if (SWIG_arg_fail(2)) SWIG_fail;
23163 if (arg2 == NULL) {
23164 SWIG_null_ref("wxTimeSpan");
23165 }
23166 if (SWIG_arg_fail(2)) SWIG_fail;
23167 }
23168 {
23169 PyThreadState* __tstate = wxPyBeginAllowThreads();
23170 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
23171
23172 wxPyEndAllowThreads(__tstate);
23173 if (PyErr_Occurred()) SWIG_fail;
23174 }
23175 {
23176 wxDateTime * resultptr;
23177 resultptr = new wxDateTime((wxDateTime &)(result));
23178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23179 }
23180 return resultobj;
23181 fail:
23182 return NULL;
23183 }
23184
23185
23186 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
23187 PyObject *resultobj;
23188 wxDateTime *arg1 = (wxDateTime *) 0 ;
23189 wxDateSpan *arg2 = 0 ;
23190 wxDateTime result;
23191 PyObject * obj0 = 0 ;
23192 PyObject * obj1 = 0 ;
23193
23194 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
23195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23196 if (SWIG_arg_fail(1)) SWIG_fail;
23197 {
23198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23199 if (SWIG_arg_fail(2)) SWIG_fail;
23200 if (arg2 == NULL) {
23201 SWIG_null_ref("wxDateSpan");
23202 }
23203 if (SWIG_arg_fail(2)) SWIG_fail;
23204 }
23205 {
23206 PyThreadState* __tstate = wxPyBeginAllowThreads();
23207 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
23208
23209 wxPyEndAllowThreads(__tstate);
23210 if (PyErr_Occurred()) SWIG_fail;
23211 }
23212 {
23213 wxDateTime * resultptr;
23214 resultptr = new wxDateTime((wxDateTime &)(result));
23215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23216 }
23217 return resultobj;
23218 fail:
23219 return NULL;
23220 }
23221
23222
23223 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
23224 int argc;
23225 PyObject *argv[3];
23226 int ii;
23227
23228 argc = PyObject_Length(args);
23229 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23230 argv[ii] = PyTuple_GetItem(args,ii);
23231 }
23232 if (argc == 2) {
23233 int _v;
23234 {
23235 void *ptr;
23236 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23237 _v = 0;
23238 PyErr_Clear();
23239 } else {
23240 _v = 1;
23241 }
23242 }
23243 if (_v) {
23244 {
23245 void *ptr = 0;
23246 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23247 _v = 0;
23248 PyErr_Clear();
23249 } else {
23250 _v = (ptr != 0);
23251 }
23252 }
23253 if (_v) {
23254 return _wrap_DateTime___add____SWIG_0(self,args);
23255 }
23256 }
23257 }
23258 if (argc == 2) {
23259 int _v;
23260 {
23261 void *ptr;
23262 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23263 _v = 0;
23264 PyErr_Clear();
23265 } else {
23266 _v = 1;
23267 }
23268 }
23269 if (_v) {
23270 {
23271 void *ptr = 0;
23272 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23273 _v = 0;
23274 PyErr_Clear();
23275 } else {
23276 _v = (ptr != 0);
23277 }
23278 }
23279 if (_v) {
23280 return _wrap_DateTime___add____SWIG_1(self,args);
23281 }
23282 }
23283 }
23284
23285 Py_INCREF(Py_NotImplemented);
23286 return Py_NotImplemented;
23287 }
23288
23289
23290 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23291 PyObject *resultobj;
23292 wxDateTime *arg1 = (wxDateTime *) 0 ;
23293 wxDateTime *arg2 = 0 ;
23294 wxTimeSpan result;
23295 PyObject * obj0 = 0 ;
23296 PyObject * obj1 = 0 ;
23297
23298 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23300 if (SWIG_arg_fail(1)) SWIG_fail;
23301 {
23302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23303 if (SWIG_arg_fail(2)) SWIG_fail;
23304 if (arg2 == NULL) {
23305 SWIG_null_ref("wxDateTime");
23306 }
23307 if (SWIG_arg_fail(2)) SWIG_fail;
23308 }
23309 {
23310 PyThreadState* __tstate = wxPyBeginAllowThreads();
23311 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23312
23313 wxPyEndAllowThreads(__tstate);
23314 if (PyErr_Occurred()) SWIG_fail;
23315 }
23316 {
23317 wxTimeSpan * resultptr;
23318 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23319 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23320 }
23321 return resultobj;
23322 fail:
23323 return NULL;
23324 }
23325
23326
23327 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23328 PyObject *resultobj;
23329 wxDateTime *arg1 = (wxDateTime *) 0 ;
23330 wxTimeSpan *arg2 = 0 ;
23331 wxDateTime result;
23332 PyObject * obj0 = 0 ;
23333 PyObject * obj1 = 0 ;
23334
23335 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23337 if (SWIG_arg_fail(1)) SWIG_fail;
23338 {
23339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23340 if (SWIG_arg_fail(2)) SWIG_fail;
23341 if (arg2 == NULL) {
23342 SWIG_null_ref("wxTimeSpan");
23343 }
23344 if (SWIG_arg_fail(2)) SWIG_fail;
23345 }
23346 {
23347 PyThreadState* __tstate = wxPyBeginAllowThreads();
23348 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23349
23350 wxPyEndAllowThreads(__tstate);
23351 if (PyErr_Occurred()) SWIG_fail;
23352 }
23353 {
23354 wxDateTime * resultptr;
23355 resultptr = new wxDateTime((wxDateTime &)(result));
23356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23357 }
23358 return resultobj;
23359 fail:
23360 return NULL;
23361 }
23362
23363
23364 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23365 PyObject *resultobj;
23366 wxDateTime *arg1 = (wxDateTime *) 0 ;
23367 wxDateSpan *arg2 = 0 ;
23368 wxDateTime result;
23369 PyObject * obj0 = 0 ;
23370 PyObject * obj1 = 0 ;
23371
23372 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23374 if (SWIG_arg_fail(1)) SWIG_fail;
23375 {
23376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23377 if (SWIG_arg_fail(2)) SWIG_fail;
23378 if (arg2 == NULL) {
23379 SWIG_null_ref("wxDateSpan");
23380 }
23381 if (SWIG_arg_fail(2)) SWIG_fail;
23382 }
23383 {
23384 PyThreadState* __tstate = wxPyBeginAllowThreads();
23385 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23386
23387 wxPyEndAllowThreads(__tstate);
23388 if (PyErr_Occurred()) SWIG_fail;
23389 }
23390 {
23391 wxDateTime * resultptr;
23392 resultptr = new wxDateTime((wxDateTime &)(result));
23393 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23394 }
23395 return resultobj;
23396 fail:
23397 return NULL;
23398 }
23399
23400
23401 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23402 int argc;
23403 PyObject *argv[3];
23404 int ii;
23405
23406 argc = PyObject_Length(args);
23407 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23408 argv[ii] = PyTuple_GetItem(args,ii);
23409 }
23410 if (argc == 2) {
23411 int _v;
23412 {
23413 void *ptr;
23414 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23415 _v = 0;
23416 PyErr_Clear();
23417 } else {
23418 _v = 1;
23419 }
23420 }
23421 if (_v) {
23422 {
23423 void *ptr = 0;
23424 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23425 _v = 0;
23426 PyErr_Clear();
23427 } else {
23428 _v = (ptr != 0);
23429 }
23430 }
23431 if (_v) {
23432 return _wrap_DateTime___sub____SWIG_0(self,args);
23433 }
23434 }
23435 }
23436 if (argc == 2) {
23437 int _v;
23438 {
23439 void *ptr;
23440 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23441 _v = 0;
23442 PyErr_Clear();
23443 } else {
23444 _v = 1;
23445 }
23446 }
23447 if (_v) {
23448 {
23449 void *ptr = 0;
23450 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23451 _v = 0;
23452 PyErr_Clear();
23453 } else {
23454 _v = (ptr != 0);
23455 }
23456 }
23457 if (_v) {
23458 return _wrap_DateTime___sub____SWIG_1(self,args);
23459 }
23460 }
23461 }
23462 if (argc == 2) {
23463 int _v;
23464 {
23465 void *ptr;
23466 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23467 _v = 0;
23468 PyErr_Clear();
23469 } else {
23470 _v = 1;
23471 }
23472 }
23473 if (_v) {
23474 {
23475 void *ptr = 0;
23476 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23477 _v = 0;
23478 PyErr_Clear();
23479 } else {
23480 _v = (ptr != 0);
23481 }
23482 }
23483 if (_v) {
23484 return _wrap_DateTime___sub____SWIG_2(self,args);
23485 }
23486 }
23487 }
23488
23489 Py_INCREF(Py_NotImplemented);
23490 return Py_NotImplemented;
23491 }
23492
23493
23494 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23495 PyObject *resultobj;
23496 wxDateTime *arg1 = (wxDateTime *) 0 ;
23497 wxDateTime *arg2 = (wxDateTime *) 0 ;
23498 bool result;
23499 PyObject * obj0 = 0 ;
23500 PyObject * obj1 = 0 ;
23501 char *kwnames[] = {
23502 (char *) "self",(char *) "other", NULL
23503 };
23504
23505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23507 if (SWIG_arg_fail(1)) SWIG_fail;
23508 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23509 if (SWIG_arg_fail(2)) SWIG_fail;
23510 {
23511 PyThreadState* __tstate = wxPyBeginAllowThreads();
23512 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23513
23514 wxPyEndAllowThreads(__tstate);
23515 if (PyErr_Occurred()) SWIG_fail;
23516 }
23517 {
23518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23519 }
23520 return resultobj;
23521 fail:
23522 return NULL;
23523 }
23524
23525
23526 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23527 PyObject *resultobj;
23528 wxDateTime *arg1 = (wxDateTime *) 0 ;
23529 wxDateTime *arg2 = (wxDateTime *) 0 ;
23530 bool result;
23531 PyObject * obj0 = 0 ;
23532 PyObject * obj1 = 0 ;
23533 char *kwnames[] = {
23534 (char *) "self",(char *) "other", NULL
23535 };
23536
23537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23539 if (SWIG_arg_fail(1)) SWIG_fail;
23540 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23541 if (SWIG_arg_fail(2)) SWIG_fail;
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23545
23546 wxPyEndAllowThreads(__tstate);
23547 if (PyErr_Occurred()) SWIG_fail;
23548 }
23549 {
23550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23551 }
23552 return resultobj;
23553 fail:
23554 return NULL;
23555 }
23556
23557
23558 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23559 PyObject *resultobj;
23560 wxDateTime *arg1 = (wxDateTime *) 0 ;
23561 wxDateTime *arg2 = (wxDateTime *) 0 ;
23562 bool result;
23563 PyObject * obj0 = 0 ;
23564 PyObject * obj1 = 0 ;
23565 char *kwnames[] = {
23566 (char *) "self",(char *) "other", NULL
23567 };
23568
23569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23571 if (SWIG_arg_fail(1)) SWIG_fail;
23572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23573 if (SWIG_arg_fail(2)) SWIG_fail;
23574 {
23575 PyThreadState* __tstate = wxPyBeginAllowThreads();
23576 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23577
23578 wxPyEndAllowThreads(__tstate);
23579 if (PyErr_Occurred()) SWIG_fail;
23580 }
23581 {
23582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23583 }
23584 return resultobj;
23585 fail:
23586 return NULL;
23587 }
23588
23589
23590 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23591 PyObject *resultobj;
23592 wxDateTime *arg1 = (wxDateTime *) 0 ;
23593 wxDateTime *arg2 = (wxDateTime *) 0 ;
23594 bool result;
23595 PyObject * obj0 = 0 ;
23596 PyObject * obj1 = 0 ;
23597 char *kwnames[] = {
23598 (char *) "self",(char *) "other", NULL
23599 };
23600
23601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23603 if (SWIG_arg_fail(1)) SWIG_fail;
23604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23605 if (SWIG_arg_fail(2)) SWIG_fail;
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23609
23610 wxPyEndAllowThreads(__tstate);
23611 if (PyErr_Occurred()) SWIG_fail;
23612 }
23613 {
23614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23615 }
23616 return resultobj;
23617 fail:
23618 return NULL;
23619 }
23620
23621
23622 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23623 PyObject *resultobj;
23624 wxDateTime *arg1 = (wxDateTime *) 0 ;
23625 wxDateTime *arg2 = (wxDateTime *) 0 ;
23626 bool result;
23627 PyObject * obj0 = 0 ;
23628 PyObject * obj1 = 0 ;
23629 char *kwnames[] = {
23630 (char *) "self",(char *) "other", NULL
23631 };
23632
23633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23635 if (SWIG_arg_fail(1)) SWIG_fail;
23636 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23637 if (SWIG_arg_fail(2)) SWIG_fail;
23638 {
23639 PyThreadState* __tstate = wxPyBeginAllowThreads();
23640 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23641
23642 wxPyEndAllowThreads(__tstate);
23643 if (PyErr_Occurred()) SWIG_fail;
23644 }
23645 {
23646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23647 }
23648 return resultobj;
23649 fail:
23650 return NULL;
23651 }
23652
23653
23654 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23655 PyObject *resultobj;
23656 wxDateTime *arg1 = (wxDateTime *) 0 ;
23657 wxDateTime *arg2 = (wxDateTime *) 0 ;
23658 bool result;
23659 PyObject * obj0 = 0 ;
23660 PyObject * obj1 = 0 ;
23661 char *kwnames[] = {
23662 (char *) "self",(char *) "other", NULL
23663 };
23664
23665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23667 if (SWIG_arg_fail(1)) SWIG_fail;
23668 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23669 if (SWIG_arg_fail(2)) SWIG_fail;
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23673
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 {
23678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj;
23688 wxDateTime *arg1 = (wxDateTime *) 0 ;
23689 wxString *arg2 = 0 ;
23690 int result;
23691 bool temp2 = false ;
23692 PyObject * obj0 = 0 ;
23693 PyObject * obj1 = 0 ;
23694 char *kwnames[] = {
23695 (char *) "self",(char *) "date", NULL
23696 };
23697
23698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23700 if (SWIG_arg_fail(1)) SWIG_fail;
23701 {
23702 arg2 = wxString_in_helper(obj1);
23703 if (arg2 == NULL) SWIG_fail;
23704 temp2 = true;
23705 }
23706 {
23707 PyThreadState* __tstate = wxPyBeginAllowThreads();
23708 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23709
23710 wxPyEndAllowThreads(__tstate);
23711 if (PyErr_Occurred()) SWIG_fail;
23712 }
23713 {
23714 resultobj = SWIG_From_int((int)(result));
23715 }
23716 {
23717 if (temp2)
23718 delete arg2;
23719 }
23720 return resultobj;
23721 fail:
23722 {
23723 if (temp2)
23724 delete arg2;
23725 }
23726 return NULL;
23727 }
23728
23729
23730 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23731 PyObject *resultobj;
23732 wxDateTime *arg1 = (wxDateTime *) 0 ;
23733 wxString *arg2 = 0 ;
23734 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23735 wxString *arg3 = (wxString *) &arg3_defvalue ;
23736 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23737 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23738 int result;
23739 bool temp2 = false ;
23740 bool temp3 = false ;
23741 PyObject * obj0 = 0 ;
23742 PyObject * obj1 = 0 ;
23743 PyObject * obj2 = 0 ;
23744 PyObject * obj3 = 0 ;
23745 char *kwnames[] = {
23746 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23747 };
23748
23749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23751 if (SWIG_arg_fail(1)) SWIG_fail;
23752 {
23753 arg2 = wxString_in_helper(obj1);
23754 if (arg2 == NULL) SWIG_fail;
23755 temp2 = true;
23756 }
23757 if (obj2) {
23758 {
23759 arg3 = wxString_in_helper(obj2);
23760 if (arg3 == NULL) SWIG_fail;
23761 temp3 = true;
23762 }
23763 }
23764 if (obj3) {
23765 {
23766 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23767 if (SWIG_arg_fail(4)) SWIG_fail;
23768 if (arg4 == NULL) {
23769 SWIG_null_ref("wxDateTime");
23770 }
23771 if (SWIG_arg_fail(4)) SWIG_fail;
23772 }
23773 }
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23777
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 {
23782 resultobj = SWIG_From_int((int)(result));
23783 }
23784 {
23785 if (temp2)
23786 delete arg2;
23787 }
23788 {
23789 if (temp3)
23790 delete arg3;
23791 }
23792 return resultobj;
23793 fail:
23794 {
23795 if (temp2)
23796 delete arg2;
23797 }
23798 {
23799 if (temp3)
23800 delete arg3;
23801 }
23802 return NULL;
23803 }
23804
23805
23806 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23807 PyObject *resultobj;
23808 wxDateTime *arg1 = (wxDateTime *) 0 ;
23809 wxString *arg2 = 0 ;
23810 int result;
23811 bool temp2 = false ;
23812 PyObject * obj0 = 0 ;
23813 PyObject * obj1 = 0 ;
23814 char *kwnames[] = {
23815 (char *) "self",(char *) "datetime", NULL
23816 };
23817
23818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23820 if (SWIG_arg_fail(1)) SWIG_fail;
23821 {
23822 arg2 = wxString_in_helper(obj1);
23823 if (arg2 == NULL) SWIG_fail;
23824 temp2 = true;
23825 }
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23829
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 {
23834 resultobj = SWIG_From_int((int)(result));
23835 }
23836 {
23837 if (temp2)
23838 delete arg2;
23839 }
23840 return resultobj;
23841 fail:
23842 {
23843 if (temp2)
23844 delete arg2;
23845 }
23846 return NULL;
23847 }
23848
23849
23850 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23851 PyObject *resultobj;
23852 wxDateTime *arg1 = (wxDateTime *) 0 ;
23853 wxString *arg2 = 0 ;
23854 int result;
23855 bool temp2 = false ;
23856 PyObject * obj0 = 0 ;
23857 PyObject * obj1 = 0 ;
23858 char *kwnames[] = {
23859 (char *) "self",(char *) "date", NULL
23860 };
23861
23862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23864 if (SWIG_arg_fail(1)) SWIG_fail;
23865 {
23866 arg2 = wxString_in_helper(obj1);
23867 if (arg2 == NULL) SWIG_fail;
23868 temp2 = true;
23869 }
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23873
23874 wxPyEndAllowThreads(__tstate);
23875 if (PyErr_Occurred()) SWIG_fail;
23876 }
23877 {
23878 resultobj = SWIG_From_int((int)(result));
23879 }
23880 {
23881 if (temp2)
23882 delete arg2;
23883 }
23884 return resultobj;
23885 fail:
23886 {
23887 if (temp2)
23888 delete arg2;
23889 }
23890 return NULL;
23891 }
23892
23893
23894 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj;
23896 wxDateTime *arg1 = (wxDateTime *) 0 ;
23897 wxString *arg2 = 0 ;
23898 int result;
23899 bool temp2 = false ;
23900 PyObject * obj0 = 0 ;
23901 PyObject * obj1 = 0 ;
23902 char *kwnames[] = {
23903 (char *) "self",(char *) "time", NULL
23904 };
23905
23906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23908 if (SWIG_arg_fail(1)) SWIG_fail;
23909 {
23910 arg2 = wxString_in_helper(obj1);
23911 if (arg2 == NULL) SWIG_fail;
23912 temp2 = true;
23913 }
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23917
23918 wxPyEndAllowThreads(__tstate);
23919 if (PyErr_Occurred()) SWIG_fail;
23920 }
23921 {
23922 resultobj = SWIG_From_int((int)(result));
23923 }
23924 {
23925 if (temp2)
23926 delete arg2;
23927 }
23928 return resultobj;
23929 fail:
23930 {
23931 if (temp2)
23932 delete arg2;
23933 }
23934 return NULL;
23935 }
23936
23937
23938 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23939 PyObject *resultobj;
23940 wxDateTime *arg1 = (wxDateTime *) 0 ;
23941 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23942 wxString *arg2 = (wxString *) &arg2_defvalue ;
23943 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23944 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23945 wxString result;
23946 bool temp2 = false ;
23947 bool temp3 = false ;
23948 PyObject * obj0 = 0 ;
23949 PyObject * obj1 = 0 ;
23950 PyObject * obj2 = 0 ;
23951 char *kwnames[] = {
23952 (char *) "self",(char *) "format",(char *) "tz", NULL
23953 };
23954
23955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23957 if (SWIG_arg_fail(1)) SWIG_fail;
23958 if (obj1) {
23959 {
23960 arg2 = wxString_in_helper(obj1);
23961 if (arg2 == NULL) SWIG_fail;
23962 temp2 = true;
23963 }
23964 }
23965 if (obj2) {
23966 {
23967 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23968 temp3 = true;
23969 }
23970 }
23971 {
23972 PyThreadState* __tstate = wxPyBeginAllowThreads();
23973 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23974
23975 wxPyEndAllowThreads(__tstate);
23976 if (PyErr_Occurred()) SWIG_fail;
23977 }
23978 {
23979 #if wxUSE_UNICODE
23980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23981 #else
23982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23983 #endif
23984 }
23985 {
23986 if (temp2)
23987 delete arg2;
23988 }
23989 {
23990 if (temp3) delete arg3;
23991 }
23992 return resultobj;
23993 fail:
23994 {
23995 if (temp2)
23996 delete arg2;
23997 }
23998 {
23999 if (temp3) delete arg3;
24000 }
24001 return NULL;
24002 }
24003
24004
24005 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
24006 PyObject *resultobj;
24007 wxDateTime *arg1 = (wxDateTime *) 0 ;
24008 wxString result;
24009 PyObject * obj0 = 0 ;
24010 char *kwnames[] = {
24011 (char *) "self", NULL
24012 };
24013
24014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
24015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24016 if (SWIG_arg_fail(1)) SWIG_fail;
24017 {
24018 PyThreadState* __tstate = wxPyBeginAllowThreads();
24019 result = ((wxDateTime const *)arg1)->FormatDate();
24020
24021 wxPyEndAllowThreads(__tstate);
24022 if (PyErr_Occurred()) SWIG_fail;
24023 }
24024 {
24025 #if wxUSE_UNICODE
24026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24027 #else
24028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24029 #endif
24030 }
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
24038 PyObject *resultobj;
24039 wxDateTime *arg1 = (wxDateTime *) 0 ;
24040 wxString result;
24041 PyObject * obj0 = 0 ;
24042 char *kwnames[] = {
24043 (char *) "self", NULL
24044 };
24045
24046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
24047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24048 if (SWIG_arg_fail(1)) SWIG_fail;
24049 {
24050 PyThreadState* __tstate = wxPyBeginAllowThreads();
24051 result = ((wxDateTime const *)arg1)->FormatTime();
24052
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 {
24057 #if wxUSE_UNICODE
24058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24059 #else
24060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24061 #endif
24062 }
24063 return resultobj;
24064 fail:
24065 return NULL;
24066 }
24067
24068
24069 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
24070 PyObject *resultobj;
24071 wxDateTime *arg1 = (wxDateTime *) 0 ;
24072 wxString result;
24073 PyObject * obj0 = 0 ;
24074 char *kwnames[] = {
24075 (char *) "self", NULL
24076 };
24077
24078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
24079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24080 if (SWIG_arg_fail(1)) SWIG_fail;
24081 {
24082 PyThreadState* __tstate = wxPyBeginAllowThreads();
24083 result = ((wxDateTime const *)arg1)->FormatISODate();
24084
24085 wxPyEndAllowThreads(__tstate);
24086 if (PyErr_Occurred()) SWIG_fail;
24087 }
24088 {
24089 #if wxUSE_UNICODE
24090 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24091 #else
24092 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24093 #endif
24094 }
24095 return resultobj;
24096 fail:
24097 return NULL;
24098 }
24099
24100
24101 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
24102 PyObject *resultobj;
24103 wxDateTime *arg1 = (wxDateTime *) 0 ;
24104 wxString result;
24105 PyObject * obj0 = 0 ;
24106 char *kwnames[] = {
24107 (char *) "self", NULL
24108 };
24109
24110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
24111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24112 if (SWIG_arg_fail(1)) SWIG_fail;
24113 {
24114 PyThreadState* __tstate = wxPyBeginAllowThreads();
24115 result = ((wxDateTime const *)arg1)->FormatISOTime();
24116
24117 wxPyEndAllowThreads(__tstate);
24118 if (PyErr_Occurred()) SWIG_fail;
24119 }
24120 {
24121 #if wxUSE_UNICODE
24122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24123 #else
24124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24125 #endif
24126 }
24127 return resultobj;
24128 fail:
24129 return NULL;
24130 }
24131
24132
24133 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
24134 PyObject *obj;
24135 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24136 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
24137 Py_INCREF(obj);
24138 return Py_BuildValue((char *)"");
24139 }
24140 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 long arg1 ;
24143 wxTimeSpan result;
24144 PyObject * obj0 = 0 ;
24145 char *kwnames[] = {
24146 (char *) "sec", NULL
24147 };
24148
24149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
24150 {
24151 arg1 = (long)(SWIG_As_long(obj0));
24152 if (SWIG_arg_fail(1)) SWIG_fail;
24153 }
24154 {
24155 PyThreadState* __tstate = wxPyBeginAllowThreads();
24156 result = wxTimeSpan::Seconds(arg1);
24157
24158 wxPyEndAllowThreads(__tstate);
24159 if (PyErr_Occurred()) SWIG_fail;
24160 }
24161 {
24162 wxTimeSpan * resultptr;
24163 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24165 }
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
24173 PyObject *resultobj;
24174 wxTimeSpan result;
24175 char *kwnames[] = {
24176 NULL
24177 };
24178
24179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
24180 {
24181 PyThreadState* __tstate = wxPyBeginAllowThreads();
24182 result = wxTimeSpan::Second();
24183
24184 wxPyEndAllowThreads(__tstate);
24185 if (PyErr_Occurred()) SWIG_fail;
24186 }
24187 {
24188 wxTimeSpan * resultptr;
24189 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24190 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24191 }
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
24199 PyObject *resultobj;
24200 long arg1 ;
24201 wxTimeSpan result;
24202 PyObject * obj0 = 0 ;
24203 char *kwnames[] = {
24204 (char *) "min", NULL
24205 };
24206
24207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
24208 {
24209 arg1 = (long)(SWIG_As_long(obj0));
24210 if (SWIG_arg_fail(1)) SWIG_fail;
24211 }
24212 {
24213 PyThreadState* __tstate = wxPyBeginAllowThreads();
24214 result = wxTimeSpan::Minutes(arg1);
24215
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 {
24220 wxTimeSpan * resultptr;
24221 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24223 }
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
24231 PyObject *resultobj;
24232 wxTimeSpan result;
24233 char *kwnames[] = {
24234 NULL
24235 };
24236
24237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
24238 {
24239 PyThreadState* __tstate = wxPyBeginAllowThreads();
24240 result = wxTimeSpan::Minute();
24241
24242 wxPyEndAllowThreads(__tstate);
24243 if (PyErr_Occurred()) SWIG_fail;
24244 }
24245 {
24246 wxTimeSpan * resultptr;
24247 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24249 }
24250 return resultobj;
24251 fail:
24252 return NULL;
24253 }
24254
24255
24256 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24257 PyObject *resultobj;
24258 long arg1 ;
24259 wxTimeSpan result;
24260 PyObject * obj0 = 0 ;
24261 char *kwnames[] = {
24262 (char *) "hours", NULL
24263 };
24264
24265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24266 {
24267 arg1 = (long)(SWIG_As_long(obj0));
24268 if (SWIG_arg_fail(1)) SWIG_fail;
24269 }
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 result = wxTimeSpan::Hours(arg1);
24273
24274 wxPyEndAllowThreads(__tstate);
24275 if (PyErr_Occurred()) SWIG_fail;
24276 }
24277 {
24278 wxTimeSpan * resultptr;
24279 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24281 }
24282 return resultobj;
24283 fail:
24284 return NULL;
24285 }
24286
24287
24288 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24289 PyObject *resultobj;
24290 wxTimeSpan result;
24291 char *kwnames[] = {
24292 NULL
24293 };
24294
24295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = wxTimeSpan::Hour();
24299
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 {
24304 wxTimeSpan * resultptr;
24305 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24307 }
24308 return resultobj;
24309 fail:
24310 return NULL;
24311 }
24312
24313
24314 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24315 PyObject *resultobj;
24316 long arg1 ;
24317 wxTimeSpan result;
24318 PyObject * obj0 = 0 ;
24319 char *kwnames[] = {
24320 (char *) "days", NULL
24321 };
24322
24323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24324 {
24325 arg1 = (long)(SWIG_As_long(obj0));
24326 if (SWIG_arg_fail(1)) SWIG_fail;
24327 }
24328 {
24329 PyThreadState* __tstate = wxPyBeginAllowThreads();
24330 result = wxTimeSpan::Days(arg1);
24331
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 {
24336 wxTimeSpan * resultptr;
24337 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24338 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24339 }
24340 return resultobj;
24341 fail:
24342 return NULL;
24343 }
24344
24345
24346 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24347 PyObject *resultobj;
24348 wxTimeSpan result;
24349 char *kwnames[] = {
24350 NULL
24351 };
24352
24353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 result = wxTimeSpan::Day();
24357
24358 wxPyEndAllowThreads(__tstate);
24359 if (PyErr_Occurred()) SWIG_fail;
24360 }
24361 {
24362 wxTimeSpan * resultptr;
24363 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24365 }
24366 return resultobj;
24367 fail:
24368 return NULL;
24369 }
24370
24371
24372 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24373 PyObject *resultobj;
24374 long arg1 ;
24375 wxTimeSpan result;
24376 PyObject * obj0 = 0 ;
24377 char *kwnames[] = {
24378 (char *) "days", NULL
24379 };
24380
24381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24382 {
24383 arg1 = (long)(SWIG_As_long(obj0));
24384 if (SWIG_arg_fail(1)) SWIG_fail;
24385 }
24386 {
24387 PyThreadState* __tstate = wxPyBeginAllowThreads();
24388 result = wxTimeSpan::Weeks(arg1);
24389
24390 wxPyEndAllowThreads(__tstate);
24391 if (PyErr_Occurred()) SWIG_fail;
24392 }
24393 {
24394 wxTimeSpan * resultptr;
24395 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24396 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24397 }
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24405 PyObject *resultobj;
24406 wxTimeSpan result;
24407 char *kwnames[] = {
24408 NULL
24409 };
24410
24411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24412 {
24413 PyThreadState* __tstate = wxPyBeginAllowThreads();
24414 result = wxTimeSpan::Week();
24415
24416 wxPyEndAllowThreads(__tstate);
24417 if (PyErr_Occurred()) SWIG_fail;
24418 }
24419 {
24420 wxTimeSpan * resultptr;
24421 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24423 }
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj;
24432 long arg1 = (long) 0 ;
24433 long arg2 = (long) 0 ;
24434 long arg3 = (long) 0 ;
24435 long arg4 = (long) 0 ;
24436 wxTimeSpan *result;
24437 PyObject * obj0 = 0 ;
24438 PyObject * obj1 = 0 ;
24439 PyObject * obj2 = 0 ;
24440 PyObject * obj3 = 0 ;
24441 char *kwnames[] = {
24442 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24443 };
24444
24445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24446 if (obj0) {
24447 {
24448 arg1 = (long)(SWIG_As_long(obj0));
24449 if (SWIG_arg_fail(1)) SWIG_fail;
24450 }
24451 }
24452 if (obj1) {
24453 {
24454 arg2 = (long)(SWIG_As_long(obj1));
24455 if (SWIG_arg_fail(2)) SWIG_fail;
24456 }
24457 }
24458 if (obj2) {
24459 {
24460 arg3 = (long)(SWIG_As_long(obj2));
24461 if (SWIG_arg_fail(3)) SWIG_fail;
24462 }
24463 }
24464 if (obj3) {
24465 {
24466 arg4 = (long)(SWIG_As_long(obj3));
24467 if (SWIG_arg_fail(4)) SWIG_fail;
24468 }
24469 }
24470 {
24471 PyThreadState* __tstate = wxPyBeginAllowThreads();
24472 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24473
24474 wxPyEndAllowThreads(__tstate);
24475 if (PyErr_Occurred()) SWIG_fail;
24476 }
24477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24478 return resultobj;
24479 fail:
24480 return NULL;
24481 }
24482
24483
24484 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24485 PyObject *resultobj;
24486 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24487 PyObject * obj0 = 0 ;
24488 char *kwnames[] = {
24489 (char *) "self", NULL
24490 };
24491
24492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24494 if (SWIG_arg_fail(1)) SWIG_fail;
24495 {
24496 PyThreadState* __tstate = wxPyBeginAllowThreads();
24497 delete arg1;
24498
24499 wxPyEndAllowThreads(__tstate);
24500 if (PyErr_Occurred()) SWIG_fail;
24501 }
24502 Py_INCREF(Py_None); resultobj = Py_None;
24503 return resultobj;
24504 fail:
24505 return NULL;
24506 }
24507
24508
24509 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24510 PyObject *resultobj;
24511 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24512 wxTimeSpan *arg2 = 0 ;
24513 wxTimeSpan *result;
24514 PyObject * obj0 = 0 ;
24515 PyObject * obj1 = 0 ;
24516 char *kwnames[] = {
24517 (char *) "self",(char *) "diff", NULL
24518 };
24519
24520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24522 if (SWIG_arg_fail(1)) SWIG_fail;
24523 {
24524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24525 if (SWIG_arg_fail(2)) SWIG_fail;
24526 if (arg2 == NULL) {
24527 SWIG_null_ref("wxTimeSpan");
24528 }
24529 if (SWIG_arg_fail(2)) SWIG_fail;
24530 }
24531 {
24532 PyThreadState* __tstate = wxPyBeginAllowThreads();
24533 {
24534 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24535 result = (wxTimeSpan *) &_result_ref;
24536 }
24537
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj;
24550 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24551 wxTimeSpan *arg2 = 0 ;
24552 wxTimeSpan *result;
24553 PyObject * obj0 = 0 ;
24554 PyObject * obj1 = 0 ;
24555 char *kwnames[] = {
24556 (char *) "self",(char *) "diff", NULL
24557 };
24558
24559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24561 if (SWIG_arg_fail(1)) SWIG_fail;
24562 {
24563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24564 if (SWIG_arg_fail(2)) SWIG_fail;
24565 if (arg2 == NULL) {
24566 SWIG_null_ref("wxTimeSpan");
24567 }
24568 if (SWIG_arg_fail(2)) SWIG_fail;
24569 }
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 {
24573 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24574 result = (wxTimeSpan *) &_result_ref;
24575 }
24576
24577 wxPyEndAllowThreads(__tstate);
24578 if (PyErr_Occurred()) SWIG_fail;
24579 }
24580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj;
24589 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24590 int arg2 ;
24591 wxTimeSpan *result;
24592 PyObject * obj0 = 0 ;
24593 PyObject * obj1 = 0 ;
24594 char *kwnames[] = {
24595 (char *) "self",(char *) "n", NULL
24596 };
24597
24598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",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 {
24602 arg2 = (int)(SWIG_As_int(obj1));
24603 if (SWIG_arg_fail(2)) SWIG_fail;
24604 }
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 {
24608 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24609 result = (wxTimeSpan *) &_result_ref;
24610 }
24611
24612 wxPyEndAllowThreads(__tstate);
24613 if (PyErr_Occurred()) SWIG_fail;
24614 }
24615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24616 return resultobj;
24617 fail:
24618 return NULL;
24619 }
24620
24621
24622 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24623 PyObject *resultobj;
24624 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24625 wxTimeSpan *result;
24626 PyObject * obj0 = 0 ;
24627 char *kwnames[] = {
24628 (char *) "self", NULL
24629 };
24630
24631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24633 if (SWIG_arg_fail(1)) SWIG_fail;
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 {
24637 wxTimeSpan &_result_ref = (arg1)->Neg();
24638 result = (wxTimeSpan *) &_result_ref;
24639 }
24640
24641 wxPyEndAllowThreads(__tstate);
24642 if (PyErr_Occurred()) SWIG_fail;
24643 }
24644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24645 return resultobj;
24646 fail:
24647 return NULL;
24648 }
24649
24650
24651 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24652 PyObject *resultobj;
24653 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24654 wxTimeSpan result;
24655 PyObject * obj0 = 0 ;
24656 char *kwnames[] = {
24657 (char *) "self", NULL
24658 };
24659
24660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24662 if (SWIG_arg_fail(1)) SWIG_fail;
24663 {
24664 PyThreadState* __tstate = wxPyBeginAllowThreads();
24665 result = ((wxTimeSpan const *)arg1)->Abs();
24666
24667 wxPyEndAllowThreads(__tstate);
24668 if (PyErr_Occurred()) SWIG_fail;
24669 }
24670 {
24671 wxTimeSpan * resultptr;
24672 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24673 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24674 }
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24682 PyObject *resultobj;
24683 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24684 wxTimeSpan *arg2 = 0 ;
24685 wxTimeSpan *result;
24686 PyObject * obj0 = 0 ;
24687 PyObject * obj1 = 0 ;
24688 char *kwnames[] = {
24689 (char *) "self",(char *) "diff", NULL
24690 };
24691
24692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24694 if (SWIG_arg_fail(1)) SWIG_fail;
24695 {
24696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24697 if (SWIG_arg_fail(2)) SWIG_fail;
24698 if (arg2 == NULL) {
24699 SWIG_null_ref("wxTimeSpan");
24700 }
24701 if (SWIG_arg_fail(2)) SWIG_fail;
24702 }
24703 {
24704 PyThreadState* __tstate = wxPyBeginAllowThreads();
24705 {
24706 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24707 result = (wxTimeSpan *) &_result_ref;
24708 }
24709
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24721 PyObject *resultobj;
24722 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24723 wxTimeSpan *arg2 = 0 ;
24724 wxTimeSpan *result;
24725 PyObject * obj0 = 0 ;
24726 PyObject * obj1 = 0 ;
24727 char *kwnames[] = {
24728 (char *) "self",(char *) "diff", NULL
24729 };
24730
24731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24733 if (SWIG_arg_fail(1)) SWIG_fail;
24734 {
24735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24736 if (SWIG_arg_fail(2)) SWIG_fail;
24737 if (arg2 == NULL) {
24738 SWIG_null_ref("wxTimeSpan");
24739 }
24740 if (SWIG_arg_fail(2)) SWIG_fail;
24741 }
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 {
24745 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24746 result = (wxTimeSpan *) &_result_ref;
24747 }
24748
24749 wxPyEndAllowThreads(__tstate);
24750 if (PyErr_Occurred()) SWIG_fail;
24751 }
24752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24753 return resultobj;
24754 fail:
24755 return NULL;
24756 }
24757
24758
24759 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24760 PyObject *resultobj;
24761 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24762 int arg2 ;
24763 wxTimeSpan *result;
24764 PyObject * obj0 = 0 ;
24765 PyObject * obj1 = 0 ;
24766 char *kwnames[] = {
24767 (char *) "self",(char *) "n", NULL
24768 };
24769
24770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24772 if (SWIG_arg_fail(1)) SWIG_fail;
24773 {
24774 arg2 = (int)(SWIG_As_int(obj1));
24775 if (SWIG_arg_fail(2)) SWIG_fail;
24776 }
24777 {
24778 PyThreadState* __tstate = wxPyBeginAllowThreads();
24779 {
24780 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24781 result = (wxTimeSpan *) &_result_ref;
24782 }
24783
24784 wxPyEndAllowThreads(__tstate);
24785 if (PyErr_Occurred()) SWIG_fail;
24786 }
24787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24788 return resultobj;
24789 fail:
24790 return NULL;
24791 }
24792
24793
24794 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj;
24796 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24797 wxTimeSpan *result;
24798 PyObject * obj0 = 0 ;
24799 char *kwnames[] = {
24800 (char *) "self", NULL
24801 };
24802
24803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24805 if (SWIG_arg_fail(1)) SWIG_fail;
24806 {
24807 PyThreadState* __tstate = wxPyBeginAllowThreads();
24808 {
24809 wxTimeSpan &_result_ref = (arg1)->operator -();
24810 result = (wxTimeSpan *) &_result_ref;
24811 }
24812
24813 wxPyEndAllowThreads(__tstate);
24814 if (PyErr_Occurred()) SWIG_fail;
24815 }
24816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24817 return resultobj;
24818 fail:
24819 return NULL;
24820 }
24821
24822
24823 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24824 PyObject *resultobj;
24825 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24826 wxTimeSpan *arg2 = 0 ;
24827 wxTimeSpan result;
24828 PyObject * obj0 = 0 ;
24829 PyObject * obj1 = 0 ;
24830 char *kwnames[] = {
24831 (char *) "self",(char *) "other", NULL
24832 };
24833
24834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24836 if (SWIG_arg_fail(1)) SWIG_fail;
24837 {
24838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24839 if (SWIG_arg_fail(2)) SWIG_fail;
24840 if (arg2 == NULL) {
24841 SWIG_null_ref("wxTimeSpan");
24842 }
24843 if (SWIG_arg_fail(2)) SWIG_fail;
24844 }
24845 {
24846 PyThreadState* __tstate = wxPyBeginAllowThreads();
24847 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24848
24849 wxPyEndAllowThreads(__tstate);
24850 if (PyErr_Occurred()) SWIG_fail;
24851 }
24852 {
24853 wxTimeSpan * resultptr;
24854 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24856 }
24857 return resultobj;
24858 fail:
24859 return NULL;
24860 }
24861
24862
24863 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24864 PyObject *resultobj;
24865 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24866 wxTimeSpan *arg2 = 0 ;
24867 wxTimeSpan result;
24868 PyObject * obj0 = 0 ;
24869 PyObject * obj1 = 0 ;
24870 char *kwnames[] = {
24871 (char *) "self",(char *) "other", NULL
24872 };
24873
24874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24876 if (SWIG_arg_fail(1)) SWIG_fail;
24877 {
24878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24879 if (SWIG_arg_fail(2)) SWIG_fail;
24880 if (arg2 == NULL) {
24881 SWIG_null_ref("wxTimeSpan");
24882 }
24883 if (SWIG_arg_fail(2)) SWIG_fail;
24884 }
24885 {
24886 PyThreadState* __tstate = wxPyBeginAllowThreads();
24887 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24888
24889 wxPyEndAllowThreads(__tstate);
24890 if (PyErr_Occurred()) SWIG_fail;
24891 }
24892 {
24893 wxTimeSpan * resultptr;
24894 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24895 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24896 }
24897 return resultobj;
24898 fail:
24899 return NULL;
24900 }
24901
24902
24903 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24904 PyObject *resultobj;
24905 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24906 int arg2 ;
24907 wxTimeSpan result;
24908 PyObject * obj0 = 0 ;
24909 PyObject * obj1 = 0 ;
24910 char *kwnames[] = {
24911 (char *) "self",(char *) "n", NULL
24912 };
24913
24914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24916 if (SWIG_arg_fail(1)) SWIG_fail;
24917 {
24918 arg2 = (int)(SWIG_As_int(obj1));
24919 if (SWIG_arg_fail(2)) SWIG_fail;
24920 }
24921 {
24922 PyThreadState* __tstate = wxPyBeginAllowThreads();
24923 result = wxTimeSpan___mul__(arg1,arg2);
24924
24925 wxPyEndAllowThreads(__tstate);
24926 if (PyErr_Occurred()) SWIG_fail;
24927 }
24928 {
24929 wxTimeSpan * resultptr;
24930 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24932 }
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24940 PyObject *resultobj;
24941 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24942 int arg2 ;
24943 wxTimeSpan result;
24944 PyObject * obj0 = 0 ;
24945 PyObject * obj1 = 0 ;
24946 char *kwnames[] = {
24947 (char *) "self",(char *) "n", NULL
24948 };
24949
24950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24952 if (SWIG_arg_fail(1)) SWIG_fail;
24953 {
24954 arg2 = (int)(SWIG_As_int(obj1));
24955 if (SWIG_arg_fail(2)) SWIG_fail;
24956 }
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 result = wxTimeSpan___rmul__(arg1,arg2);
24960
24961 wxPyEndAllowThreads(__tstate);
24962 if (PyErr_Occurred()) SWIG_fail;
24963 }
24964 {
24965 wxTimeSpan * resultptr;
24966 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24967 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24968 }
24969 return resultobj;
24970 fail:
24971 return NULL;
24972 }
24973
24974
24975 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24976 PyObject *resultobj;
24977 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24978 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24979 bool result;
24980 PyObject * obj0 = 0 ;
24981 PyObject * obj1 = 0 ;
24982 char *kwnames[] = {
24983 (char *) "self",(char *) "other", NULL
24984 };
24985
24986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24988 if (SWIG_arg_fail(1)) SWIG_fail;
24989 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24990 if (SWIG_arg_fail(2)) SWIG_fail;
24991 {
24992 PyThreadState* __tstate = wxPyBeginAllowThreads();
24993 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24994
24995 wxPyEndAllowThreads(__tstate);
24996 if (PyErr_Occurred()) SWIG_fail;
24997 }
24998 {
24999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25000 }
25001 return resultobj;
25002 fail:
25003 return NULL;
25004 }
25005
25006
25007 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
25008 PyObject *resultobj;
25009 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25010 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25011 bool result;
25012 PyObject * obj0 = 0 ;
25013 PyObject * obj1 = 0 ;
25014 char *kwnames[] = {
25015 (char *) "self",(char *) "other", NULL
25016 };
25017
25018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
25019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25020 if (SWIG_arg_fail(1)) SWIG_fail;
25021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25022 if (SWIG_arg_fail(2)) SWIG_fail;
25023 {
25024 PyThreadState* __tstate = wxPyBeginAllowThreads();
25025 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
25026
25027 wxPyEndAllowThreads(__tstate);
25028 if (PyErr_Occurred()) SWIG_fail;
25029 }
25030 {
25031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25032 }
25033 return resultobj;
25034 fail:
25035 return NULL;
25036 }
25037
25038
25039 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
25040 PyObject *resultobj;
25041 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25042 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25043 bool result;
25044 PyObject * obj0 = 0 ;
25045 PyObject * obj1 = 0 ;
25046 char *kwnames[] = {
25047 (char *) "self",(char *) "other", NULL
25048 };
25049
25050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
25051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25052 if (SWIG_arg_fail(1)) SWIG_fail;
25053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25054 if (SWIG_arg_fail(2)) SWIG_fail;
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
25058
25059 wxPyEndAllowThreads(__tstate);
25060 if (PyErr_Occurred()) SWIG_fail;
25061 }
25062 {
25063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25064 }
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
25072 PyObject *resultobj;
25073 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25074 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25075 bool result;
25076 PyObject * obj0 = 0 ;
25077 PyObject * obj1 = 0 ;
25078 char *kwnames[] = {
25079 (char *) "self",(char *) "other", NULL
25080 };
25081
25082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
25083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25084 if (SWIG_arg_fail(1)) SWIG_fail;
25085 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25086 if (SWIG_arg_fail(2)) SWIG_fail;
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 {
25095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25096 }
25097 return resultobj;
25098 fail:
25099 return NULL;
25100 }
25101
25102
25103 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
25104 PyObject *resultobj;
25105 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25106 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25107 bool result;
25108 PyObject * obj0 = 0 ;
25109 PyObject * obj1 = 0 ;
25110 char *kwnames[] = {
25111 (char *) "self",(char *) "other", NULL
25112 };
25113
25114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
25115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25116 if (SWIG_arg_fail(1)) SWIG_fail;
25117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25118 if (SWIG_arg_fail(2)) SWIG_fail;
25119 {
25120 PyThreadState* __tstate = wxPyBeginAllowThreads();
25121 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
25122
25123 wxPyEndAllowThreads(__tstate);
25124 if (PyErr_Occurred()) SWIG_fail;
25125 }
25126 {
25127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25128 }
25129 return resultobj;
25130 fail:
25131 return NULL;
25132 }
25133
25134
25135 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
25136 PyObject *resultobj;
25137 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25138 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25139 bool result;
25140 PyObject * obj0 = 0 ;
25141 PyObject * obj1 = 0 ;
25142 char *kwnames[] = {
25143 (char *) "self",(char *) "other", NULL
25144 };
25145
25146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25148 if (SWIG_arg_fail(1)) SWIG_fail;
25149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25150 if (SWIG_arg_fail(2)) SWIG_fail;
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
25154
25155 wxPyEndAllowThreads(__tstate);
25156 if (PyErr_Occurred()) SWIG_fail;
25157 }
25158 {
25159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25160 }
25161 return resultobj;
25162 fail:
25163 return NULL;
25164 }
25165
25166
25167 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
25168 PyObject *resultobj;
25169 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25170 bool result;
25171 PyObject * obj0 = 0 ;
25172 char *kwnames[] = {
25173 (char *) "self", NULL
25174 };
25175
25176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
25177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25178 if (SWIG_arg_fail(1)) SWIG_fail;
25179 {
25180 PyThreadState* __tstate = wxPyBeginAllowThreads();
25181 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
25182
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 {
25187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25188 }
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
25196 PyObject *resultobj;
25197 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25198 bool result;
25199 PyObject * obj0 = 0 ;
25200 char *kwnames[] = {
25201 (char *) "self", NULL
25202 };
25203
25204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
25205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25206 if (SWIG_arg_fail(1)) SWIG_fail;
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
25210
25211 wxPyEndAllowThreads(__tstate);
25212 if (PyErr_Occurred()) SWIG_fail;
25213 }
25214 {
25215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25216 }
25217 return resultobj;
25218 fail:
25219 return NULL;
25220 }
25221
25222
25223 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
25224 PyObject *resultobj;
25225 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25226 bool result;
25227 PyObject * obj0 = 0 ;
25228 char *kwnames[] = {
25229 (char *) "self", NULL
25230 };
25231
25232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
25233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25234 if (SWIG_arg_fail(1)) SWIG_fail;
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
25238
25239 wxPyEndAllowThreads(__tstate);
25240 if (PyErr_Occurred()) SWIG_fail;
25241 }
25242 {
25243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25244 }
25245 return resultobj;
25246 fail:
25247 return NULL;
25248 }
25249
25250
25251 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj;
25253 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25254 wxTimeSpan *arg2 = 0 ;
25255 bool result;
25256 PyObject * obj0 = 0 ;
25257 PyObject * obj1 = 0 ;
25258 char *kwnames[] = {
25259 (char *) "self",(char *) "ts", NULL
25260 };
25261
25262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25264 if (SWIG_arg_fail(1)) SWIG_fail;
25265 {
25266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25267 if (SWIG_arg_fail(2)) SWIG_fail;
25268 if (arg2 == NULL) {
25269 SWIG_null_ref("wxTimeSpan");
25270 }
25271 if (SWIG_arg_fail(2)) SWIG_fail;
25272 }
25273 {
25274 PyThreadState* __tstate = wxPyBeginAllowThreads();
25275 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25276
25277 wxPyEndAllowThreads(__tstate);
25278 if (PyErr_Occurred()) SWIG_fail;
25279 }
25280 {
25281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25282 }
25283 return resultobj;
25284 fail:
25285 return NULL;
25286 }
25287
25288
25289 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25290 PyObject *resultobj;
25291 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25292 wxTimeSpan *arg2 = 0 ;
25293 bool result;
25294 PyObject * obj0 = 0 ;
25295 PyObject * obj1 = 0 ;
25296 char *kwnames[] = {
25297 (char *) "self",(char *) "ts", NULL
25298 };
25299
25300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25302 if (SWIG_arg_fail(1)) SWIG_fail;
25303 {
25304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25305 if (SWIG_arg_fail(2)) SWIG_fail;
25306 if (arg2 == NULL) {
25307 SWIG_null_ref("wxTimeSpan");
25308 }
25309 if (SWIG_arg_fail(2)) SWIG_fail;
25310 }
25311 {
25312 PyThreadState* __tstate = wxPyBeginAllowThreads();
25313 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25314
25315 wxPyEndAllowThreads(__tstate);
25316 if (PyErr_Occurred()) SWIG_fail;
25317 }
25318 {
25319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25320 }
25321 return resultobj;
25322 fail:
25323 return NULL;
25324 }
25325
25326
25327 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25328 PyObject *resultobj;
25329 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25330 wxTimeSpan *arg2 = 0 ;
25331 bool result;
25332 PyObject * obj0 = 0 ;
25333 PyObject * obj1 = 0 ;
25334 char *kwnames[] = {
25335 (char *) "self",(char *) "t", NULL
25336 };
25337
25338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25340 if (SWIG_arg_fail(1)) SWIG_fail;
25341 {
25342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25343 if (SWIG_arg_fail(2)) SWIG_fail;
25344 if (arg2 == NULL) {
25345 SWIG_null_ref("wxTimeSpan");
25346 }
25347 if (SWIG_arg_fail(2)) SWIG_fail;
25348 }
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25352
25353 wxPyEndAllowThreads(__tstate);
25354 if (PyErr_Occurred()) SWIG_fail;
25355 }
25356 {
25357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25358 }
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25366 PyObject *resultobj;
25367 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25368 int result;
25369 PyObject * obj0 = 0 ;
25370 char *kwnames[] = {
25371 (char *) "self", NULL
25372 };
25373
25374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25376 if (SWIG_arg_fail(1)) SWIG_fail;
25377 {
25378 PyThreadState* __tstate = wxPyBeginAllowThreads();
25379 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25380
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 {
25385 resultobj = SWIG_From_int((int)(result));
25386 }
25387 return resultobj;
25388 fail:
25389 return NULL;
25390 }
25391
25392
25393 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25394 PyObject *resultobj;
25395 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25396 int result;
25397 PyObject * obj0 = 0 ;
25398 char *kwnames[] = {
25399 (char *) "self", NULL
25400 };
25401
25402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25404 if (SWIG_arg_fail(1)) SWIG_fail;
25405 {
25406 PyThreadState* __tstate = wxPyBeginAllowThreads();
25407 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25408
25409 wxPyEndAllowThreads(__tstate);
25410 if (PyErr_Occurred()) SWIG_fail;
25411 }
25412 {
25413 resultobj = SWIG_From_int((int)(result));
25414 }
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj;
25423 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25424 int result;
25425 PyObject * obj0 = 0 ;
25426 char *kwnames[] = {
25427 (char *) "self", NULL
25428 };
25429
25430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25432 if (SWIG_arg_fail(1)) SWIG_fail;
25433 {
25434 PyThreadState* __tstate = wxPyBeginAllowThreads();
25435 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25436
25437 wxPyEndAllowThreads(__tstate);
25438 if (PyErr_Occurred()) SWIG_fail;
25439 }
25440 {
25441 resultobj = SWIG_From_int((int)(result));
25442 }
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25450 PyObject *resultobj;
25451 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25452 int result;
25453 PyObject * obj0 = 0 ;
25454 char *kwnames[] = {
25455 (char *) "self", NULL
25456 };
25457
25458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25460 if (SWIG_arg_fail(1)) SWIG_fail;
25461 {
25462 PyThreadState* __tstate = wxPyBeginAllowThreads();
25463 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25464
25465 wxPyEndAllowThreads(__tstate);
25466 if (PyErr_Occurred()) SWIG_fail;
25467 }
25468 {
25469 resultobj = SWIG_From_int((int)(result));
25470 }
25471 return resultobj;
25472 fail:
25473 return NULL;
25474 }
25475
25476
25477 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25478 PyObject *resultobj;
25479 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25480 wxLongLong result;
25481 PyObject * obj0 = 0 ;
25482 char *kwnames[] = {
25483 (char *) "self", NULL
25484 };
25485
25486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25488 if (SWIG_arg_fail(1)) SWIG_fail;
25489 {
25490 PyThreadState* __tstate = wxPyBeginAllowThreads();
25491 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25492
25493 wxPyEndAllowThreads(__tstate);
25494 if (PyErr_Occurred()) SWIG_fail;
25495 }
25496 {
25497 PyObject *hi, *lo, *shifter, *shifted;
25498 hi = PyLong_FromLong( (&result)->GetHi() );
25499 lo = PyLong_FromLong( (&result)->GetLo() );
25500 shifter = PyLong_FromLong(32);
25501 shifted = PyNumber_Lshift(hi, shifter);
25502 resultobj = PyNumber_Or(shifted, lo);
25503 Py_DECREF(hi);
25504 Py_DECREF(lo);
25505 Py_DECREF(shifter);
25506 Py_DECREF(shifted);
25507 }
25508 return resultobj;
25509 fail:
25510 return NULL;
25511 }
25512
25513
25514 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25515 PyObject *resultobj;
25516 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25517 wxLongLong result;
25518 PyObject * obj0 = 0 ;
25519 char *kwnames[] = {
25520 (char *) "self", NULL
25521 };
25522
25523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25525 if (SWIG_arg_fail(1)) SWIG_fail;
25526 {
25527 PyThreadState* __tstate = wxPyBeginAllowThreads();
25528 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25529
25530 wxPyEndAllowThreads(__tstate);
25531 if (PyErr_Occurred()) SWIG_fail;
25532 }
25533 {
25534 PyObject *hi, *lo, *shifter, *shifted;
25535 hi = PyLong_FromLong( (&result)->GetHi() );
25536 lo = PyLong_FromLong( (&result)->GetLo() );
25537 shifter = PyLong_FromLong(32);
25538 shifted = PyNumber_Lshift(hi, shifter);
25539 resultobj = PyNumber_Or(shifted, lo);
25540 Py_DECREF(hi);
25541 Py_DECREF(lo);
25542 Py_DECREF(shifter);
25543 Py_DECREF(shifted);
25544 }
25545 return resultobj;
25546 fail:
25547 return NULL;
25548 }
25549
25550
25551 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25552 PyObject *resultobj;
25553 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25554 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25555 wxString *arg2 = (wxString *) &arg2_defvalue ;
25556 wxString result;
25557 bool temp2 = false ;
25558 PyObject * obj0 = 0 ;
25559 PyObject * obj1 = 0 ;
25560 char *kwnames[] = {
25561 (char *) "self",(char *) "format", NULL
25562 };
25563
25564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25566 if (SWIG_arg_fail(1)) SWIG_fail;
25567 if (obj1) {
25568 {
25569 arg2 = wxString_in_helper(obj1);
25570 if (arg2 == NULL) SWIG_fail;
25571 temp2 = true;
25572 }
25573 }
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25577
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 {
25582 #if wxUSE_UNICODE
25583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25584 #else
25585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25586 #endif
25587 }
25588 {
25589 if (temp2)
25590 delete arg2;
25591 }
25592 return resultobj;
25593 fail:
25594 {
25595 if (temp2)
25596 delete arg2;
25597 }
25598 return NULL;
25599 }
25600
25601
25602 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25603 PyObject *obj;
25604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25605 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25606 Py_INCREF(obj);
25607 return Py_BuildValue((char *)"");
25608 }
25609 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj;
25611 int arg1 = (int) 0 ;
25612 int arg2 = (int) 0 ;
25613 int arg3 = (int) 0 ;
25614 int arg4 = (int) 0 ;
25615 wxDateSpan *result;
25616 PyObject * obj0 = 0 ;
25617 PyObject * obj1 = 0 ;
25618 PyObject * obj2 = 0 ;
25619 PyObject * obj3 = 0 ;
25620 char *kwnames[] = {
25621 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25622 };
25623
25624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25625 if (obj0) {
25626 {
25627 arg1 = (int)(SWIG_As_int(obj0));
25628 if (SWIG_arg_fail(1)) SWIG_fail;
25629 }
25630 }
25631 if (obj1) {
25632 {
25633 arg2 = (int)(SWIG_As_int(obj1));
25634 if (SWIG_arg_fail(2)) SWIG_fail;
25635 }
25636 }
25637 if (obj2) {
25638 {
25639 arg3 = (int)(SWIG_As_int(obj2));
25640 if (SWIG_arg_fail(3)) SWIG_fail;
25641 }
25642 }
25643 if (obj3) {
25644 {
25645 arg4 = (int)(SWIG_As_int(obj3));
25646 if (SWIG_arg_fail(4)) SWIG_fail;
25647 }
25648 }
25649 {
25650 PyThreadState* __tstate = wxPyBeginAllowThreads();
25651 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25652
25653 wxPyEndAllowThreads(__tstate);
25654 if (PyErr_Occurred()) SWIG_fail;
25655 }
25656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25657 return resultobj;
25658 fail:
25659 return NULL;
25660 }
25661
25662
25663 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25664 PyObject *resultobj;
25665 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25666 PyObject * obj0 = 0 ;
25667 char *kwnames[] = {
25668 (char *) "self", NULL
25669 };
25670
25671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25673 if (SWIG_arg_fail(1)) SWIG_fail;
25674 {
25675 PyThreadState* __tstate = wxPyBeginAllowThreads();
25676 delete arg1;
25677
25678 wxPyEndAllowThreads(__tstate);
25679 if (PyErr_Occurred()) SWIG_fail;
25680 }
25681 Py_INCREF(Py_None); resultobj = Py_None;
25682 return resultobj;
25683 fail:
25684 return NULL;
25685 }
25686
25687
25688 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25689 PyObject *resultobj;
25690 int arg1 ;
25691 wxDateSpan result;
25692 PyObject * obj0 = 0 ;
25693 char *kwnames[] = {
25694 (char *) "days", NULL
25695 };
25696
25697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25698 {
25699 arg1 = (int)(SWIG_As_int(obj0));
25700 if (SWIG_arg_fail(1)) SWIG_fail;
25701 }
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 result = wxDateSpan::Days(arg1);
25705
25706 wxPyEndAllowThreads(__tstate);
25707 if (PyErr_Occurred()) SWIG_fail;
25708 }
25709 {
25710 wxDateSpan * resultptr;
25711 resultptr = new wxDateSpan((wxDateSpan &)(result));
25712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25713 }
25714 return resultobj;
25715 fail:
25716 return NULL;
25717 }
25718
25719
25720 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25721 PyObject *resultobj;
25722 wxDateSpan result;
25723 char *kwnames[] = {
25724 NULL
25725 };
25726
25727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 result = wxDateSpan::Day();
25731
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 {
25736 wxDateSpan * resultptr;
25737 resultptr = new wxDateSpan((wxDateSpan &)(result));
25738 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25739 }
25740 return resultobj;
25741 fail:
25742 return NULL;
25743 }
25744
25745
25746 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25747 PyObject *resultobj;
25748 int arg1 ;
25749 wxDateSpan result;
25750 PyObject * obj0 = 0 ;
25751 char *kwnames[] = {
25752 (char *) "weeks", NULL
25753 };
25754
25755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25756 {
25757 arg1 = (int)(SWIG_As_int(obj0));
25758 if (SWIG_arg_fail(1)) SWIG_fail;
25759 }
25760 {
25761 PyThreadState* __tstate = wxPyBeginAllowThreads();
25762 result = wxDateSpan::Weeks(arg1);
25763
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 {
25768 wxDateSpan * resultptr;
25769 resultptr = new wxDateSpan((wxDateSpan &)(result));
25770 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25771 }
25772 return resultobj;
25773 fail:
25774 return NULL;
25775 }
25776
25777
25778 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25779 PyObject *resultobj;
25780 wxDateSpan result;
25781 char *kwnames[] = {
25782 NULL
25783 };
25784
25785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25786 {
25787 PyThreadState* __tstate = wxPyBeginAllowThreads();
25788 result = wxDateSpan::Week();
25789
25790 wxPyEndAllowThreads(__tstate);
25791 if (PyErr_Occurred()) SWIG_fail;
25792 }
25793 {
25794 wxDateSpan * resultptr;
25795 resultptr = new wxDateSpan((wxDateSpan &)(result));
25796 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25797 }
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25805 PyObject *resultobj;
25806 int arg1 ;
25807 wxDateSpan result;
25808 PyObject * obj0 = 0 ;
25809 char *kwnames[] = {
25810 (char *) "mon", NULL
25811 };
25812
25813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25814 {
25815 arg1 = (int)(SWIG_As_int(obj0));
25816 if (SWIG_arg_fail(1)) SWIG_fail;
25817 }
25818 {
25819 PyThreadState* __tstate = wxPyBeginAllowThreads();
25820 result = wxDateSpan::Months(arg1);
25821
25822 wxPyEndAllowThreads(__tstate);
25823 if (PyErr_Occurred()) SWIG_fail;
25824 }
25825 {
25826 wxDateSpan * resultptr;
25827 resultptr = new wxDateSpan((wxDateSpan &)(result));
25828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25829 }
25830 return resultobj;
25831 fail:
25832 return NULL;
25833 }
25834
25835
25836 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25837 PyObject *resultobj;
25838 wxDateSpan result;
25839 char *kwnames[] = {
25840 NULL
25841 };
25842
25843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25844 {
25845 PyThreadState* __tstate = wxPyBeginAllowThreads();
25846 result = wxDateSpan::Month();
25847
25848 wxPyEndAllowThreads(__tstate);
25849 if (PyErr_Occurred()) SWIG_fail;
25850 }
25851 {
25852 wxDateSpan * resultptr;
25853 resultptr = new wxDateSpan((wxDateSpan &)(result));
25854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25855 }
25856 return resultobj;
25857 fail:
25858 return NULL;
25859 }
25860
25861
25862 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25863 PyObject *resultobj;
25864 int arg1 ;
25865 wxDateSpan result;
25866 PyObject * obj0 = 0 ;
25867 char *kwnames[] = {
25868 (char *) "years", NULL
25869 };
25870
25871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25872 {
25873 arg1 = (int)(SWIG_As_int(obj0));
25874 if (SWIG_arg_fail(1)) SWIG_fail;
25875 }
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 result = wxDateSpan::Years(arg1);
25879
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 {
25884 wxDateSpan * resultptr;
25885 resultptr = new wxDateSpan((wxDateSpan &)(result));
25886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25887 }
25888 return resultobj;
25889 fail:
25890 return NULL;
25891 }
25892
25893
25894 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25895 PyObject *resultobj;
25896 wxDateSpan result;
25897 char *kwnames[] = {
25898 NULL
25899 };
25900
25901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25902 {
25903 PyThreadState* __tstate = wxPyBeginAllowThreads();
25904 result = wxDateSpan::Year();
25905
25906 wxPyEndAllowThreads(__tstate);
25907 if (PyErr_Occurred()) SWIG_fail;
25908 }
25909 {
25910 wxDateSpan * resultptr;
25911 resultptr = new wxDateSpan((wxDateSpan &)(result));
25912 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25913 }
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25921 PyObject *resultobj;
25922 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25923 int arg2 ;
25924 wxDateSpan *result;
25925 PyObject * obj0 = 0 ;
25926 PyObject * obj1 = 0 ;
25927 char *kwnames[] = {
25928 (char *) "self",(char *) "n", NULL
25929 };
25930
25931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25933 if (SWIG_arg_fail(1)) SWIG_fail;
25934 {
25935 arg2 = (int)(SWIG_As_int(obj1));
25936 if (SWIG_arg_fail(2)) SWIG_fail;
25937 }
25938 {
25939 PyThreadState* __tstate = wxPyBeginAllowThreads();
25940 {
25941 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25942 result = (wxDateSpan *) &_result_ref;
25943 }
25944
25945 wxPyEndAllowThreads(__tstate);
25946 if (PyErr_Occurred()) SWIG_fail;
25947 }
25948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25949 return resultobj;
25950 fail:
25951 return NULL;
25952 }
25953
25954
25955 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25956 PyObject *resultobj;
25957 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25958 int arg2 ;
25959 wxDateSpan *result;
25960 PyObject * obj0 = 0 ;
25961 PyObject * obj1 = 0 ;
25962 char *kwnames[] = {
25963 (char *) "self",(char *) "n", NULL
25964 };
25965
25966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25968 if (SWIG_arg_fail(1)) SWIG_fail;
25969 {
25970 arg2 = (int)(SWIG_As_int(obj1));
25971 if (SWIG_arg_fail(2)) SWIG_fail;
25972 }
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 {
25976 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25977 result = (wxDateSpan *) &_result_ref;
25978 }
25979
25980 wxPyEndAllowThreads(__tstate);
25981 if (PyErr_Occurred()) SWIG_fail;
25982 }
25983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25984 return resultobj;
25985 fail:
25986 return NULL;
25987 }
25988
25989
25990 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25991 PyObject *resultobj;
25992 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25993 int arg2 ;
25994 wxDateSpan *result;
25995 PyObject * obj0 = 0 ;
25996 PyObject * obj1 = 0 ;
25997 char *kwnames[] = {
25998 (char *) "self",(char *) "n", NULL
25999 };
26000
26001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
26002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26003 if (SWIG_arg_fail(1)) SWIG_fail;
26004 {
26005 arg2 = (int)(SWIG_As_int(obj1));
26006 if (SWIG_arg_fail(2)) SWIG_fail;
26007 }
26008 {
26009 PyThreadState* __tstate = wxPyBeginAllowThreads();
26010 {
26011 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
26012 result = (wxDateSpan *) &_result_ref;
26013 }
26014
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj;
26027 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26028 int arg2 ;
26029 wxDateSpan *result;
26030 PyObject * obj0 = 0 ;
26031 PyObject * obj1 = 0 ;
26032 char *kwnames[] = {
26033 (char *) "self",(char *) "n", NULL
26034 };
26035
26036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
26037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26038 if (SWIG_arg_fail(1)) SWIG_fail;
26039 {
26040 arg2 = (int)(SWIG_As_int(obj1));
26041 if (SWIG_arg_fail(2)) SWIG_fail;
26042 }
26043 {
26044 PyThreadState* __tstate = wxPyBeginAllowThreads();
26045 {
26046 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
26047 result = (wxDateSpan *) &_result_ref;
26048 }
26049
26050 wxPyEndAllowThreads(__tstate);
26051 if (PyErr_Occurred()) SWIG_fail;
26052 }
26053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
26061 PyObject *resultobj;
26062 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26063 int result;
26064 PyObject * obj0 = 0 ;
26065 char *kwnames[] = {
26066 (char *) "self", NULL
26067 };
26068
26069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
26070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26071 if (SWIG_arg_fail(1)) SWIG_fail;
26072 {
26073 PyThreadState* __tstate = wxPyBeginAllowThreads();
26074 result = (int)((wxDateSpan const *)arg1)->GetYears();
26075
26076 wxPyEndAllowThreads(__tstate);
26077 if (PyErr_Occurred()) SWIG_fail;
26078 }
26079 {
26080 resultobj = SWIG_From_int((int)(result));
26081 }
26082 return resultobj;
26083 fail:
26084 return NULL;
26085 }
26086
26087
26088 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
26089 PyObject *resultobj;
26090 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26091 int result;
26092 PyObject * obj0 = 0 ;
26093 char *kwnames[] = {
26094 (char *) "self", NULL
26095 };
26096
26097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
26098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26099 if (SWIG_arg_fail(1)) SWIG_fail;
26100 {
26101 PyThreadState* __tstate = wxPyBeginAllowThreads();
26102 result = (int)((wxDateSpan const *)arg1)->GetMonths();
26103
26104 wxPyEndAllowThreads(__tstate);
26105 if (PyErr_Occurred()) SWIG_fail;
26106 }
26107 {
26108 resultobj = SWIG_From_int((int)(result));
26109 }
26110 return resultobj;
26111 fail:
26112 return NULL;
26113 }
26114
26115
26116 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
26117 PyObject *resultobj;
26118 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26119 int result;
26120 PyObject * obj0 = 0 ;
26121 char *kwnames[] = {
26122 (char *) "self", NULL
26123 };
26124
26125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
26126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26127 if (SWIG_arg_fail(1)) SWIG_fail;
26128 {
26129 PyThreadState* __tstate = wxPyBeginAllowThreads();
26130 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
26131
26132 wxPyEndAllowThreads(__tstate);
26133 if (PyErr_Occurred()) SWIG_fail;
26134 }
26135 {
26136 resultobj = SWIG_From_int((int)(result));
26137 }
26138 return resultobj;
26139 fail:
26140 return NULL;
26141 }
26142
26143
26144 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26145 PyObject *resultobj;
26146 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26147 int result;
26148 PyObject * obj0 = 0 ;
26149 char *kwnames[] = {
26150 (char *) "self", NULL
26151 };
26152
26153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
26154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26155 if (SWIG_arg_fail(1)) SWIG_fail;
26156 {
26157 PyThreadState* __tstate = wxPyBeginAllowThreads();
26158 result = (int)((wxDateSpan const *)arg1)->GetDays();
26159
26160 wxPyEndAllowThreads(__tstate);
26161 if (PyErr_Occurred()) SWIG_fail;
26162 }
26163 {
26164 resultobj = SWIG_From_int((int)(result));
26165 }
26166 return resultobj;
26167 fail:
26168 return NULL;
26169 }
26170
26171
26172 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
26173 PyObject *resultobj;
26174 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26175 int result;
26176 PyObject * obj0 = 0 ;
26177 char *kwnames[] = {
26178 (char *) "self", NULL
26179 };
26180
26181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
26182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26183 if (SWIG_arg_fail(1)) SWIG_fail;
26184 {
26185 PyThreadState* __tstate = wxPyBeginAllowThreads();
26186 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
26187
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 {
26192 resultobj = SWIG_From_int((int)(result));
26193 }
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj;
26202 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26203 wxDateSpan *arg2 = 0 ;
26204 wxDateSpan *result;
26205 PyObject * obj0 = 0 ;
26206 PyObject * obj1 = 0 ;
26207 char *kwnames[] = {
26208 (char *) "self",(char *) "other", NULL
26209 };
26210
26211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
26212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26213 if (SWIG_arg_fail(1)) SWIG_fail;
26214 {
26215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26216 if (SWIG_arg_fail(2)) SWIG_fail;
26217 if (arg2 == NULL) {
26218 SWIG_null_ref("wxDateSpan");
26219 }
26220 if (SWIG_arg_fail(2)) SWIG_fail;
26221 }
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 {
26225 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26226 result = (wxDateSpan *) &_result_ref;
26227 }
26228
26229 wxPyEndAllowThreads(__tstate);
26230 if (PyErr_Occurred()) SWIG_fail;
26231 }
26232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26233 return resultobj;
26234 fail:
26235 return NULL;
26236 }
26237
26238
26239 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
26240 PyObject *resultobj;
26241 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26242 wxDateSpan *arg2 = 0 ;
26243 wxDateSpan *result;
26244 PyObject * obj0 = 0 ;
26245 PyObject * obj1 = 0 ;
26246 char *kwnames[] = {
26247 (char *) "self",(char *) "other", NULL
26248 };
26249
26250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
26251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26252 if (SWIG_arg_fail(1)) SWIG_fail;
26253 {
26254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26255 if (SWIG_arg_fail(2)) SWIG_fail;
26256 if (arg2 == NULL) {
26257 SWIG_null_ref("wxDateSpan");
26258 }
26259 if (SWIG_arg_fail(2)) SWIG_fail;
26260 }
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 {
26264 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26265 result = (wxDateSpan *) &_result_ref;
26266 }
26267
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26272 return resultobj;
26273 fail:
26274 return NULL;
26275 }
26276
26277
26278 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26279 PyObject *resultobj;
26280 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26281 wxDateSpan *result;
26282 PyObject * obj0 = 0 ;
26283 char *kwnames[] = {
26284 (char *) "self", NULL
26285 };
26286
26287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26289 if (SWIG_arg_fail(1)) SWIG_fail;
26290 {
26291 PyThreadState* __tstate = wxPyBeginAllowThreads();
26292 {
26293 wxDateSpan &_result_ref = (arg1)->Neg();
26294 result = (wxDateSpan *) &_result_ref;
26295 }
26296
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26301 return resultobj;
26302 fail:
26303 return NULL;
26304 }
26305
26306
26307 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj;
26309 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26310 int arg2 ;
26311 wxDateSpan *result;
26312 PyObject * obj0 = 0 ;
26313 PyObject * obj1 = 0 ;
26314 char *kwnames[] = {
26315 (char *) "self",(char *) "factor", NULL
26316 };
26317
26318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26320 if (SWIG_arg_fail(1)) SWIG_fail;
26321 {
26322 arg2 = (int)(SWIG_As_int(obj1));
26323 if (SWIG_arg_fail(2)) SWIG_fail;
26324 }
26325 {
26326 PyThreadState* __tstate = wxPyBeginAllowThreads();
26327 {
26328 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26329 result = (wxDateSpan *) &_result_ref;
26330 }
26331
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26336 return resultobj;
26337 fail:
26338 return NULL;
26339 }
26340
26341
26342 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26343 PyObject *resultobj;
26344 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26345 wxDateSpan *arg2 = 0 ;
26346 wxDateSpan *result;
26347 PyObject * obj0 = 0 ;
26348 PyObject * obj1 = 0 ;
26349 char *kwnames[] = {
26350 (char *) "self",(char *) "other", NULL
26351 };
26352
26353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26355 if (SWIG_arg_fail(1)) SWIG_fail;
26356 {
26357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26358 if (SWIG_arg_fail(2)) SWIG_fail;
26359 if (arg2 == NULL) {
26360 SWIG_null_ref("wxDateSpan");
26361 }
26362 if (SWIG_arg_fail(2)) SWIG_fail;
26363 }
26364 {
26365 PyThreadState* __tstate = wxPyBeginAllowThreads();
26366 {
26367 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26368 result = (wxDateSpan *) &_result_ref;
26369 }
26370
26371 wxPyEndAllowThreads(__tstate);
26372 if (PyErr_Occurred()) SWIG_fail;
26373 }
26374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26375 return resultobj;
26376 fail:
26377 return NULL;
26378 }
26379
26380
26381 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26382 PyObject *resultobj;
26383 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26384 wxDateSpan *arg2 = 0 ;
26385 wxDateSpan *result;
26386 PyObject * obj0 = 0 ;
26387 PyObject * obj1 = 0 ;
26388 char *kwnames[] = {
26389 (char *) "self",(char *) "other", NULL
26390 };
26391
26392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26394 if (SWIG_arg_fail(1)) SWIG_fail;
26395 {
26396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26397 if (SWIG_arg_fail(2)) SWIG_fail;
26398 if (arg2 == NULL) {
26399 SWIG_null_ref("wxDateSpan");
26400 }
26401 if (SWIG_arg_fail(2)) SWIG_fail;
26402 }
26403 {
26404 PyThreadState* __tstate = wxPyBeginAllowThreads();
26405 {
26406 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26407 result = (wxDateSpan *) &_result_ref;
26408 }
26409
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26421 PyObject *resultobj;
26422 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26423 wxDateSpan *result;
26424 PyObject * obj0 = 0 ;
26425 char *kwnames[] = {
26426 (char *) "self", NULL
26427 };
26428
26429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26431 if (SWIG_arg_fail(1)) SWIG_fail;
26432 {
26433 PyThreadState* __tstate = wxPyBeginAllowThreads();
26434 {
26435 wxDateSpan &_result_ref = (arg1)->operator -();
26436 result = (wxDateSpan *) &_result_ref;
26437 }
26438
26439 wxPyEndAllowThreads(__tstate);
26440 if (PyErr_Occurred()) SWIG_fail;
26441 }
26442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26443 return resultobj;
26444 fail:
26445 return NULL;
26446 }
26447
26448
26449 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26450 PyObject *resultobj;
26451 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26452 int arg2 ;
26453 wxDateSpan *result;
26454 PyObject * obj0 = 0 ;
26455 PyObject * obj1 = 0 ;
26456 char *kwnames[] = {
26457 (char *) "self",(char *) "factor", NULL
26458 };
26459
26460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26462 if (SWIG_arg_fail(1)) SWIG_fail;
26463 {
26464 arg2 = (int)(SWIG_As_int(obj1));
26465 if (SWIG_arg_fail(2)) SWIG_fail;
26466 }
26467 {
26468 PyThreadState* __tstate = wxPyBeginAllowThreads();
26469 {
26470 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26471 result = (wxDateSpan *) &_result_ref;
26472 }
26473
26474 wxPyEndAllowThreads(__tstate);
26475 if (PyErr_Occurred()) SWIG_fail;
26476 }
26477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26478 return resultobj;
26479 fail:
26480 return NULL;
26481 }
26482
26483
26484 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26485 PyObject *resultobj;
26486 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26487 wxDateSpan *arg2 = 0 ;
26488 wxDateSpan result;
26489 PyObject * obj0 = 0 ;
26490 PyObject * obj1 = 0 ;
26491 char *kwnames[] = {
26492 (char *) "self",(char *) "other", NULL
26493 };
26494
26495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26497 if (SWIG_arg_fail(1)) SWIG_fail;
26498 {
26499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26500 if (SWIG_arg_fail(2)) SWIG_fail;
26501 if (arg2 == NULL) {
26502 SWIG_null_ref("wxDateSpan");
26503 }
26504 if (SWIG_arg_fail(2)) SWIG_fail;
26505 }
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26509
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 {
26514 wxDateSpan * resultptr;
26515 resultptr = new wxDateSpan((wxDateSpan &)(result));
26516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26517 }
26518 return resultobj;
26519 fail:
26520 return NULL;
26521 }
26522
26523
26524 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26525 PyObject *resultobj;
26526 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26527 wxDateSpan *arg2 = 0 ;
26528 wxDateSpan result;
26529 PyObject * obj0 = 0 ;
26530 PyObject * obj1 = 0 ;
26531 char *kwnames[] = {
26532 (char *) "self",(char *) "other", NULL
26533 };
26534
26535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26537 if (SWIG_arg_fail(1)) SWIG_fail;
26538 {
26539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26540 if (SWIG_arg_fail(2)) SWIG_fail;
26541 if (arg2 == NULL) {
26542 SWIG_null_ref("wxDateSpan");
26543 }
26544 if (SWIG_arg_fail(2)) SWIG_fail;
26545 }
26546 {
26547 PyThreadState* __tstate = wxPyBeginAllowThreads();
26548 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26549
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 {
26554 wxDateSpan * resultptr;
26555 resultptr = new wxDateSpan((wxDateSpan &)(result));
26556 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26557 }
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26565 PyObject *resultobj;
26566 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26567 int arg2 ;
26568 wxDateSpan result;
26569 PyObject * obj0 = 0 ;
26570 PyObject * obj1 = 0 ;
26571 char *kwnames[] = {
26572 (char *) "self",(char *) "n", NULL
26573 };
26574
26575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26577 if (SWIG_arg_fail(1)) SWIG_fail;
26578 {
26579 arg2 = (int)(SWIG_As_int(obj1));
26580 if (SWIG_arg_fail(2)) SWIG_fail;
26581 }
26582 {
26583 PyThreadState* __tstate = wxPyBeginAllowThreads();
26584 result = wxDateSpan___mul__(arg1,arg2);
26585
26586 wxPyEndAllowThreads(__tstate);
26587 if (PyErr_Occurred()) SWIG_fail;
26588 }
26589 {
26590 wxDateSpan * resultptr;
26591 resultptr = new wxDateSpan((wxDateSpan &)(result));
26592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26593 }
26594 return resultobj;
26595 fail:
26596 return NULL;
26597 }
26598
26599
26600 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26601 PyObject *resultobj;
26602 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26603 int arg2 ;
26604 wxDateSpan result;
26605 PyObject * obj0 = 0 ;
26606 PyObject * obj1 = 0 ;
26607 char *kwnames[] = {
26608 (char *) "self",(char *) "n", NULL
26609 };
26610
26611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26613 if (SWIG_arg_fail(1)) SWIG_fail;
26614 {
26615 arg2 = (int)(SWIG_As_int(obj1));
26616 if (SWIG_arg_fail(2)) SWIG_fail;
26617 }
26618 {
26619 PyThreadState* __tstate = wxPyBeginAllowThreads();
26620 result = wxDateSpan___rmul__(arg1,arg2);
26621
26622 wxPyEndAllowThreads(__tstate);
26623 if (PyErr_Occurred()) SWIG_fail;
26624 }
26625 {
26626 wxDateSpan * resultptr;
26627 resultptr = new wxDateSpan((wxDateSpan &)(result));
26628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26629 }
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj;
26638 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26639 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26640 bool result;
26641 PyObject * obj0 = 0 ;
26642 PyObject * obj1 = 0 ;
26643 char *kwnames[] = {
26644 (char *) "self",(char *) "other", NULL
26645 };
26646
26647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26649 if (SWIG_arg_fail(1)) SWIG_fail;
26650 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26651 if (SWIG_arg_fail(2)) SWIG_fail;
26652 {
26653 PyThreadState* __tstate = wxPyBeginAllowThreads();
26654 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26655
26656 wxPyEndAllowThreads(__tstate);
26657 if (PyErr_Occurred()) SWIG_fail;
26658 }
26659 {
26660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26661 }
26662 return resultobj;
26663 fail:
26664 return NULL;
26665 }
26666
26667
26668 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26669 PyObject *resultobj;
26670 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26671 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26672 bool result;
26673 PyObject * obj0 = 0 ;
26674 PyObject * obj1 = 0 ;
26675 char *kwnames[] = {
26676 (char *) "self",(char *) "other", NULL
26677 };
26678
26679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26681 if (SWIG_arg_fail(1)) SWIG_fail;
26682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26683 if (SWIG_arg_fail(2)) SWIG_fail;
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26687
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 {
26692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26693 }
26694 return resultobj;
26695 fail:
26696 return NULL;
26697 }
26698
26699
26700 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26701 PyObject *obj;
26702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26703 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26704 Py_INCREF(obj);
26705 return Py_BuildValue((char *)"");
26706 }
26707 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26708 PyObject *resultobj;
26709 long result;
26710 char *kwnames[] = {
26711 NULL
26712 };
26713
26714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26715 {
26716 PyThreadState* __tstate = wxPyBeginAllowThreads();
26717 result = (long)wxGetLocalTime();
26718
26719 wxPyEndAllowThreads(__tstate);
26720 if (PyErr_Occurred()) SWIG_fail;
26721 }
26722 {
26723 resultobj = SWIG_From_long((long)(result));
26724 }
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj;
26733 long result;
26734 char *kwnames[] = {
26735 NULL
26736 };
26737
26738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26739 {
26740 PyThreadState* __tstate = wxPyBeginAllowThreads();
26741 result = (long)wxGetUTCTime();
26742
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 {
26747 resultobj = SWIG_From_long((long)(result));
26748 }
26749 return resultobj;
26750 fail:
26751 return NULL;
26752 }
26753
26754
26755 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj;
26757 long result;
26758 char *kwnames[] = {
26759 NULL
26760 };
26761
26762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26763 {
26764 PyThreadState* __tstate = wxPyBeginAllowThreads();
26765 result = (long)wxGetCurrentTime();
26766
26767 wxPyEndAllowThreads(__tstate);
26768 if (PyErr_Occurred()) SWIG_fail;
26769 }
26770 {
26771 resultobj = SWIG_From_long((long)(result));
26772 }
26773 return resultobj;
26774 fail:
26775 return NULL;
26776 }
26777
26778
26779 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26780 PyObject *resultobj;
26781 wxLongLong result;
26782 char *kwnames[] = {
26783 NULL
26784 };
26785
26786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26787 {
26788 PyThreadState* __tstate = wxPyBeginAllowThreads();
26789 result = wxGetLocalTimeMillis();
26790
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 {
26795 PyObject *hi, *lo, *shifter, *shifted;
26796 hi = PyLong_FromLong( (&result)->GetHi() );
26797 lo = PyLong_FromLong( (&result)->GetLo() );
26798 shifter = PyLong_FromLong(32);
26799 shifted = PyNumber_Lshift(hi, shifter);
26800 resultobj = PyNumber_Or(shifted, lo);
26801 Py_DECREF(hi);
26802 Py_DECREF(lo);
26803 Py_DECREF(shifter);
26804 Py_DECREF(shifted);
26805 }
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 static int _wrap_DefaultDateTime_set(PyObject *) {
26813 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26814 return 1;
26815 }
26816
26817
26818 static PyObject *_wrap_DefaultDateTime_get(void) {
26819 PyObject *pyobj;
26820
26821 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26822 return pyobj;
26823 }
26824
26825
26826 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26827 PyObject *resultobj;
26828 wxDataFormatId arg1 ;
26829 wxDataFormat *result;
26830 PyObject * obj0 = 0 ;
26831 char *kwnames[] = {
26832 (char *) "type", NULL
26833 };
26834
26835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26836 {
26837 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26838 if (SWIG_arg_fail(1)) SWIG_fail;
26839 }
26840 {
26841 PyThreadState* __tstate = wxPyBeginAllowThreads();
26842 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26843
26844 wxPyEndAllowThreads(__tstate);
26845 if (PyErr_Occurred()) SWIG_fail;
26846 }
26847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26848 return resultobj;
26849 fail:
26850 return NULL;
26851 }
26852
26853
26854 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26855 PyObject *resultobj;
26856 wxString *arg1 = 0 ;
26857 wxDataFormat *result;
26858 bool temp1 = false ;
26859 PyObject * obj0 = 0 ;
26860 char *kwnames[] = {
26861 (char *) "format", NULL
26862 };
26863
26864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26865 {
26866 arg1 = wxString_in_helper(obj0);
26867 if (arg1 == NULL) SWIG_fail;
26868 temp1 = true;
26869 }
26870 {
26871 PyThreadState* __tstate = wxPyBeginAllowThreads();
26872 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26873
26874 wxPyEndAllowThreads(__tstate);
26875 if (PyErr_Occurred()) SWIG_fail;
26876 }
26877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26878 {
26879 if (temp1)
26880 delete arg1;
26881 }
26882 return resultobj;
26883 fail:
26884 {
26885 if (temp1)
26886 delete arg1;
26887 }
26888 return NULL;
26889 }
26890
26891
26892 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj;
26894 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26895 PyObject * obj0 = 0 ;
26896 char *kwnames[] = {
26897 (char *) "self", NULL
26898 };
26899
26900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26902 if (SWIG_arg_fail(1)) SWIG_fail;
26903 {
26904 PyThreadState* __tstate = wxPyBeginAllowThreads();
26905 delete arg1;
26906
26907 wxPyEndAllowThreads(__tstate);
26908 if (PyErr_Occurred()) SWIG_fail;
26909 }
26910 Py_INCREF(Py_None); resultobj = Py_None;
26911 return resultobj;
26912 fail:
26913 return NULL;
26914 }
26915
26916
26917 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26918 PyObject *resultobj;
26919 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26920 wxDataFormatId arg2 ;
26921 bool result;
26922 PyObject * obj0 = 0 ;
26923 PyObject * obj1 = 0 ;
26924
26925 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26927 if (SWIG_arg_fail(1)) SWIG_fail;
26928 {
26929 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26930 if (SWIG_arg_fail(2)) SWIG_fail;
26931 }
26932 {
26933 PyThreadState* __tstate = wxPyBeginAllowThreads();
26934 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26935
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 {
26940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26941 }
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26949 PyObject *resultobj;
26950 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26951 wxDataFormatId arg2 ;
26952 bool result;
26953 PyObject * obj0 = 0 ;
26954 PyObject * obj1 = 0 ;
26955
26956 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26958 if (SWIG_arg_fail(1)) SWIG_fail;
26959 {
26960 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26961 if (SWIG_arg_fail(2)) SWIG_fail;
26962 }
26963 {
26964 PyThreadState* __tstate = wxPyBeginAllowThreads();
26965 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26966
26967 wxPyEndAllowThreads(__tstate);
26968 if (PyErr_Occurred()) SWIG_fail;
26969 }
26970 {
26971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26972 }
26973 return resultobj;
26974 fail:
26975 return NULL;
26976 }
26977
26978
26979 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26980 PyObject *resultobj;
26981 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26982 wxDataFormat *arg2 = 0 ;
26983 bool result;
26984 PyObject * obj0 = 0 ;
26985 PyObject * obj1 = 0 ;
26986
26987 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26989 if (SWIG_arg_fail(1)) SWIG_fail;
26990 {
26991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26992 if (SWIG_arg_fail(2)) SWIG_fail;
26993 if (arg2 == NULL) {
26994 SWIG_null_ref("wxDataFormat");
26995 }
26996 if (SWIG_arg_fail(2)) SWIG_fail;
26997 }
26998 {
26999 PyThreadState* __tstate = wxPyBeginAllowThreads();
27000 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
27001
27002 wxPyEndAllowThreads(__tstate);
27003 if (PyErr_Occurred()) SWIG_fail;
27004 }
27005 {
27006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27007 }
27008 return resultobj;
27009 fail:
27010 return NULL;
27011 }
27012
27013
27014 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
27015 int argc;
27016 PyObject *argv[3];
27017 int ii;
27018
27019 argc = PyObject_Length(args);
27020 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
27021 argv[ii] = PyTuple_GetItem(args,ii);
27022 }
27023 if (argc == 2) {
27024 int _v;
27025 {
27026 void *ptr;
27027 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27028 _v = 0;
27029 PyErr_Clear();
27030 } else {
27031 _v = 1;
27032 }
27033 }
27034 if (_v) {
27035 {
27036 void *ptr = 0;
27037 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27038 _v = 0;
27039 PyErr_Clear();
27040 } else {
27041 _v = (ptr != 0);
27042 }
27043 }
27044 if (_v) {
27045 return _wrap_DataFormat___eq____SWIG_1(self,args);
27046 }
27047 }
27048 }
27049 if (argc == 2) {
27050 int _v;
27051 {
27052 void *ptr;
27053 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27054 _v = 0;
27055 PyErr_Clear();
27056 } else {
27057 _v = 1;
27058 }
27059 }
27060 if (_v) {
27061 _v = SWIG_Check_int(argv[1]);
27062 if (_v) {
27063 return _wrap_DataFormat___eq____SWIG_0(self,args);
27064 }
27065 }
27066 }
27067
27068 Py_INCREF(Py_NotImplemented);
27069 return Py_NotImplemented;
27070 }
27071
27072
27073 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
27074 PyObject *resultobj;
27075 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27076 wxDataFormat *arg2 = 0 ;
27077 bool result;
27078 PyObject * obj0 = 0 ;
27079 PyObject * obj1 = 0 ;
27080
27081 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
27082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27083 if (SWIG_arg_fail(1)) SWIG_fail;
27084 {
27085 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27086 if (SWIG_arg_fail(2)) SWIG_fail;
27087 if (arg2 == NULL) {
27088 SWIG_null_ref("wxDataFormat");
27089 }
27090 if (SWIG_arg_fail(2)) SWIG_fail;
27091 }
27092 {
27093 PyThreadState* __tstate = wxPyBeginAllowThreads();
27094 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
27095
27096 wxPyEndAllowThreads(__tstate);
27097 if (PyErr_Occurred()) SWIG_fail;
27098 }
27099 {
27100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27101 }
27102 return resultobj;
27103 fail:
27104 return NULL;
27105 }
27106
27107
27108 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
27109 int argc;
27110 PyObject *argv[3];
27111 int ii;
27112
27113 argc = PyObject_Length(args);
27114 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
27115 argv[ii] = PyTuple_GetItem(args,ii);
27116 }
27117 if (argc == 2) {
27118 int _v;
27119 {
27120 void *ptr;
27121 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27122 _v = 0;
27123 PyErr_Clear();
27124 } else {
27125 _v = 1;
27126 }
27127 }
27128 if (_v) {
27129 {
27130 void *ptr = 0;
27131 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27132 _v = 0;
27133 PyErr_Clear();
27134 } else {
27135 _v = (ptr != 0);
27136 }
27137 }
27138 if (_v) {
27139 return _wrap_DataFormat___ne____SWIG_1(self,args);
27140 }
27141 }
27142 }
27143 if (argc == 2) {
27144 int _v;
27145 {
27146 void *ptr;
27147 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27148 _v = 0;
27149 PyErr_Clear();
27150 } else {
27151 _v = 1;
27152 }
27153 }
27154 if (_v) {
27155 _v = SWIG_Check_int(argv[1]);
27156 if (_v) {
27157 return _wrap_DataFormat___ne____SWIG_0(self,args);
27158 }
27159 }
27160 }
27161
27162 Py_INCREF(Py_NotImplemented);
27163 return Py_NotImplemented;
27164 }
27165
27166
27167 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
27168 PyObject *resultobj;
27169 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27170 wxDataFormatId arg2 ;
27171 PyObject * obj0 = 0 ;
27172 PyObject * obj1 = 0 ;
27173 char *kwnames[] = {
27174 (char *) "self",(char *) "format", NULL
27175 };
27176
27177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
27178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27179 if (SWIG_arg_fail(1)) SWIG_fail;
27180 {
27181 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
27182 if (SWIG_arg_fail(2)) SWIG_fail;
27183 }
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 (arg1)->SetType((wxDataFormatId )arg2);
27187
27188 wxPyEndAllowThreads(__tstate);
27189 if (PyErr_Occurred()) SWIG_fail;
27190 }
27191 Py_INCREF(Py_None); resultobj = Py_None;
27192 return resultobj;
27193 fail:
27194 return NULL;
27195 }
27196
27197
27198 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
27199 PyObject *resultobj;
27200 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27201 wxDataFormatId result;
27202 PyObject * obj0 = 0 ;
27203 char *kwnames[] = {
27204 (char *) "self", NULL
27205 };
27206
27207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
27208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27209 if (SWIG_arg_fail(1)) SWIG_fail;
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
27213
27214 wxPyEndAllowThreads(__tstate);
27215 if (PyErr_Occurred()) SWIG_fail;
27216 }
27217 resultobj = SWIG_From_int((result));
27218 return resultobj;
27219 fail:
27220 return NULL;
27221 }
27222
27223
27224 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
27225 PyObject *resultobj;
27226 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27227 wxString result;
27228 PyObject * obj0 = 0 ;
27229 char *kwnames[] = {
27230 (char *) "self", NULL
27231 };
27232
27233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
27234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27235 if (SWIG_arg_fail(1)) SWIG_fail;
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 result = ((wxDataFormat const *)arg1)->GetId();
27239
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 {
27244 #if wxUSE_UNICODE
27245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27246 #else
27247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27248 #endif
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj;
27258 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27259 wxString *arg2 = 0 ;
27260 bool temp2 = false ;
27261 PyObject * obj0 = 0 ;
27262 PyObject * obj1 = 0 ;
27263 char *kwnames[] = {
27264 (char *) "self",(char *) "format", NULL
27265 };
27266
27267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27269 if (SWIG_arg_fail(1)) SWIG_fail;
27270 {
27271 arg2 = wxString_in_helper(obj1);
27272 if (arg2 == NULL) SWIG_fail;
27273 temp2 = true;
27274 }
27275 {
27276 PyThreadState* __tstate = wxPyBeginAllowThreads();
27277 (arg1)->SetId((wxString const &)*arg2);
27278
27279 wxPyEndAllowThreads(__tstate);
27280 if (PyErr_Occurred()) SWIG_fail;
27281 }
27282 Py_INCREF(Py_None); resultobj = Py_None;
27283 {
27284 if (temp2)
27285 delete arg2;
27286 }
27287 return resultobj;
27288 fail:
27289 {
27290 if (temp2)
27291 delete arg2;
27292 }
27293 return NULL;
27294 }
27295
27296
27297 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27298 PyObject *obj;
27299 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27300 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27301 Py_INCREF(obj);
27302 return Py_BuildValue((char *)"");
27303 }
27304 static int _wrap_FormatInvalid_set(PyObject *) {
27305 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27306 return 1;
27307 }
27308
27309
27310 static PyObject *_wrap_FormatInvalid_get(void) {
27311 PyObject *pyobj;
27312
27313 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27314 return pyobj;
27315 }
27316
27317
27318 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27319 PyObject *resultobj;
27320 wxDataObject *arg1 = (wxDataObject *) 0 ;
27321 PyObject * obj0 = 0 ;
27322 char *kwnames[] = {
27323 (char *) "self", NULL
27324 };
27325
27326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27328 if (SWIG_arg_fail(1)) SWIG_fail;
27329 {
27330 PyThreadState* __tstate = wxPyBeginAllowThreads();
27331 delete arg1;
27332
27333 wxPyEndAllowThreads(__tstate);
27334 if (PyErr_Occurred()) SWIG_fail;
27335 }
27336 Py_INCREF(Py_None); resultobj = Py_None;
27337 return resultobj;
27338 fail:
27339 return NULL;
27340 }
27341
27342
27343 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27344 PyObject *resultobj;
27345 wxDataObject *arg1 = (wxDataObject *) 0 ;
27346 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27347 SwigValueWrapper<wxDataFormat > result;
27348 PyObject * obj0 = 0 ;
27349 PyObject * obj1 = 0 ;
27350 char *kwnames[] = {
27351 (char *) "self",(char *) "dir", NULL
27352 };
27353
27354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27356 if (SWIG_arg_fail(1)) SWIG_fail;
27357 if (obj1) {
27358 {
27359 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27360 if (SWIG_arg_fail(2)) SWIG_fail;
27361 }
27362 }
27363 {
27364 PyThreadState* __tstate = wxPyBeginAllowThreads();
27365 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27366
27367 wxPyEndAllowThreads(__tstate);
27368 if (PyErr_Occurred()) SWIG_fail;
27369 }
27370 {
27371 wxDataFormat * resultptr;
27372 resultptr = new wxDataFormat((wxDataFormat &)(result));
27373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27374 }
27375 return resultobj;
27376 fail:
27377 return NULL;
27378 }
27379
27380
27381 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27382 PyObject *resultobj;
27383 wxDataObject *arg1 = (wxDataObject *) 0 ;
27384 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27385 size_t result;
27386 PyObject * obj0 = 0 ;
27387 PyObject * obj1 = 0 ;
27388 char *kwnames[] = {
27389 (char *) "self",(char *) "dir", NULL
27390 };
27391
27392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27394 if (SWIG_arg_fail(1)) SWIG_fail;
27395 if (obj1) {
27396 {
27397 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27398 if (SWIG_arg_fail(2)) SWIG_fail;
27399 }
27400 }
27401 {
27402 PyThreadState* __tstate = wxPyBeginAllowThreads();
27403 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27404
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 {
27409 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27410 }
27411 return resultobj;
27412 fail:
27413 return NULL;
27414 }
27415
27416
27417 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27418 PyObject *resultobj;
27419 wxDataObject *arg1 = (wxDataObject *) 0 ;
27420 wxDataFormat *arg2 = 0 ;
27421 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27422 bool result;
27423 PyObject * obj0 = 0 ;
27424 PyObject * obj1 = 0 ;
27425 PyObject * obj2 = 0 ;
27426 char *kwnames[] = {
27427 (char *) "self",(char *) "format",(char *) "dir", NULL
27428 };
27429
27430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27432 if (SWIG_arg_fail(1)) SWIG_fail;
27433 {
27434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27435 if (SWIG_arg_fail(2)) SWIG_fail;
27436 if (arg2 == NULL) {
27437 SWIG_null_ref("wxDataFormat");
27438 }
27439 if (SWIG_arg_fail(2)) SWIG_fail;
27440 }
27441 if (obj2) {
27442 {
27443 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27444 if (SWIG_arg_fail(3)) SWIG_fail;
27445 }
27446 }
27447 {
27448 PyThreadState* __tstate = wxPyBeginAllowThreads();
27449 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27450
27451 wxPyEndAllowThreads(__tstate);
27452 if (PyErr_Occurred()) SWIG_fail;
27453 }
27454 {
27455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27456 }
27457 return resultobj;
27458 fail:
27459 return NULL;
27460 }
27461
27462
27463 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27464 PyObject *resultobj;
27465 wxDataObject *arg1 = (wxDataObject *) 0 ;
27466 wxDataFormat *arg2 = 0 ;
27467 size_t result;
27468 PyObject * obj0 = 0 ;
27469 PyObject * obj1 = 0 ;
27470 char *kwnames[] = {
27471 (char *) "self",(char *) "format", NULL
27472 };
27473
27474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27476 if (SWIG_arg_fail(1)) SWIG_fail;
27477 {
27478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27479 if (SWIG_arg_fail(2)) SWIG_fail;
27480 if (arg2 == NULL) {
27481 SWIG_null_ref("wxDataFormat");
27482 }
27483 if (SWIG_arg_fail(2)) SWIG_fail;
27484 }
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27488
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27502 PyObject *resultobj;
27503 wxDataObject *arg1 = (wxDataObject *) 0 ;
27504 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27505 PyObject *result;
27506 PyObject * obj0 = 0 ;
27507 PyObject * obj1 = 0 ;
27508 char *kwnames[] = {
27509 (char *) "self",(char *) "dir", NULL
27510 };
27511
27512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27514 if (SWIG_arg_fail(1)) SWIG_fail;
27515 if (obj1) {
27516 {
27517 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27518 if (SWIG_arg_fail(2)) SWIG_fail;
27519 }
27520 }
27521 {
27522 PyThreadState* __tstate = wxPyBeginAllowThreads();
27523 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27524
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 resultobj = result;
27529 return resultobj;
27530 fail:
27531 return NULL;
27532 }
27533
27534
27535 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27536 PyObject *resultobj;
27537 wxDataObject *arg1 = (wxDataObject *) 0 ;
27538 wxDataFormat *arg2 = 0 ;
27539 PyObject *result;
27540 PyObject * obj0 = 0 ;
27541 PyObject * obj1 = 0 ;
27542 char *kwnames[] = {
27543 (char *) "self",(char *) "format", NULL
27544 };
27545
27546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27548 if (SWIG_arg_fail(1)) SWIG_fail;
27549 {
27550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27551 if (SWIG_arg_fail(2)) SWIG_fail;
27552 if (arg2 == NULL) {
27553 SWIG_null_ref("wxDataFormat");
27554 }
27555 if (SWIG_arg_fail(2)) SWIG_fail;
27556 }
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27560
27561 wxPyEndAllowThreads(__tstate);
27562 if (PyErr_Occurred()) SWIG_fail;
27563 }
27564 resultobj = result;
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27572 PyObject *resultobj;
27573 wxDataObject *arg1 = (wxDataObject *) 0 ;
27574 wxDataFormat *arg2 = 0 ;
27575 PyObject *arg3 = (PyObject *) 0 ;
27576 bool result;
27577 PyObject * obj0 = 0 ;
27578 PyObject * obj1 = 0 ;
27579 PyObject * obj2 = 0 ;
27580 char *kwnames[] = {
27581 (char *) "self",(char *) "format",(char *) "data", NULL
27582 };
27583
27584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27586 if (SWIG_arg_fail(1)) SWIG_fail;
27587 {
27588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27589 if (SWIG_arg_fail(2)) SWIG_fail;
27590 if (arg2 == NULL) {
27591 SWIG_null_ref("wxDataFormat");
27592 }
27593 if (SWIG_arg_fail(2)) SWIG_fail;
27594 }
27595 arg3 = obj2;
27596 {
27597 PyThreadState* __tstate = wxPyBeginAllowThreads();
27598 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27599
27600 wxPyEndAllowThreads(__tstate);
27601 if (PyErr_Occurred()) SWIG_fail;
27602 }
27603 {
27604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27605 }
27606 return resultobj;
27607 fail:
27608 return NULL;
27609 }
27610
27611
27612 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27613 PyObject *obj;
27614 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27615 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27616 Py_INCREF(obj);
27617 return Py_BuildValue((char *)"");
27618 }
27619 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27620 PyObject *resultobj;
27621 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27622 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27623 wxDataObjectSimple *result;
27624 PyObject * obj0 = 0 ;
27625 char *kwnames[] = {
27626 (char *) "format", NULL
27627 };
27628
27629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27630 if (obj0) {
27631 {
27632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27633 if (SWIG_arg_fail(1)) SWIG_fail;
27634 if (arg1 == NULL) {
27635 SWIG_null_ref("wxDataFormat");
27636 }
27637 if (SWIG_arg_fail(1)) SWIG_fail;
27638 }
27639 }
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27643
27644 wxPyEndAllowThreads(__tstate);
27645 if (PyErr_Occurred()) SWIG_fail;
27646 }
27647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27655 PyObject *resultobj;
27656 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27657 wxDataFormat *result;
27658 PyObject * obj0 = 0 ;
27659 char *kwnames[] = {
27660 (char *) "self", NULL
27661 };
27662
27663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27665 if (SWIG_arg_fail(1)) SWIG_fail;
27666 {
27667 PyThreadState* __tstate = wxPyBeginAllowThreads();
27668 {
27669 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27670 result = (wxDataFormat *) &_result_ref;
27671 }
27672
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27677 return resultobj;
27678 fail:
27679 return NULL;
27680 }
27681
27682
27683 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27684 PyObject *resultobj;
27685 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27686 wxDataFormat *arg2 = 0 ;
27687 PyObject * obj0 = 0 ;
27688 PyObject * obj1 = 0 ;
27689 char *kwnames[] = {
27690 (char *) "self",(char *) "format", NULL
27691 };
27692
27693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27695 if (SWIG_arg_fail(1)) SWIG_fail;
27696 {
27697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27698 if (SWIG_arg_fail(2)) SWIG_fail;
27699 if (arg2 == NULL) {
27700 SWIG_null_ref("wxDataFormat");
27701 }
27702 if (SWIG_arg_fail(2)) SWIG_fail;
27703 }
27704 {
27705 PyThreadState* __tstate = wxPyBeginAllowThreads();
27706 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27707
27708 wxPyEndAllowThreads(__tstate);
27709 if (PyErr_Occurred()) SWIG_fail;
27710 }
27711 Py_INCREF(Py_None); resultobj = Py_None;
27712 return resultobj;
27713 fail:
27714 return NULL;
27715 }
27716
27717
27718 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27719 PyObject *resultobj;
27720 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27721 size_t result;
27722 PyObject * obj0 = 0 ;
27723 char *kwnames[] = {
27724 (char *) "self", NULL
27725 };
27726
27727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27729 if (SWIG_arg_fail(1)) SWIG_fail;
27730 {
27731 PyThreadState* __tstate = wxPyBeginAllowThreads();
27732 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27733
27734 wxPyEndAllowThreads(__tstate);
27735 if (PyErr_Occurred()) SWIG_fail;
27736 }
27737 {
27738 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27739 }
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27747 PyObject *resultobj;
27748 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27749 PyObject *result;
27750 PyObject * obj0 = 0 ;
27751 char *kwnames[] = {
27752 (char *) "self", NULL
27753 };
27754
27755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27757 if (SWIG_arg_fail(1)) SWIG_fail;
27758 {
27759 PyThreadState* __tstate = wxPyBeginAllowThreads();
27760 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27761
27762 wxPyEndAllowThreads(__tstate);
27763 if (PyErr_Occurred()) SWIG_fail;
27764 }
27765 resultobj = result;
27766 return resultobj;
27767 fail:
27768 return NULL;
27769 }
27770
27771
27772 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27773 PyObject *resultobj;
27774 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27775 PyObject *arg2 = (PyObject *) 0 ;
27776 bool result;
27777 PyObject * obj0 = 0 ;
27778 PyObject * obj1 = 0 ;
27779 char *kwnames[] = {
27780 (char *) "self",(char *) "data", NULL
27781 };
27782
27783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27785 if (SWIG_arg_fail(1)) SWIG_fail;
27786 arg2 = obj1;
27787 {
27788 PyThreadState* __tstate = wxPyBeginAllowThreads();
27789 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27790
27791 wxPyEndAllowThreads(__tstate);
27792 if (PyErr_Occurred()) SWIG_fail;
27793 }
27794 {
27795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27796 }
27797 return resultobj;
27798 fail:
27799 return NULL;
27800 }
27801
27802
27803 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27804 PyObject *obj;
27805 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27806 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27807 Py_INCREF(obj);
27808 return Py_BuildValue((char *)"");
27809 }
27810 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27811 PyObject *resultobj;
27812 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27813 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27814 wxPyDataObjectSimple *result;
27815 PyObject * obj0 = 0 ;
27816 char *kwnames[] = {
27817 (char *) "format", NULL
27818 };
27819
27820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27821 if (obj0) {
27822 {
27823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27824 if (SWIG_arg_fail(1)) SWIG_fail;
27825 if (arg1 == NULL) {
27826 SWIG_null_ref("wxDataFormat");
27827 }
27828 if (SWIG_arg_fail(1)) SWIG_fail;
27829 }
27830 }
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27834
27835 wxPyEndAllowThreads(__tstate);
27836 if (PyErr_Occurred()) SWIG_fail;
27837 }
27838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27839 return resultobj;
27840 fail:
27841 return NULL;
27842 }
27843
27844
27845 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27846 PyObject *resultobj;
27847 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27848 PyObject *arg2 = (PyObject *) 0 ;
27849 PyObject *arg3 = (PyObject *) 0 ;
27850 PyObject * obj0 = 0 ;
27851 PyObject * obj1 = 0 ;
27852 PyObject * obj2 = 0 ;
27853 char *kwnames[] = {
27854 (char *) "self",(char *) "self",(char *) "_class", NULL
27855 };
27856
27857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27859 if (SWIG_arg_fail(1)) SWIG_fail;
27860 arg2 = obj1;
27861 arg3 = obj2;
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 (arg1)->_setCallbackInfo(arg2,arg3);
27865
27866 wxPyEndAllowThreads(__tstate);
27867 if (PyErr_Occurred()) SWIG_fail;
27868 }
27869 Py_INCREF(Py_None); resultobj = Py_None;
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27877 PyObject *obj;
27878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27879 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27880 Py_INCREF(obj);
27881 return Py_BuildValue((char *)"");
27882 }
27883 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27884 PyObject *resultobj;
27885 wxDataObjectComposite *result;
27886 char *kwnames[] = {
27887 NULL
27888 };
27889
27890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27891 {
27892 PyThreadState* __tstate = wxPyBeginAllowThreads();
27893 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27894
27895 wxPyEndAllowThreads(__tstate);
27896 if (PyErr_Occurred()) SWIG_fail;
27897 }
27898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27899 return resultobj;
27900 fail:
27901 return NULL;
27902 }
27903
27904
27905 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27906 PyObject *resultobj;
27907 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27908 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27909 bool arg3 = (bool) false ;
27910 PyObject * obj0 = 0 ;
27911 PyObject * obj1 = 0 ;
27912 PyObject * obj2 = 0 ;
27913 char *kwnames[] = {
27914 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27915 };
27916
27917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27919 if (SWIG_arg_fail(1)) SWIG_fail;
27920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27921 if (SWIG_arg_fail(2)) SWIG_fail;
27922 if (obj2) {
27923 {
27924 arg3 = (bool)(SWIG_As_bool(obj2));
27925 if (SWIG_arg_fail(3)) SWIG_fail;
27926 }
27927 }
27928 {
27929 PyThreadState* __tstate = wxPyBeginAllowThreads();
27930 (arg1)->Add(arg2,arg3);
27931
27932 wxPyEndAllowThreads(__tstate);
27933 if (PyErr_Occurred()) SWIG_fail;
27934 }
27935 Py_INCREF(Py_None); resultobj = Py_None;
27936 return resultobj;
27937 fail:
27938 return NULL;
27939 }
27940
27941
27942 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27943 PyObject *obj;
27944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27945 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27946 Py_INCREF(obj);
27947 return Py_BuildValue((char *)"");
27948 }
27949 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj;
27951 wxString const &arg1_defvalue = wxPyEmptyString ;
27952 wxString *arg1 = (wxString *) &arg1_defvalue ;
27953 wxTextDataObject *result;
27954 bool temp1 = false ;
27955 PyObject * obj0 = 0 ;
27956 char *kwnames[] = {
27957 (char *) "text", NULL
27958 };
27959
27960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27961 if (obj0) {
27962 {
27963 arg1 = wxString_in_helper(obj0);
27964 if (arg1 == NULL) SWIG_fail;
27965 temp1 = true;
27966 }
27967 }
27968 {
27969 PyThreadState* __tstate = wxPyBeginAllowThreads();
27970 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27971
27972 wxPyEndAllowThreads(__tstate);
27973 if (PyErr_Occurred()) SWIG_fail;
27974 }
27975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27976 {
27977 if (temp1)
27978 delete arg1;
27979 }
27980 return resultobj;
27981 fail:
27982 {
27983 if (temp1)
27984 delete arg1;
27985 }
27986 return NULL;
27987 }
27988
27989
27990 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27991 PyObject *resultobj;
27992 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27993 size_t result;
27994 PyObject * obj0 = 0 ;
27995 char *kwnames[] = {
27996 (char *) "self", NULL
27997 };
27998
27999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
28000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28001 if (SWIG_arg_fail(1)) SWIG_fail;
28002 {
28003 PyThreadState* __tstate = wxPyBeginAllowThreads();
28004 result = (size_t)(arg1)->GetTextLength();
28005
28006 wxPyEndAllowThreads(__tstate);
28007 if (PyErr_Occurred()) SWIG_fail;
28008 }
28009 {
28010 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28011 }
28012 return resultobj;
28013 fail:
28014 return NULL;
28015 }
28016
28017
28018 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
28019 PyObject *resultobj;
28020 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28021 wxString result;
28022 PyObject * obj0 = 0 ;
28023 char *kwnames[] = {
28024 (char *) "self", NULL
28025 };
28026
28027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
28028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28029 if (SWIG_arg_fail(1)) SWIG_fail;
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 result = (arg1)->GetText();
28033
28034 wxPyEndAllowThreads(__tstate);
28035 if (PyErr_Occurred()) SWIG_fail;
28036 }
28037 {
28038 #if wxUSE_UNICODE
28039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28040 #else
28041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28042 #endif
28043 }
28044 return resultobj;
28045 fail:
28046 return NULL;
28047 }
28048
28049
28050 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
28051 PyObject *resultobj;
28052 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28053 wxString *arg2 = 0 ;
28054 bool temp2 = false ;
28055 PyObject * obj0 = 0 ;
28056 PyObject * obj1 = 0 ;
28057 char *kwnames[] = {
28058 (char *) "self",(char *) "text", NULL
28059 };
28060
28061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
28062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28063 if (SWIG_arg_fail(1)) SWIG_fail;
28064 {
28065 arg2 = wxString_in_helper(obj1);
28066 if (arg2 == NULL) SWIG_fail;
28067 temp2 = true;
28068 }
28069 {
28070 PyThreadState* __tstate = wxPyBeginAllowThreads();
28071 (arg1)->SetText((wxString const &)*arg2);
28072
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 Py_INCREF(Py_None); resultobj = Py_None;
28077 {
28078 if (temp2)
28079 delete arg2;
28080 }
28081 return resultobj;
28082 fail:
28083 {
28084 if (temp2)
28085 delete arg2;
28086 }
28087 return NULL;
28088 }
28089
28090
28091 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
28092 PyObject *obj;
28093 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28094 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
28095 Py_INCREF(obj);
28096 return Py_BuildValue((char *)"");
28097 }
28098 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28099 PyObject *resultobj;
28100 wxString const &arg1_defvalue = wxPyEmptyString ;
28101 wxString *arg1 = (wxString *) &arg1_defvalue ;
28102 wxPyTextDataObject *result;
28103 bool temp1 = false ;
28104 PyObject * obj0 = 0 ;
28105 char *kwnames[] = {
28106 (char *) "text", NULL
28107 };
28108
28109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
28110 if (obj0) {
28111 {
28112 arg1 = wxString_in_helper(obj0);
28113 if (arg1 == NULL) SWIG_fail;
28114 temp1 = true;
28115 }
28116 }
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
28120
28121 wxPyEndAllowThreads(__tstate);
28122 if (PyErr_Occurred()) SWIG_fail;
28123 }
28124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
28125 {
28126 if (temp1)
28127 delete arg1;
28128 }
28129 return resultobj;
28130 fail:
28131 {
28132 if (temp1)
28133 delete arg1;
28134 }
28135 return NULL;
28136 }
28137
28138
28139 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28140 PyObject *resultobj;
28141 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
28142 PyObject *arg2 = (PyObject *) 0 ;
28143 PyObject *arg3 = (PyObject *) 0 ;
28144 PyObject * obj0 = 0 ;
28145 PyObject * obj1 = 0 ;
28146 PyObject * obj2 = 0 ;
28147 char *kwnames[] = {
28148 (char *) "self",(char *) "self",(char *) "_class", NULL
28149 };
28150
28151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28153 if (SWIG_arg_fail(1)) SWIG_fail;
28154 arg2 = obj1;
28155 arg3 = obj2;
28156 {
28157 PyThreadState* __tstate = wxPyBeginAllowThreads();
28158 (arg1)->_setCallbackInfo(arg2,arg3);
28159
28160 wxPyEndAllowThreads(__tstate);
28161 if (PyErr_Occurred()) SWIG_fail;
28162 }
28163 Py_INCREF(Py_None); resultobj = Py_None;
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
28171 PyObject *obj;
28172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28173 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
28174 Py_INCREF(obj);
28175 return Py_BuildValue((char *)"");
28176 }
28177 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj;
28179 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28180 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28181 wxBitmapDataObject *result;
28182 PyObject * obj0 = 0 ;
28183 char *kwnames[] = {
28184 (char *) "bitmap", NULL
28185 };
28186
28187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
28188 if (obj0) {
28189 {
28190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28191 if (SWIG_arg_fail(1)) SWIG_fail;
28192 if (arg1 == NULL) {
28193 SWIG_null_ref("wxBitmap");
28194 }
28195 if (SWIG_arg_fail(1)) SWIG_fail;
28196 }
28197 }
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
28201
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
28206 return resultobj;
28207 fail:
28208 return NULL;
28209 }
28210
28211
28212 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28213 PyObject *resultobj;
28214 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28215 wxBitmap result;
28216 PyObject * obj0 = 0 ;
28217 char *kwnames[] = {
28218 (char *) "self", NULL
28219 };
28220
28221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
28222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28223 if (SWIG_arg_fail(1)) SWIG_fail;
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
28227
28228 wxPyEndAllowThreads(__tstate);
28229 if (PyErr_Occurred()) SWIG_fail;
28230 }
28231 {
28232 wxBitmap * resultptr;
28233 resultptr = new wxBitmap((wxBitmap &)(result));
28234 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
28235 }
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28243 PyObject *resultobj;
28244 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28245 wxBitmap *arg2 = 0 ;
28246 PyObject * obj0 = 0 ;
28247 PyObject * obj1 = 0 ;
28248 char *kwnames[] = {
28249 (char *) "self",(char *) "bitmap", NULL
28250 };
28251
28252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28254 if (SWIG_arg_fail(1)) SWIG_fail;
28255 {
28256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28257 if (SWIG_arg_fail(2)) SWIG_fail;
28258 if (arg2 == NULL) {
28259 SWIG_null_ref("wxBitmap");
28260 }
28261 if (SWIG_arg_fail(2)) SWIG_fail;
28262 }
28263 {
28264 PyThreadState* __tstate = wxPyBeginAllowThreads();
28265 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28266
28267 wxPyEndAllowThreads(__tstate);
28268 if (PyErr_Occurred()) SWIG_fail;
28269 }
28270 Py_INCREF(Py_None); resultobj = Py_None;
28271 return resultobj;
28272 fail:
28273 return NULL;
28274 }
28275
28276
28277 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28278 PyObject *obj;
28279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28280 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28281 Py_INCREF(obj);
28282 return Py_BuildValue((char *)"");
28283 }
28284 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28285 PyObject *resultobj;
28286 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28287 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28288 wxPyBitmapDataObject *result;
28289 PyObject * obj0 = 0 ;
28290 char *kwnames[] = {
28291 (char *) "bitmap", NULL
28292 };
28293
28294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28295 if (obj0) {
28296 {
28297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28298 if (SWIG_arg_fail(1)) SWIG_fail;
28299 if (arg1 == NULL) {
28300 SWIG_null_ref("wxBitmap");
28301 }
28302 if (SWIG_arg_fail(1)) SWIG_fail;
28303 }
28304 }
28305 {
28306 PyThreadState* __tstate = wxPyBeginAllowThreads();
28307 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28308
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28313 return resultobj;
28314 fail:
28315 return NULL;
28316 }
28317
28318
28319 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28320 PyObject *resultobj;
28321 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28322 PyObject *arg2 = (PyObject *) 0 ;
28323 PyObject *arg3 = (PyObject *) 0 ;
28324 PyObject * obj0 = 0 ;
28325 PyObject * obj1 = 0 ;
28326 PyObject * obj2 = 0 ;
28327 char *kwnames[] = {
28328 (char *) "self",(char *) "self",(char *) "_class", NULL
28329 };
28330
28331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28333 if (SWIG_arg_fail(1)) SWIG_fail;
28334 arg2 = obj1;
28335 arg3 = obj2;
28336 {
28337 PyThreadState* __tstate = wxPyBeginAllowThreads();
28338 (arg1)->_setCallbackInfo(arg2,arg3);
28339
28340 wxPyEndAllowThreads(__tstate);
28341 if (PyErr_Occurred()) SWIG_fail;
28342 }
28343 Py_INCREF(Py_None); resultobj = Py_None;
28344 return resultobj;
28345 fail:
28346 return NULL;
28347 }
28348
28349
28350 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28351 PyObject *obj;
28352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28353 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28354 Py_INCREF(obj);
28355 return Py_BuildValue((char *)"");
28356 }
28357 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28358 PyObject *resultobj;
28359 wxFileDataObject *result;
28360 char *kwnames[] = {
28361 NULL
28362 };
28363
28364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 result = (wxFileDataObject *)new wxFileDataObject();
28368
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28373 return resultobj;
28374 fail:
28375 return NULL;
28376 }
28377
28378
28379 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28380 PyObject *resultobj;
28381 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28382 wxArrayString *result;
28383 PyObject * obj0 = 0 ;
28384 char *kwnames[] = {
28385 (char *) "self", NULL
28386 };
28387
28388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28390 if (SWIG_arg_fail(1)) SWIG_fail;
28391 {
28392 PyThreadState* __tstate = wxPyBeginAllowThreads();
28393 {
28394 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28395 result = (wxArrayString *) &_result_ref;
28396 }
28397
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 {
28402 resultobj = wxArrayString2PyList_helper(*result);
28403 }
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28411 PyObject *resultobj;
28412 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28413 wxString *arg2 = 0 ;
28414 bool temp2 = false ;
28415 PyObject * obj0 = 0 ;
28416 PyObject * obj1 = 0 ;
28417 char *kwnames[] = {
28418 (char *) "self",(char *) "filename", NULL
28419 };
28420
28421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28423 if (SWIG_arg_fail(1)) SWIG_fail;
28424 {
28425 arg2 = wxString_in_helper(obj1);
28426 if (arg2 == NULL) SWIG_fail;
28427 temp2 = true;
28428 }
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 (arg1)->AddFile((wxString const &)*arg2);
28432
28433 wxPyEndAllowThreads(__tstate);
28434 if (PyErr_Occurred()) SWIG_fail;
28435 }
28436 Py_INCREF(Py_None); resultobj = Py_None;
28437 {
28438 if (temp2)
28439 delete arg2;
28440 }
28441 return resultobj;
28442 fail:
28443 {
28444 if (temp2)
28445 delete arg2;
28446 }
28447 return NULL;
28448 }
28449
28450
28451 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28452 PyObject *obj;
28453 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28454 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28455 Py_INCREF(obj);
28456 return Py_BuildValue((char *)"");
28457 }
28458 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28459 PyObject *resultobj;
28460 wxDataFormat *arg1 = 0 ;
28461 wxCustomDataObject *result;
28462 PyObject * obj0 = 0 ;
28463
28464 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28465 {
28466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28467 if (SWIG_arg_fail(1)) SWIG_fail;
28468 if (arg1 == NULL) {
28469 SWIG_null_ref("wxDataFormat");
28470 }
28471 if (SWIG_arg_fail(1)) SWIG_fail;
28472 }
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28476
28477 wxPyEndAllowThreads(__tstate);
28478 if (PyErr_Occurred()) SWIG_fail;
28479 }
28480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28481 return resultobj;
28482 fail:
28483 return NULL;
28484 }
28485
28486
28487 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28488 PyObject *resultobj;
28489 wxString *arg1 = 0 ;
28490 wxCustomDataObject *result;
28491 bool temp1 = false ;
28492 PyObject * obj0 = 0 ;
28493
28494 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28495 {
28496 arg1 = wxString_in_helper(obj0);
28497 if (arg1 == NULL) SWIG_fail;
28498 temp1 = true;
28499 }
28500 {
28501 PyThreadState* __tstate = wxPyBeginAllowThreads();
28502 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28503
28504 wxPyEndAllowThreads(__tstate);
28505 if (PyErr_Occurred()) SWIG_fail;
28506 }
28507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28508 {
28509 if (temp1)
28510 delete arg1;
28511 }
28512 return resultobj;
28513 fail:
28514 {
28515 if (temp1)
28516 delete arg1;
28517 }
28518 return NULL;
28519 }
28520
28521
28522 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28523 PyObject *resultobj;
28524 wxCustomDataObject *result;
28525
28526 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28527 {
28528 PyThreadState* __tstate = wxPyBeginAllowThreads();
28529 result = (wxCustomDataObject *)new wxCustomDataObject();
28530
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28542 int argc;
28543 PyObject *argv[2];
28544 int ii;
28545
28546 argc = PyObject_Length(args);
28547 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28548 argv[ii] = PyTuple_GetItem(args,ii);
28549 }
28550 if (argc == 0) {
28551 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28552 }
28553 if (argc == 1) {
28554 int _v;
28555 {
28556 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28557 }
28558 if (_v) {
28559 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28560 }
28561 }
28562 if (argc == 1) {
28563 int _v;
28564 {
28565 void *ptr = 0;
28566 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28567 _v = 0;
28568 PyErr_Clear();
28569 } else {
28570 _v = (ptr != 0);
28571 }
28572 }
28573 if (_v) {
28574 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28575 }
28576 }
28577
28578 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28579 return NULL;
28580 }
28581
28582
28583 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28584 PyObject *resultobj;
28585 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28586 PyObject *arg2 = (PyObject *) 0 ;
28587 bool result;
28588 PyObject * obj0 = 0 ;
28589 PyObject * obj1 = 0 ;
28590 char *kwnames[] = {
28591 (char *) "self",(char *) "data", NULL
28592 };
28593
28594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28596 if (SWIG_arg_fail(1)) SWIG_fail;
28597 arg2 = obj1;
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28601
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 {
28606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28607 }
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj;
28616 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28617 size_t result;
28618 PyObject * obj0 = 0 ;
28619 char *kwnames[] = {
28620 (char *) "self", NULL
28621 };
28622
28623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28625 if (SWIG_arg_fail(1)) SWIG_fail;
28626 {
28627 PyThreadState* __tstate = wxPyBeginAllowThreads();
28628 result = (size_t)(arg1)->GetSize();
28629
28630 wxPyEndAllowThreads(__tstate);
28631 if (PyErr_Occurred()) SWIG_fail;
28632 }
28633 {
28634 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28635 }
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28643 PyObject *resultobj;
28644 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28645 PyObject *result;
28646 PyObject * obj0 = 0 ;
28647 char *kwnames[] = {
28648 (char *) "self", NULL
28649 };
28650
28651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28653 if (SWIG_arg_fail(1)) SWIG_fail;
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28657
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 resultobj = result;
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28669 PyObject *obj;
28670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28671 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28672 Py_INCREF(obj);
28673 return Py_BuildValue((char *)"");
28674 }
28675 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28676 PyObject *resultobj;
28677 wxURLDataObject *result;
28678 char *kwnames[] = {
28679 NULL
28680 };
28681
28682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 result = (wxURLDataObject *)new wxURLDataObject();
28686
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28691 return resultobj;
28692 fail:
28693 return NULL;
28694 }
28695
28696
28697 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28698 PyObject *resultobj;
28699 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28700 wxString result;
28701 PyObject * obj0 = 0 ;
28702 char *kwnames[] = {
28703 (char *) "self", NULL
28704 };
28705
28706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28708 if (SWIG_arg_fail(1)) SWIG_fail;
28709 {
28710 PyThreadState* __tstate = wxPyBeginAllowThreads();
28711 result = (arg1)->GetURL();
28712
28713 wxPyEndAllowThreads(__tstate);
28714 if (PyErr_Occurred()) SWIG_fail;
28715 }
28716 {
28717 #if wxUSE_UNICODE
28718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28719 #else
28720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28721 #endif
28722 }
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28730 PyObject *resultobj;
28731 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28732 wxString *arg2 = 0 ;
28733 bool temp2 = false ;
28734 PyObject * obj0 = 0 ;
28735 PyObject * obj1 = 0 ;
28736 char *kwnames[] = {
28737 (char *) "self",(char *) "url", NULL
28738 };
28739
28740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28742 if (SWIG_arg_fail(1)) SWIG_fail;
28743 {
28744 arg2 = wxString_in_helper(obj1);
28745 if (arg2 == NULL) SWIG_fail;
28746 temp2 = true;
28747 }
28748 {
28749 PyThreadState* __tstate = wxPyBeginAllowThreads();
28750 (arg1)->SetURL((wxString const &)*arg2);
28751
28752 wxPyEndAllowThreads(__tstate);
28753 if (PyErr_Occurred()) SWIG_fail;
28754 }
28755 Py_INCREF(Py_None); resultobj = Py_None;
28756 {
28757 if (temp2)
28758 delete arg2;
28759 }
28760 return resultobj;
28761 fail:
28762 {
28763 if (temp2)
28764 delete arg2;
28765 }
28766 return NULL;
28767 }
28768
28769
28770 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28771 PyObject *obj;
28772 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28773 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28774 Py_INCREF(obj);
28775 return Py_BuildValue((char *)"");
28776 }
28777 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28778 PyObject *resultobj;
28779 wxMetafileDataObject *result;
28780 char *kwnames[] = {
28781 NULL
28782 };
28783
28784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28785 {
28786 PyThreadState* __tstate = wxPyBeginAllowThreads();
28787 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28788
28789 wxPyEndAllowThreads(__tstate);
28790 if (PyErr_Occurred()) SWIG_fail;
28791 }
28792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28793 return resultobj;
28794 fail:
28795 return NULL;
28796 }
28797
28798
28799 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28800 PyObject *resultobj;
28801 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28802 wxMetafile *arg2 = 0 ;
28803 PyObject * obj0 = 0 ;
28804 PyObject * obj1 = 0 ;
28805 char *kwnames[] = {
28806 (char *) "self",(char *) "metafile", NULL
28807 };
28808
28809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28811 if (SWIG_arg_fail(1)) SWIG_fail;
28812 {
28813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28814 if (SWIG_arg_fail(2)) SWIG_fail;
28815 if (arg2 == NULL) {
28816 SWIG_null_ref("wxMetafile");
28817 }
28818 if (SWIG_arg_fail(2)) SWIG_fail;
28819 }
28820 {
28821 PyThreadState* __tstate = wxPyBeginAllowThreads();
28822 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28823
28824 wxPyEndAllowThreads(__tstate);
28825 if (PyErr_Occurred()) SWIG_fail;
28826 }
28827 Py_INCREF(Py_None); resultobj = Py_None;
28828 return resultobj;
28829 fail:
28830 return NULL;
28831 }
28832
28833
28834 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28835 PyObject *resultobj;
28836 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28837 wxMetafile result;
28838 PyObject * obj0 = 0 ;
28839 char *kwnames[] = {
28840 (char *) "self", NULL
28841 };
28842
28843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28845 if (SWIG_arg_fail(1)) SWIG_fail;
28846 {
28847 PyThreadState* __tstate = wxPyBeginAllowThreads();
28848 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28849
28850 wxPyEndAllowThreads(__tstate);
28851 if (PyErr_Occurred()) SWIG_fail;
28852 }
28853 {
28854 wxMetafile * resultptr;
28855 resultptr = new wxMetafile((wxMetafile &)(result));
28856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28857 }
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28865 PyObject *obj;
28866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28867 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28868 Py_INCREF(obj);
28869 return Py_BuildValue((char *)"");
28870 }
28871 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28872 PyObject *resultobj;
28873 wxDragResult arg1 ;
28874 bool result;
28875 PyObject * obj0 = 0 ;
28876 char *kwnames[] = {
28877 (char *) "res", NULL
28878 };
28879
28880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28881 {
28882 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28883 if (SWIG_arg_fail(1)) SWIG_fail;
28884 }
28885 {
28886 PyThreadState* __tstate = wxPyBeginAllowThreads();
28887 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28888
28889 wxPyEndAllowThreads(__tstate);
28890 if (PyErr_Occurred()) SWIG_fail;
28891 }
28892 {
28893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28894 }
28895 return resultobj;
28896 fail:
28897 return NULL;
28898 }
28899
28900
28901 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28902 PyObject *resultobj;
28903 wxWindow *arg1 = (wxWindow *) 0 ;
28904 wxCursor const &arg2_defvalue = wxNullCursor ;
28905 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28906 wxCursor const &arg3_defvalue = wxNullCursor ;
28907 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28908 wxCursor const &arg4_defvalue = wxNullCursor ;
28909 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28910 wxPyDropSource *result;
28911 PyObject * obj0 = 0 ;
28912 PyObject * obj1 = 0 ;
28913 PyObject * obj2 = 0 ;
28914 PyObject * obj3 = 0 ;
28915 char *kwnames[] = {
28916 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28917 };
28918
28919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28921 if (SWIG_arg_fail(1)) SWIG_fail;
28922 if (obj1) {
28923 {
28924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28925 if (SWIG_arg_fail(2)) SWIG_fail;
28926 if (arg2 == NULL) {
28927 SWIG_null_ref("wxCursor");
28928 }
28929 if (SWIG_arg_fail(2)) SWIG_fail;
28930 }
28931 }
28932 if (obj2) {
28933 {
28934 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28935 if (SWIG_arg_fail(3)) SWIG_fail;
28936 if (arg3 == NULL) {
28937 SWIG_null_ref("wxCursor");
28938 }
28939 if (SWIG_arg_fail(3)) SWIG_fail;
28940 }
28941 }
28942 if (obj3) {
28943 {
28944 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28945 if (SWIG_arg_fail(4)) SWIG_fail;
28946 if (arg4 == NULL) {
28947 SWIG_null_ref("wxCursor");
28948 }
28949 if (SWIG_arg_fail(4)) SWIG_fail;
28950 }
28951 }
28952 {
28953 PyThreadState* __tstate = wxPyBeginAllowThreads();
28954 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28955
28956 wxPyEndAllowThreads(__tstate);
28957 if (PyErr_Occurred()) SWIG_fail;
28958 }
28959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28960 return resultobj;
28961 fail:
28962 return NULL;
28963 }
28964
28965
28966 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28967 PyObject *resultobj;
28968 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28969 PyObject *arg2 = (PyObject *) 0 ;
28970 PyObject *arg3 = (PyObject *) 0 ;
28971 int arg4 ;
28972 PyObject * obj0 = 0 ;
28973 PyObject * obj1 = 0 ;
28974 PyObject * obj2 = 0 ;
28975 PyObject * obj3 = 0 ;
28976 char *kwnames[] = {
28977 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28978 };
28979
28980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28982 if (SWIG_arg_fail(1)) SWIG_fail;
28983 arg2 = obj1;
28984 arg3 = obj2;
28985 {
28986 arg4 = (int)(SWIG_As_int(obj3));
28987 if (SWIG_arg_fail(4)) SWIG_fail;
28988 }
28989 {
28990 PyThreadState* __tstate = wxPyBeginAllowThreads();
28991 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28992
28993 wxPyEndAllowThreads(__tstate);
28994 if (PyErr_Occurred()) SWIG_fail;
28995 }
28996 Py_INCREF(Py_None); resultobj = Py_None;
28997 return resultobj;
28998 fail:
28999 return NULL;
29000 }
29001
29002
29003 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
29004 PyObject *resultobj;
29005 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29006 PyObject * obj0 = 0 ;
29007 char *kwnames[] = {
29008 (char *) "self", NULL
29009 };
29010
29011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
29012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29013 if (SWIG_arg_fail(1)) SWIG_fail;
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 delete arg1;
29017
29018 wxPyEndAllowThreads(__tstate);
29019 if (PyErr_Occurred()) SWIG_fail;
29020 }
29021 Py_INCREF(Py_None); resultobj = Py_None;
29022 return resultobj;
29023 fail:
29024 return NULL;
29025 }
29026
29027
29028 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29029 PyObject *resultobj;
29030 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29031 wxDataObject *arg2 = 0 ;
29032 PyObject * obj0 = 0 ;
29033 PyObject * obj1 = 0 ;
29034 char *kwnames[] = {
29035 (char *) "self",(char *) "data", NULL
29036 };
29037
29038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
29039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29040 if (SWIG_arg_fail(1)) SWIG_fail;
29041 {
29042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29043 if (SWIG_arg_fail(2)) SWIG_fail;
29044 if (arg2 == NULL) {
29045 SWIG_null_ref("wxDataObject");
29046 }
29047 if (SWIG_arg_fail(2)) SWIG_fail;
29048 }
29049 {
29050 PyThreadState* __tstate = wxPyBeginAllowThreads();
29051 (arg1)->SetData(*arg2);
29052
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 Py_INCREF(Py_None); resultobj = Py_None;
29057 return resultobj;
29058 fail:
29059 return NULL;
29060 }
29061
29062
29063 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29064 PyObject *resultobj;
29065 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29066 wxDataObject *result;
29067 PyObject * obj0 = 0 ;
29068 char *kwnames[] = {
29069 (char *) "self", NULL
29070 };
29071
29072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
29073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29074 if (SWIG_arg_fail(1)) SWIG_fail;
29075 {
29076 PyThreadState* __tstate = wxPyBeginAllowThreads();
29077 result = (wxDataObject *)(arg1)->GetDataObject();
29078
29079 wxPyEndAllowThreads(__tstate);
29080 if (PyErr_Occurred()) SWIG_fail;
29081 }
29082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29083 return resultobj;
29084 fail:
29085 return NULL;
29086 }
29087
29088
29089 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29090 PyObject *resultobj;
29091 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29092 wxDragResult arg2 ;
29093 wxCursor *arg3 = 0 ;
29094 PyObject * obj0 = 0 ;
29095 PyObject * obj1 = 0 ;
29096 PyObject * obj2 = 0 ;
29097 char *kwnames[] = {
29098 (char *) "self",(char *) "res",(char *) "cursor", NULL
29099 };
29100
29101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
29102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29103 if (SWIG_arg_fail(1)) SWIG_fail;
29104 {
29105 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29106 if (SWIG_arg_fail(2)) SWIG_fail;
29107 }
29108 {
29109 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29110 if (SWIG_arg_fail(3)) SWIG_fail;
29111 if (arg3 == NULL) {
29112 SWIG_null_ref("wxCursor");
29113 }
29114 if (SWIG_arg_fail(3)) SWIG_fail;
29115 }
29116 {
29117 PyThreadState* __tstate = wxPyBeginAllowThreads();
29118 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
29119
29120 wxPyEndAllowThreads(__tstate);
29121 if (PyErr_Occurred()) SWIG_fail;
29122 }
29123 Py_INCREF(Py_None); resultobj = Py_None;
29124 return resultobj;
29125 fail:
29126 return NULL;
29127 }
29128
29129
29130 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29131 PyObject *resultobj;
29132 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29133 int arg2 = (int) wxDrag_CopyOnly ;
29134 wxDragResult result;
29135 PyObject * obj0 = 0 ;
29136 PyObject * obj1 = 0 ;
29137 char *kwnames[] = {
29138 (char *) "self",(char *) "flags", NULL
29139 };
29140
29141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
29142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29143 if (SWIG_arg_fail(1)) SWIG_fail;
29144 if (obj1) {
29145 {
29146 arg2 = (int)(SWIG_As_int(obj1));
29147 if (SWIG_arg_fail(2)) SWIG_fail;
29148 }
29149 }
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
29153
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 resultobj = SWIG_From_int((result));
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
29165 PyObject *resultobj;
29166 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29167 wxDragResult arg2 ;
29168 bool result;
29169 PyObject * obj0 = 0 ;
29170 PyObject * obj1 = 0 ;
29171 char *kwnames[] = {
29172 (char *) "self",(char *) "effect", NULL
29173 };
29174
29175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
29176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29177 if (SWIG_arg_fail(1)) SWIG_fail;
29178 {
29179 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29180 if (SWIG_arg_fail(2)) SWIG_fail;
29181 }
29182 {
29183 PyThreadState* __tstate = wxPyBeginAllowThreads();
29184 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
29185
29186 wxPyEndAllowThreads(__tstate);
29187 if (PyErr_Occurred()) SWIG_fail;
29188 }
29189 {
29190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29191 }
29192 return resultobj;
29193 fail:
29194 return NULL;
29195 }
29196
29197
29198 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
29199 PyObject *obj;
29200 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29201 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
29202 Py_INCREF(obj);
29203 return Py_BuildValue((char *)"");
29204 }
29205 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29206 PyObject *resultobj;
29207 wxDataObject *arg1 = (wxDataObject *) NULL ;
29208 wxPyDropTarget *result;
29209 PyObject * obj0 = 0 ;
29210 char *kwnames[] = {
29211 (char *) "dataObject", NULL
29212 };
29213
29214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
29215 if (obj0) {
29216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29217 if (SWIG_arg_fail(1)) SWIG_fail;
29218 }
29219 {
29220 PyThreadState* __tstate = wxPyBeginAllowThreads();
29221 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
29222
29223 wxPyEndAllowThreads(__tstate);
29224 if (PyErr_Occurred()) SWIG_fail;
29225 }
29226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
29227 return resultobj;
29228 fail:
29229 return NULL;
29230 }
29231
29232
29233 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29234 PyObject *resultobj;
29235 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29236 PyObject *arg2 = (PyObject *) 0 ;
29237 PyObject *arg3 = (PyObject *) 0 ;
29238 PyObject * obj0 = 0 ;
29239 PyObject * obj1 = 0 ;
29240 PyObject * obj2 = 0 ;
29241 char *kwnames[] = {
29242 (char *) "self",(char *) "self",(char *) "_class", NULL
29243 };
29244
29245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29247 if (SWIG_arg_fail(1)) SWIG_fail;
29248 arg2 = obj1;
29249 arg3 = obj2;
29250 {
29251 PyThreadState* __tstate = wxPyBeginAllowThreads();
29252 (arg1)->_setCallbackInfo(arg2,arg3);
29253
29254 wxPyEndAllowThreads(__tstate);
29255 if (PyErr_Occurred()) SWIG_fail;
29256 }
29257 Py_INCREF(Py_None); resultobj = Py_None;
29258 return resultobj;
29259 fail:
29260 return NULL;
29261 }
29262
29263
29264 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29265 PyObject *resultobj;
29266 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29267 PyObject * obj0 = 0 ;
29268 char *kwnames[] = {
29269 (char *) "self", NULL
29270 };
29271
29272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
29273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29274 if (SWIG_arg_fail(1)) SWIG_fail;
29275 {
29276 PyThreadState* __tstate = wxPyBeginAllowThreads();
29277 delete arg1;
29278
29279 wxPyEndAllowThreads(__tstate);
29280 if (PyErr_Occurred()) SWIG_fail;
29281 }
29282 Py_INCREF(Py_None); resultobj = Py_None;
29283 return resultobj;
29284 fail:
29285 return NULL;
29286 }
29287
29288
29289 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29290 PyObject *resultobj;
29291 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29292 wxDataObject *result;
29293 PyObject * obj0 = 0 ;
29294 char *kwnames[] = {
29295 (char *) "self", NULL
29296 };
29297
29298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29300 if (SWIG_arg_fail(1)) SWIG_fail;
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 result = (wxDataObject *)(arg1)->GetDataObject();
29304
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29316 PyObject *resultobj;
29317 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29318 wxDataObject *arg2 = (wxDataObject *) 0 ;
29319 PyObject * obj0 = 0 ;
29320 PyObject * obj1 = 0 ;
29321 char *kwnames[] = {
29322 (char *) "self",(char *) "dataObject", NULL
29323 };
29324
29325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29327 if (SWIG_arg_fail(1)) SWIG_fail;
29328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29329 if (SWIG_arg_fail(2)) SWIG_fail;
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 (arg1)->SetDataObject(arg2);
29333
29334 wxPyEndAllowThreads(__tstate);
29335 if (PyErr_Occurred()) SWIG_fail;
29336 }
29337 Py_INCREF(Py_None); resultobj = Py_None;
29338 return resultobj;
29339 fail:
29340 return NULL;
29341 }
29342
29343
29344 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29345 PyObject *resultobj;
29346 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29347 int arg2 ;
29348 int arg3 ;
29349 wxDragResult arg4 ;
29350 wxDragResult result;
29351 PyObject * obj0 = 0 ;
29352 PyObject * obj1 = 0 ;
29353 PyObject * obj2 = 0 ;
29354 PyObject * obj3 = 0 ;
29355 char *kwnames[] = {
29356 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29357 };
29358
29359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29361 if (SWIG_arg_fail(1)) SWIG_fail;
29362 {
29363 arg2 = (int)(SWIG_As_int(obj1));
29364 if (SWIG_arg_fail(2)) SWIG_fail;
29365 }
29366 {
29367 arg3 = (int)(SWIG_As_int(obj2));
29368 if (SWIG_arg_fail(3)) SWIG_fail;
29369 }
29370 {
29371 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29372 if (SWIG_arg_fail(4)) SWIG_fail;
29373 }
29374 {
29375 PyThreadState* __tstate = wxPyBeginAllowThreads();
29376 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29377
29378 wxPyEndAllowThreads(__tstate);
29379 if (PyErr_Occurred()) SWIG_fail;
29380 }
29381 resultobj = SWIG_From_int((result));
29382 return resultobj;
29383 fail:
29384 return NULL;
29385 }
29386
29387
29388 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29389 PyObject *resultobj;
29390 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29391 int arg2 ;
29392 int arg3 ;
29393 wxDragResult arg4 ;
29394 wxDragResult result;
29395 PyObject * obj0 = 0 ;
29396 PyObject * obj1 = 0 ;
29397 PyObject * obj2 = 0 ;
29398 PyObject * obj3 = 0 ;
29399 char *kwnames[] = {
29400 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29401 };
29402
29403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29405 if (SWIG_arg_fail(1)) SWIG_fail;
29406 {
29407 arg2 = (int)(SWIG_As_int(obj1));
29408 if (SWIG_arg_fail(2)) SWIG_fail;
29409 }
29410 {
29411 arg3 = (int)(SWIG_As_int(obj2));
29412 if (SWIG_arg_fail(3)) SWIG_fail;
29413 }
29414 {
29415 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29416 if (SWIG_arg_fail(4)) SWIG_fail;
29417 }
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29421
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 resultobj = SWIG_From_int((result));
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29433 PyObject *resultobj;
29434 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29435 PyObject * obj0 = 0 ;
29436 char *kwnames[] = {
29437 (char *) "self", NULL
29438 };
29439
29440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29442 if (SWIG_arg_fail(1)) SWIG_fail;
29443 {
29444 PyThreadState* __tstate = wxPyBeginAllowThreads();
29445 (arg1)->base_OnLeave();
29446
29447 wxPyEndAllowThreads(__tstate);
29448 if (PyErr_Occurred()) SWIG_fail;
29449 }
29450 Py_INCREF(Py_None); resultobj = Py_None;
29451 return resultobj;
29452 fail:
29453 return NULL;
29454 }
29455
29456
29457 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29458 PyObject *resultobj;
29459 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29460 int arg2 ;
29461 int arg3 ;
29462 bool result;
29463 PyObject * obj0 = 0 ;
29464 PyObject * obj1 = 0 ;
29465 PyObject * obj2 = 0 ;
29466 char *kwnames[] = {
29467 (char *) "self",(char *) "x",(char *) "y", NULL
29468 };
29469
29470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29472 if (SWIG_arg_fail(1)) SWIG_fail;
29473 {
29474 arg2 = (int)(SWIG_As_int(obj1));
29475 if (SWIG_arg_fail(2)) SWIG_fail;
29476 }
29477 {
29478 arg3 = (int)(SWIG_As_int(obj2));
29479 if (SWIG_arg_fail(3)) SWIG_fail;
29480 }
29481 {
29482 PyThreadState* __tstate = wxPyBeginAllowThreads();
29483 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29484
29485 wxPyEndAllowThreads(__tstate);
29486 if (PyErr_Occurred()) SWIG_fail;
29487 }
29488 {
29489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29490 }
29491 return resultobj;
29492 fail:
29493 return NULL;
29494 }
29495
29496
29497 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29498 PyObject *resultobj;
29499 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29500 bool result;
29501 PyObject * obj0 = 0 ;
29502 char *kwnames[] = {
29503 (char *) "self", NULL
29504 };
29505
29506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29508 if (SWIG_arg_fail(1)) SWIG_fail;
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 result = (bool)(arg1)->GetData();
29512
29513 wxPyEndAllowThreads(__tstate);
29514 if (PyErr_Occurred()) SWIG_fail;
29515 }
29516 {
29517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29518 }
29519 return resultobj;
29520 fail:
29521 return NULL;
29522 }
29523
29524
29525 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29526 PyObject *resultobj;
29527 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29528 wxDragResult arg2 ;
29529 PyObject * obj0 = 0 ;
29530 PyObject * obj1 = 0 ;
29531 char *kwnames[] = {
29532 (char *) "self",(char *) "action", NULL
29533 };
29534
29535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29537 if (SWIG_arg_fail(1)) SWIG_fail;
29538 {
29539 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29540 if (SWIG_arg_fail(2)) SWIG_fail;
29541 }
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 (arg1)->SetDefaultAction((wxDragResult )arg2);
29545
29546 wxPyEndAllowThreads(__tstate);
29547 if (PyErr_Occurred()) SWIG_fail;
29548 }
29549 Py_INCREF(Py_None); resultobj = Py_None;
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29557 PyObject *resultobj;
29558 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29559 wxDragResult result;
29560 PyObject * obj0 = 0 ;
29561 char *kwnames[] = {
29562 (char *) "self", NULL
29563 };
29564
29565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29567 if (SWIG_arg_fail(1)) SWIG_fail;
29568 {
29569 PyThreadState* __tstate = wxPyBeginAllowThreads();
29570 result = (wxDragResult)(arg1)->GetDefaultAction();
29571
29572 wxPyEndAllowThreads(__tstate);
29573 if (PyErr_Occurred()) SWIG_fail;
29574 }
29575 resultobj = SWIG_From_int((result));
29576 return resultobj;
29577 fail:
29578 return NULL;
29579 }
29580
29581
29582 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29583 PyObject *obj;
29584 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29585 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29586 Py_INCREF(obj);
29587 return Py_BuildValue((char *)"");
29588 }
29589 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29590 PyObject *resultobj;
29591 wxPyTextDropTarget *result;
29592 char *kwnames[] = {
29593 NULL
29594 };
29595
29596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29597 {
29598 PyThreadState* __tstate = wxPyBeginAllowThreads();
29599 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29600
29601 wxPyEndAllowThreads(__tstate);
29602 if (PyErr_Occurred()) SWIG_fail;
29603 }
29604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29605 return resultobj;
29606 fail:
29607 return NULL;
29608 }
29609
29610
29611 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29612 PyObject *resultobj;
29613 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29614 PyObject *arg2 = (PyObject *) 0 ;
29615 PyObject *arg3 = (PyObject *) 0 ;
29616 PyObject * obj0 = 0 ;
29617 PyObject * obj1 = 0 ;
29618 PyObject * obj2 = 0 ;
29619 char *kwnames[] = {
29620 (char *) "self",(char *) "self",(char *) "_class", NULL
29621 };
29622
29623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29625 if (SWIG_arg_fail(1)) SWIG_fail;
29626 arg2 = obj1;
29627 arg3 = obj2;
29628 {
29629 PyThreadState* __tstate = wxPyBeginAllowThreads();
29630 (arg1)->_setCallbackInfo(arg2,arg3);
29631
29632 wxPyEndAllowThreads(__tstate);
29633 if (PyErr_Occurred()) SWIG_fail;
29634 }
29635 Py_INCREF(Py_None); resultobj = Py_None;
29636 return resultobj;
29637 fail:
29638 return NULL;
29639 }
29640
29641
29642 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29643 PyObject *resultobj;
29644 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29645 int arg2 ;
29646 int arg3 ;
29647 wxDragResult arg4 ;
29648 wxDragResult result;
29649 PyObject * obj0 = 0 ;
29650 PyObject * obj1 = 0 ;
29651 PyObject * obj2 = 0 ;
29652 PyObject * obj3 = 0 ;
29653 char *kwnames[] = {
29654 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29655 };
29656
29657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29659 if (SWIG_arg_fail(1)) SWIG_fail;
29660 {
29661 arg2 = (int)(SWIG_As_int(obj1));
29662 if (SWIG_arg_fail(2)) SWIG_fail;
29663 }
29664 {
29665 arg3 = (int)(SWIG_As_int(obj2));
29666 if (SWIG_arg_fail(3)) SWIG_fail;
29667 }
29668 {
29669 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29670 if (SWIG_arg_fail(4)) SWIG_fail;
29671 }
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29675
29676 wxPyEndAllowThreads(__tstate);
29677 if (PyErr_Occurred()) SWIG_fail;
29678 }
29679 resultobj = SWIG_From_int((result));
29680 return resultobj;
29681 fail:
29682 return NULL;
29683 }
29684
29685
29686 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29687 PyObject *resultobj;
29688 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29689 int arg2 ;
29690 int arg3 ;
29691 wxDragResult arg4 ;
29692 wxDragResult result;
29693 PyObject * obj0 = 0 ;
29694 PyObject * obj1 = 0 ;
29695 PyObject * obj2 = 0 ;
29696 PyObject * obj3 = 0 ;
29697 char *kwnames[] = {
29698 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29699 };
29700
29701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29703 if (SWIG_arg_fail(1)) SWIG_fail;
29704 {
29705 arg2 = (int)(SWIG_As_int(obj1));
29706 if (SWIG_arg_fail(2)) SWIG_fail;
29707 }
29708 {
29709 arg3 = (int)(SWIG_As_int(obj2));
29710 if (SWIG_arg_fail(3)) SWIG_fail;
29711 }
29712 {
29713 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29714 if (SWIG_arg_fail(4)) SWIG_fail;
29715 }
29716 {
29717 PyThreadState* __tstate = wxPyBeginAllowThreads();
29718 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29719
29720 wxPyEndAllowThreads(__tstate);
29721 if (PyErr_Occurred()) SWIG_fail;
29722 }
29723 resultobj = SWIG_From_int((result));
29724 return resultobj;
29725 fail:
29726 return NULL;
29727 }
29728
29729
29730 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29731 PyObject *resultobj;
29732 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29733 PyObject * obj0 = 0 ;
29734 char *kwnames[] = {
29735 (char *) "self", NULL
29736 };
29737
29738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29740 if (SWIG_arg_fail(1)) SWIG_fail;
29741 {
29742 PyThreadState* __tstate = wxPyBeginAllowThreads();
29743 (arg1)->base_OnLeave();
29744
29745 wxPyEndAllowThreads(__tstate);
29746 if (PyErr_Occurred()) SWIG_fail;
29747 }
29748 Py_INCREF(Py_None); resultobj = Py_None;
29749 return resultobj;
29750 fail:
29751 return NULL;
29752 }
29753
29754
29755 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29756 PyObject *resultobj;
29757 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29758 int arg2 ;
29759 int arg3 ;
29760 bool result;
29761 PyObject * obj0 = 0 ;
29762 PyObject * obj1 = 0 ;
29763 PyObject * obj2 = 0 ;
29764 char *kwnames[] = {
29765 (char *) "self",(char *) "x",(char *) "y", NULL
29766 };
29767
29768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29770 if (SWIG_arg_fail(1)) SWIG_fail;
29771 {
29772 arg2 = (int)(SWIG_As_int(obj1));
29773 if (SWIG_arg_fail(2)) SWIG_fail;
29774 }
29775 {
29776 arg3 = (int)(SWIG_As_int(obj2));
29777 if (SWIG_arg_fail(3)) SWIG_fail;
29778 }
29779 {
29780 PyThreadState* __tstate = wxPyBeginAllowThreads();
29781 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29782
29783 wxPyEndAllowThreads(__tstate);
29784 if (PyErr_Occurred()) SWIG_fail;
29785 }
29786 {
29787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29788 }
29789 return resultobj;
29790 fail:
29791 return NULL;
29792 }
29793
29794
29795 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29796 PyObject *resultobj;
29797 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29798 int arg2 ;
29799 int arg3 ;
29800 wxDragResult arg4 ;
29801 wxDragResult result;
29802 PyObject * obj0 = 0 ;
29803 PyObject * obj1 = 0 ;
29804 PyObject * obj2 = 0 ;
29805 PyObject * obj3 = 0 ;
29806 char *kwnames[] = {
29807 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29808 };
29809
29810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29812 if (SWIG_arg_fail(1)) SWIG_fail;
29813 {
29814 arg2 = (int)(SWIG_As_int(obj1));
29815 if (SWIG_arg_fail(2)) SWIG_fail;
29816 }
29817 {
29818 arg3 = (int)(SWIG_As_int(obj2));
29819 if (SWIG_arg_fail(3)) SWIG_fail;
29820 }
29821 {
29822 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29823 if (SWIG_arg_fail(4)) SWIG_fail;
29824 }
29825 {
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29828
29829 wxPyEndAllowThreads(__tstate);
29830 if (PyErr_Occurred()) SWIG_fail;
29831 }
29832 resultobj = SWIG_From_int((result));
29833 return resultobj;
29834 fail:
29835 return NULL;
29836 }
29837
29838
29839 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29840 PyObject *obj;
29841 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29842 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29843 Py_INCREF(obj);
29844 return Py_BuildValue((char *)"");
29845 }
29846 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29847 PyObject *resultobj;
29848 wxPyFileDropTarget *result;
29849 char *kwnames[] = {
29850 NULL
29851 };
29852
29853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29857
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj;
29870 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29871 PyObject *arg2 = (PyObject *) 0 ;
29872 PyObject *arg3 = (PyObject *) 0 ;
29873 PyObject * obj0 = 0 ;
29874 PyObject * obj1 = 0 ;
29875 PyObject * obj2 = 0 ;
29876 char *kwnames[] = {
29877 (char *) "self",(char *) "self",(char *) "_class", NULL
29878 };
29879
29880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29882 if (SWIG_arg_fail(1)) SWIG_fail;
29883 arg2 = obj1;
29884 arg3 = obj2;
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 (arg1)->_setCallbackInfo(arg2,arg3);
29888
29889 wxPyEndAllowThreads(__tstate);
29890 if (PyErr_Occurred()) SWIG_fail;
29891 }
29892 Py_INCREF(Py_None); resultobj = Py_None;
29893 return resultobj;
29894 fail:
29895 return NULL;
29896 }
29897
29898
29899 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29900 PyObject *resultobj;
29901 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29902 int arg2 ;
29903 int arg3 ;
29904 wxDragResult arg4 ;
29905 wxDragResult result;
29906 PyObject * obj0 = 0 ;
29907 PyObject * obj1 = 0 ;
29908 PyObject * obj2 = 0 ;
29909 PyObject * obj3 = 0 ;
29910 char *kwnames[] = {
29911 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29912 };
29913
29914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29916 if (SWIG_arg_fail(1)) SWIG_fail;
29917 {
29918 arg2 = (int)(SWIG_As_int(obj1));
29919 if (SWIG_arg_fail(2)) SWIG_fail;
29920 }
29921 {
29922 arg3 = (int)(SWIG_As_int(obj2));
29923 if (SWIG_arg_fail(3)) SWIG_fail;
29924 }
29925 {
29926 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29927 if (SWIG_arg_fail(4)) SWIG_fail;
29928 }
29929 {
29930 PyThreadState* __tstate = wxPyBeginAllowThreads();
29931 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29932
29933 wxPyEndAllowThreads(__tstate);
29934 if (PyErr_Occurred()) SWIG_fail;
29935 }
29936 resultobj = SWIG_From_int((result));
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj;
29945 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29946 int arg2 ;
29947 int arg3 ;
29948 wxDragResult arg4 ;
29949 wxDragResult result;
29950 PyObject * obj0 = 0 ;
29951 PyObject * obj1 = 0 ;
29952 PyObject * obj2 = 0 ;
29953 PyObject * obj3 = 0 ;
29954 char *kwnames[] = {
29955 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29956 };
29957
29958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29960 if (SWIG_arg_fail(1)) SWIG_fail;
29961 {
29962 arg2 = (int)(SWIG_As_int(obj1));
29963 if (SWIG_arg_fail(2)) SWIG_fail;
29964 }
29965 {
29966 arg3 = (int)(SWIG_As_int(obj2));
29967 if (SWIG_arg_fail(3)) SWIG_fail;
29968 }
29969 {
29970 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29971 if (SWIG_arg_fail(4)) SWIG_fail;
29972 }
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29976
29977 wxPyEndAllowThreads(__tstate);
29978 if (PyErr_Occurred()) SWIG_fail;
29979 }
29980 resultobj = SWIG_From_int((result));
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj;
29989 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29990 PyObject * obj0 = 0 ;
29991 char *kwnames[] = {
29992 (char *) "self", NULL
29993 };
29994
29995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29997 if (SWIG_arg_fail(1)) SWIG_fail;
29998 {
29999 PyThreadState* __tstate = wxPyBeginAllowThreads();
30000 (arg1)->base_OnLeave();
30001
30002 wxPyEndAllowThreads(__tstate);
30003 if (PyErr_Occurred()) SWIG_fail;
30004 }
30005 Py_INCREF(Py_None); resultobj = Py_None;
30006 return resultobj;
30007 fail:
30008 return NULL;
30009 }
30010
30011
30012 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30013 PyObject *resultobj;
30014 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30015 int arg2 ;
30016 int arg3 ;
30017 bool result;
30018 PyObject * obj0 = 0 ;
30019 PyObject * obj1 = 0 ;
30020 PyObject * obj2 = 0 ;
30021 char *kwnames[] = {
30022 (char *) "self",(char *) "x",(char *) "y", NULL
30023 };
30024
30025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30027 if (SWIG_arg_fail(1)) SWIG_fail;
30028 {
30029 arg2 = (int)(SWIG_As_int(obj1));
30030 if (SWIG_arg_fail(2)) SWIG_fail;
30031 }
30032 {
30033 arg3 = (int)(SWIG_As_int(obj2));
30034 if (SWIG_arg_fail(3)) SWIG_fail;
30035 }
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30039
30040 wxPyEndAllowThreads(__tstate);
30041 if (PyErr_Occurred()) SWIG_fail;
30042 }
30043 {
30044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30045 }
30046 return resultobj;
30047 fail:
30048 return NULL;
30049 }
30050
30051
30052 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
30053 PyObject *resultobj;
30054 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30055 int arg2 ;
30056 int arg3 ;
30057 wxDragResult arg4 ;
30058 wxDragResult result;
30059 PyObject * obj0 = 0 ;
30060 PyObject * obj1 = 0 ;
30061 PyObject * obj2 = 0 ;
30062 PyObject * obj3 = 0 ;
30063 char *kwnames[] = {
30064 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30065 };
30066
30067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30069 if (SWIG_arg_fail(1)) SWIG_fail;
30070 {
30071 arg2 = (int)(SWIG_As_int(obj1));
30072 if (SWIG_arg_fail(2)) SWIG_fail;
30073 }
30074 {
30075 arg3 = (int)(SWIG_As_int(obj2));
30076 if (SWIG_arg_fail(3)) SWIG_fail;
30077 }
30078 {
30079 arg4 = (wxDragResult)(SWIG_As_int(obj3));
30080 if (SWIG_arg_fail(4)) SWIG_fail;
30081 }
30082 {
30083 PyThreadState* __tstate = wxPyBeginAllowThreads();
30084 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
30085
30086 wxPyEndAllowThreads(__tstate);
30087 if (PyErr_Occurred()) SWIG_fail;
30088 }
30089 resultobj = SWIG_From_int((result));
30090 return resultobj;
30091 fail:
30092 return NULL;
30093 }
30094
30095
30096 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
30097 PyObject *obj;
30098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30099 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
30100 Py_INCREF(obj);
30101 return Py_BuildValue((char *)"");
30102 }
30103 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
30104 PyObject *resultobj;
30105 wxClipboard *result;
30106 char *kwnames[] = {
30107 NULL
30108 };
30109
30110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
30111 {
30112 PyThreadState* __tstate = wxPyBeginAllowThreads();
30113 result = (wxClipboard *)new wxClipboard();
30114
30115 wxPyEndAllowThreads(__tstate);
30116 if (PyErr_Occurred()) SWIG_fail;
30117 }
30118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
30119 return resultobj;
30120 fail:
30121 return NULL;
30122 }
30123
30124
30125 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
30126 PyObject *resultobj;
30127 wxClipboard *arg1 = (wxClipboard *) 0 ;
30128 PyObject * obj0 = 0 ;
30129 char *kwnames[] = {
30130 (char *) "self", NULL
30131 };
30132
30133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
30134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30135 if (SWIG_arg_fail(1)) SWIG_fail;
30136 {
30137 PyThreadState* __tstate = wxPyBeginAllowThreads();
30138 delete arg1;
30139
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 Py_INCREF(Py_None); resultobj = Py_None;
30144 return resultobj;
30145 fail:
30146 return NULL;
30147 }
30148
30149
30150 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
30151 PyObject *resultobj;
30152 wxClipboard *arg1 = (wxClipboard *) 0 ;
30153 bool result;
30154 PyObject * obj0 = 0 ;
30155 char *kwnames[] = {
30156 (char *) "self", NULL
30157 };
30158
30159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
30160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30161 if (SWIG_arg_fail(1)) SWIG_fail;
30162 {
30163 PyThreadState* __tstate = wxPyBeginAllowThreads();
30164 result = (bool)(arg1)->Open();
30165
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 {
30170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30171 }
30172 return resultobj;
30173 fail:
30174 return NULL;
30175 }
30176
30177
30178 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
30179 PyObject *resultobj;
30180 wxClipboard *arg1 = (wxClipboard *) 0 ;
30181 PyObject * obj0 = 0 ;
30182 char *kwnames[] = {
30183 (char *) "self", NULL
30184 };
30185
30186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
30187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30188 if (SWIG_arg_fail(1)) SWIG_fail;
30189 {
30190 PyThreadState* __tstate = wxPyBeginAllowThreads();
30191 (arg1)->Close();
30192
30193 wxPyEndAllowThreads(__tstate);
30194 if (PyErr_Occurred()) SWIG_fail;
30195 }
30196 Py_INCREF(Py_None); resultobj = Py_None;
30197 return resultobj;
30198 fail:
30199 return NULL;
30200 }
30201
30202
30203 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
30204 PyObject *resultobj;
30205 wxClipboard *arg1 = (wxClipboard *) 0 ;
30206 bool result;
30207 PyObject * obj0 = 0 ;
30208 char *kwnames[] = {
30209 (char *) "self", NULL
30210 };
30211
30212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
30213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30214 if (SWIG_arg_fail(1)) SWIG_fail;
30215 {
30216 PyThreadState* __tstate = wxPyBeginAllowThreads();
30217 result = (bool)((wxClipboard const *)arg1)->IsOpened();
30218
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 {
30223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30224 }
30225 return resultobj;
30226 fail:
30227 return NULL;
30228 }
30229
30230
30231 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
30232 PyObject *resultobj;
30233 wxClipboard *arg1 = (wxClipboard *) 0 ;
30234 wxDataObject *arg2 = (wxDataObject *) 0 ;
30235 bool result;
30236 PyObject * obj0 = 0 ;
30237 PyObject * obj1 = 0 ;
30238 char *kwnames[] = {
30239 (char *) "self",(char *) "data", NULL
30240 };
30241
30242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
30243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30244 if (SWIG_arg_fail(1)) SWIG_fail;
30245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30246 if (SWIG_arg_fail(2)) SWIG_fail;
30247 {
30248 PyThreadState* __tstate = wxPyBeginAllowThreads();
30249 result = (bool)(arg1)->AddData(arg2);
30250
30251 wxPyEndAllowThreads(__tstate);
30252 if (PyErr_Occurred()) SWIG_fail;
30253 }
30254 {
30255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30256 }
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
30264 PyObject *resultobj;
30265 wxClipboard *arg1 = (wxClipboard *) 0 ;
30266 wxDataObject *arg2 = (wxDataObject *) 0 ;
30267 bool result;
30268 PyObject * obj0 = 0 ;
30269 PyObject * obj1 = 0 ;
30270 char *kwnames[] = {
30271 (char *) "self",(char *) "data", NULL
30272 };
30273
30274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
30275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30276 if (SWIG_arg_fail(1)) SWIG_fail;
30277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30278 if (SWIG_arg_fail(2)) SWIG_fail;
30279 {
30280 PyThreadState* __tstate = wxPyBeginAllowThreads();
30281 result = (bool)(arg1)->SetData(arg2);
30282
30283 wxPyEndAllowThreads(__tstate);
30284 if (PyErr_Occurred()) SWIG_fail;
30285 }
30286 {
30287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30288 }
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30296 PyObject *resultobj;
30297 wxClipboard *arg1 = (wxClipboard *) 0 ;
30298 wxDataFormat *arg2 = 0 ;
30299 bool result;
30300 PyObject * obj0 = 0 ;
30301 PyObject * obj1 = 0 ;
30302 char *kwnames[] = {
30303 (char *) "self",(char *) "format", NULL
30304 };
30305
30306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30308 if (SWIG_arg_fail(1)) SWIG_fail;
30309 {
30310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30311 if (SWIG_arg_fail(2)) SWIG_fail;
30312 if (arg2 == NULL) {
30313 SWIG_null_ref("wxDataFormat");
30314 }
30315 if (SWIG_arg_fail(2)) SWIG_fail;
30316 }
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30320
30321 wxPyEndAllowThreads(__tstate);
30322 if (PyErr_Occurred()) SWIG_fail;
30323 }
30324 {
30325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30326 }
30327 return resultobj;
30328 fail:
30329 return NULL;
30330 }
30331
30332
30333 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30334 PyObject *resultobj;
30335 wxClipboard *arg1 = (wxClipboard *) 0 ;
30336 wxDataObject *arg2 = 0 ;
30337 bool result;
30338 PyObject * obj0 = 0 ;
30339 PyObject * obj1 = 0 ;
30340 char *kwnames[] = {
30341 (char *) "self",(char *) "data", NULL
30342 };
30343
30344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30346 if (SWIG_arg_fail(1)) SWIG_fail;
30347 {
30348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30349 if (SWIG_arg_fail(2)) SWIG_fail;
30350 if (arg2 == NULL) {
30351 SWIG_null_ref("wxDataObject");
30352 }
30353 if (SWIG_arg_fail(2)) SWIG_fail;
30354 }
30355 {
30356 PyThreadState* __tstate = wxPyBeginAllowThreads();
30357 result = (bool)(arg1)->GetData(*arg2);
30358
30359 wxPyEndAllowThreads(__tstate);
30360 if (PyErr_Occurred()) SWIG_fail;
30361 }
30362 {
30363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30364 }
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj;
30373 wxClipboard *arg1 = (wxClipboard *) 0 ;
30374 PyObject * obj0 = 0 ;
30375 char *kwnames[] = {
30376 (char *) "self", NULL
30377 };
30378
30379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30381 if (SWIG_arg_fail(1)) SWIG_fail;
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 (arg1)->Clear();
30385
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 Py_INCREF(Py_None); resultobj = Py_None;
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj;
30398 wxClipboard *arg1 = (wxClipboard *) 0 ;
30399 bool result;
30400 PyObject * obj0 = 0 ;
30401 char *kwnames[] = {
30402 (char *) "self", NULL
30403 };
30404
30405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30407 if (SWIG_arg_fail(1)) SWIG_fail;
30408 {
30409 PyThreadState* __tstate = wxPyBeginAllowThreads();
30410 result = (bool)(arg1)->Flush();
30411
30412 wxPyEndAllowThreads(__tstate);
30413 if (PyErr_Occurred()) SWIG_fail;
30414 }
30415 {
30416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30417 }
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30425 PyObject *resultobj;
30426 wxClipboard *arg1 = (wxClipboard *) 0 ;
30427 bool arg2 = (bool) true ;
30428 PyObject * obj0 = 0 ;
30429 PyObject * obj1 = 0 ;
30430 char *kwnames[] = {
30431 (char *) "self",(char *) "primary", NULL
30432 };
30433
30434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30436 if (SWIG_arg_fail(1)) SWIG_fail;
30437 if (obj1) {
30438 {
30439 arg2 = (bool)(SWIG_As_bool(obj1));
30440 if (SWIG_arg_fail(2)) SWIG_fail;
30441 }
30442 }
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 (arg1)->UsePrimarySelection(arg2);
30446
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 Py_INCREF(Py_None); resultobj = Py_None;
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj;
30459 wxClipboard *result;
30460 char *kwnames[] = {
30461 NULL
30462 };
30463
30464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30465 {
30466 PyThreadState* __tstate = wxPyBeginAllowThreads();
30467 result = (wxClipboard *)wxClipboard::Get();
30468
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30480 PyObject *obj;
30481 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30482 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30483 Py_INCREF(obj);
30484 return Py_BuildValue((char *)"");
30485 }
30486 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj;
30488 wxClipboard *arg1 = (wxClipboard *) NULL ;
30489 wxClipboardLocker *result;
30490 PyObject * obj0 = 0 ;
30491 char *kwnames[] = {
30492 (char *) "clipboard", NULL
30493 };
30494
30495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30496 if (obj0) {
30497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30498 if (SWIG_arg_fail(1)) SWIG_fail;
30499 }
30500 {
30501 PyThreadState* __tstate = wxPyBeginAllowThreads();
30502 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30503
30504 wxPyEndAllowThreads(__tstate);
30505 if (PyErr_Occurred()) SWIG_fail;
30506 }
30507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30515 PyObject *resultobj;
30516 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30517 PyObject * obj0 = 0 ;
30518 char *kwnames[] = {
30519 (char *) "self", NULL
30520 };
30521
30522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30524 if (SWIG_arg_fail(1)) SWIG_fail;
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 delete arg1;
30528
30529 wxPyEndAllowThreads(__tstate);
30530 if (PyErr_Occurred()) SWIG_fail;
30531 }
30532 Py_INCREF(Py_None); resultobj = Py_None;
30533 return resultobj;
30534 fail:
30535 return NULL;
30536 }
30537
30538
30539 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30540 PyObject *resultobj;
30541 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30542 bool result;
30543 PyObject * obj0 = 0 ;
30544 char *kwnames[] = {
30545 (char *) "self", NULL
30546 };
30547
30548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30550 if (SWIG_arg_fail(1)) SWIG_fail;
30551 {
30552 PyThreadState* __tstate = wxPyBeginAllowThreads();
30553 result = (bool)wxClipboardLocker___nonzero__(arg1);
30554
30555 wxPyEndAllowThreads(__tstate);
30556 if (PyErr_Occurred()) SWIG_fail;
30557 }
30558 {
30559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30560 }
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30568 PyObject *obj;
30569 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30570 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30571 Py_INCREF(obj);
30572 return Py_BuildValue((char *)"");
30573 }
30574 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30575 PyObject *resultobj;
30576 int arg1 = (int) 0 ;
30577 int arg2 = (int) 0 ;
30578 int arg3 = (int) 0 ;
30579 int arg4 = (int) 0 ;
30580 wxVideoMode *result;
30581 PyObject * obj0 = 0 ;
30582 PyObject * obj1 = 0 ;
30583 PyObject * obj2 = 0 ;
30584 PyObject * obj3 = 0 ;
30585 char *kwnames[] = {
30586 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30587 };
30588
30589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30590 if (obj0) {
30591 {
30592 arg1 = (int)(SWIG_As_int(obj0));
30593 if (SWIG_arg_fail(1)) SWIG_fail;
30594 }
30595 }
30596 if (obj1) {
30597 {
30598 arg2 = (int)(SWIG_As_int(obj1));
30599 if (SWIG_arg_fail(2)) SWIG_fail;
30600 }
30601 }
30602 if (obj2) {
30603 {
30604 arg3 = (int)(SWIG_As_int(obj2));
30605 if (SWIG_arg_fail(3)) SWIG_fail;
30606 }
30607 }
30608 if (obj3) {
30609 {
30610 arg4 = (int)(SWIG_As_int(obj3));
30611 if (SWIG_arg_fail(4)) SWIG_fail;
30612 }
30613 }
30614 {
30615 PyThreadState* __tstate = wxPyBeginAllowThreads();
30616 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30617
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30629 PyObject *resultobj;
30630 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30631 PyObject * obj0 = 0 ;
30632 char *kwnames[] = {
30633 (char *) "self", NULL
30634 };
30635
30636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30638 if (SWIG_arg_fail(1)) SWIG_fail;
30639 {
30640 PyThreadState* __tstate = wxPyBeginAllowThreads();
30641 delete arg1;
30642
30643 wxPyEndAllowThreads(__tstate);
30644 if (PyErr_Occurred()) SWIG_fail;
30645 }
30646 Py_INCREF(Py_None); resultobj = Py_None;
30647 return resultobj;
30648 fail:
30649 return NULL;
30650 }
30651
30652
30653 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30654 PyObject *resultobj;
30655 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30656 wxVideoMode *arg2 = 0 ;
30657 bool result;
30658 PyObject * obj0 = 0 ;
30659 PyObject * obj1 = 0 ;
30660 char *kwnames[] = {
30661 (char *) "self",(char *) "other", NULL
30662 };
30663
30664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30666 if (SWIG_arg_fail(1)) SWIG_fail;
30667 {
30668 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30669 if (SWIG_arg_fail(2)) SWIG_fail;
30670 if (arg2 == NULL) {
30671 SWIG_null_ref("wxVideoMode");
30672 }
30673 if (SWIG_arg_fail(2)) SWIG_fail;
30674 }
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30678
30679 wxPyEndAllowThreads(__tstate);
30680 if (PyErr_Occurred()) SWIG_fail;
30681 }
30682 {
30683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30684 }
30685 return resultobj;
30686 fail:
30687 return NULL;
30688 }
30689
30690
30691 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30692 PyObject *resultobj;
30693 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30694 int result;
30695 PyObject * obj0 = 0 ;
30696 char *kwnames[] = {
30697 (char *) "self", NULL
30698 };
30699
30700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30702 if (SWIG_arg_fail(1)) SWIG_fail;
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30706
30707 wxPyEndAllowThreads(__tstate);
30708 if (PyErr_Occurred()) SWIG_fail;
30709 }
30710 {
30711 resultobj = SWIG_From_int((int)(result));
30712 }
30713 return resultobj;
30714 fail:
30715 return NULL;
30716 }
30717
30718
30719 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30720 PyObject *resultobj;
30721 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30722 int result;
30723 PyObject * obj0 = 0 ;
30724 char *kwnames[] = {
30725 (char *) "self", NULL
30726 };
30727
30728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30730 if (SWIG_arg_fail(1)) SWIG_fail;
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30734
30735 wxPyEndAllowThreads(__tstate);
30736 if (PyErr_Occurred()) SWIG_fail;
30737 }
30738 {
30739 resultobj = SWIG_From_int((int)(result));
30740 }
30741 return resultobj;
30742 fail:
30743 return NULL;
30744 }
30745
30746
30747 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30748 PyObject *resultobj;
30749 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30750 int result;
30751 PyObject * obj0 = 0 ;
30752 char *kwnames[] = {
30753 (char *) "self", NULL
30754 };
30755
30756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30758 if (SWIG_arg_fail(1)) SWIG_fail;
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30762
30763 wxPyEndAllowThreads(__tstate);
30764 if (PyErr_Occurred()) SWIG_fail;
30765 }
30766 {
30767 resultobj = SWIG_From_int((int)(result));
30768 }
30769 return resultobj;
30770 fail:
30771 return NULL;
30772 }
30773
30774
30775 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30776 PyObject *resultobj;
30777 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30778 bool result;
30779 PyObject * obj0 = 0 ;
30780 char *kwnames[] = {
30781 (char *) "self", NULL
30782 };
30783
30784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30786 if (SWIG_arg_fail(1)) SWIG_fail;
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30790
30791 wxPyEndAllowThreads(__tstate);
30792 if (PyErr_Occurred()) SWIG_fail;
30793 }
30794 {
30795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30796 }
30797 return resultobj;
30798 fail:
30799 return NULL;
30800 }
30801
30802
30803 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30804 PyObject *resultobj;
30805 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30806 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30807 bool result;
30808 PyObject * obj0 = 0 ;
30809 PyObject * obj1 = 0 ;
30810 char *kwnames[] = {
30811 (char *) "self",(char *) "other", NULL
30812 };
30813
30814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30816 if (SWIG_arg_fail(1)) SWIG_fail;
30817 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30818 if (SWIG_arg_fail(2)) SWIG_fail;
30819 {
30820 PyThreadState* __tstate = wxPyBeginAllowThreads();
30821 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30822
30823 wxPyEndAllowThreads(__tstate);
30824 if (PyErr_Occurred()) SWIG_fail;
30825 }
30826 {
30827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30828 }
30829 return resultobj;
30830 fail:
30831 return NULL;
30832 }
30833
30834
30835 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30836 PyObject *resultobj;
30837 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30838 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30839 bool result;
30840 PyObject * obj0 = 0 ;
30841 PyObject * obj1 = 0 ;
30842 char *kwnames[] = {
30843 (char *) "self",(char *) "other", NULL
30844 };
30845
30846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30848 if (SWIG_arg_fail(1)) SWIG_fail;
30849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30850 if (SWIG_arg_fail(2)) SWIG_fail;
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30854
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 {
30859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30860 }
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30868 PyObject *resultobj;
30869 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30870 int arg2 ;
30871 PyObject * obj0 = 0 ;
30872 PyObject * obj1 = 0 ;
30873 char *kwnames[] = {
30874 (char *) "self",(char *) "w", NULL
30875 };
30876
30877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30879 if (SWIG_arg_fail(1)) SWIG_fail;
30880 {
30881 arg2 = (int)(SWIG_As_int(obj1));
30882 if (SWIG_arg_fail(2)) SWIG_fail;
30883 }
30884 if (arg1) (arg1)->w = arg2;
30885
30886 Py_INCREF(Py_None); resultobj = Py_None;
30887 return resultobj;
30888 fail:
30889 return NULL;
30890 }
30891
30892
30893 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30894 PyObject *resultobj;
30895 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30896 int result;
30897 PyObject * obj0 = 0 ;
30898 char *kwnames[] = {
30899 (char *) "self", NULL
30900 };
30901
30902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30904 if (SWIG_arg_fail(1)) SWIG_fail;
30905 result = (int) ((arg1)->w);
30906
30907 {
30908 resultobj = SWIG_From_int((int)(result));
30909 }
30910 return resultobj;
30911 fail:
30912 return NULL;
30913 }
30914
30915
30916 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30917 PyObject *resultobj;
30918 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30919 int arg2 ;
30920 PyObject * obj0 = 0 ;
30921 PyObject * obj1 = 0 ;
30922 char *kwnames[] = {
30923 (char *) "self",(char *) "h", NULL
30924 };
30925
30926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30928 if (SWIG_arg_fail(1)) SWIG_fail;
30929 {
30930 arg2 = (int)(SWIG_As_int(obj1));
30931 if (SWIG_arg_fail(2)) SWIG_fail;
30932 }
30933 if (arg1) (arg1)->h = arg2;
30934
30935 Py_INCREF(Py_None); resultobj = Py_None;
30936 return resultobj;
30937 fail:
30938 return NULL;
30939 }
30940
30941
30942 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30943 PyObject *resultobj;
30944 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30945 int result;
30946 PyObject * obj0 = 0 ;
30947 char *kwnames[] = {
30948 (char *) "self", NULL
30949 };
30950
30951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30953 if (SWIG_arg_fail(1)) SWIG_fail;
30954 result = (int) ((arg1)->h);
30955
30956 {
30957 resultobj = SWIG_From_int((int)(result));
30958 }
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj;
30967 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30968 int arg2 ;
30969 PyObject * obj0 = 0 ;
30970 PyObject * obj1 = 0 ;
30971 char *kwnames[] = {
30972 (char *) "self",(char *) "bpp", NULL
30973 };
30974
30975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30977 if (SWIG_arg_fail(1)) SWIG_fail;
30978 {
30979 arg2 = (int)(SWIG_As_int(obj1));
30980 if (SWIG_arg_fail(2)) SWIG_fail;
30981 }
30982 if (arg1) (arg1)->bpp = arg2;
30983
30984 Py_INCREF(Py_None); resultobj = Py_None;
30985 return resultobj;
30986 fail:
30987 return NULL;
30988 }
30989
30990
30991 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30992 PyObject *resultobj;
30993 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30994 int result;
30995 PyObject * obj0 = 0 ;
30996 char *kwnames[] = {
30997 (char *) "self", NULL
30998 };
30999
31000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
31001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31002 if (SWIG_arg_fail(1)) SWIG_fail;
31003 result = (int) ((arg1)->bpp);
31004
31005 {
31006 resultobj = SWIG_From_int((int)(result));
31007 }
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
31015 PyObject *resultobj;
31016 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31017 int arg2 ;
31018 PyObject * obj0 = 0 ;
31019 PyObject * obj1 = 0 ;
31020 char *kwnames[] = {
31021 (char *) "self",(char *) "refresh", NULL
31022 };
31023
31024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
31025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31026 if (SWIG_arg_fail(1)) SWIG_fail;
31027 {
31028 arg2 = (int)(SWIG_As_int(obj1));
31029 if (SWIG_arg_fail(2)) SWIG_fail;
31030 }
31031 if (arg1) (arg1)->refresh = arg2;
31032
31033 Py_INCREF(Py_None); resultobj = Py_None;
31034 return resultobj;
31035 fail:
31036 return NULL;
31037 }
31038
31039
31040 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
31041 PyObject *resultobj;
31042 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31043 int result;
31044 PyObject * obj0 = 0 ;
31045 char *kwnames[] = {
31046 (char *) "self", NULL
31047 };
31048
31049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
31050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31051 if (SWIG_arg_fail(1)) SWIG_fail;
31052 result = (int) ((arg1)->refresh);
31053
31054 {
31055 resultobj = SWIG_From_int((int)(result));
31056 }
31057 return resultobj;
31058 fail:
31059 return NULL;
31060 }
31061
31062
31063 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
31064 PyObject *obj;
31065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31066 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
31067 Py_INCREF(obj);
31068 return Py_BuildValue((char *)"");
31069 }
31070 static int _wrap_DefaultVideoMode_set(PyObject *) {
31071 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
31072 return 1;
31073 }
31074
31075
31076 static PyObject *_wrap_DefaultVideoMode_get(void) {
31077 PyObject *pyobj;
31078
31079 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
31080 return pyobj;
31081 }
31082
31083
31084 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj;
31086 size_t arg1 = (size_t) 0 ;
31087 wxDisplay *result;
31088 PyObject * obj0 = 0 ;
31089 char *kwnames[] = {
31090 (char *) "index", NULL
31091 };
31092
31093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
31094 if (obj0) {
31095 {
31096 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
31097 if (SWIG_arg_fail(1)) SWIG_fail;
31098 }
31099 }
31100 {
31101 PyThreadState* __tstate = wxPyBeginAllowThreads();
31102 result = (wxDisplay *)new wxDisplay(arg1);
31103
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
31115 PyObject *resultobj;
31116 wxDisplay *arg1 = (wxDisplay *) 0 ;
31117 PyObject * obj0 = 0 ;
31118 char *kwnames[] = {
31119 (char *) "self", NULL
31120 };
31121
31122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
31123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31124 if (SWIG_arg_fail(1)) SWIG_fail;
31125 {
31126 PyThreadState* __tstate = wxPyBeginAllowThreads();
31127 delete arg1;
31128
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 Py_INCREF(Py_None); resultobj = Py_None;
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
31140 PyObject *resultobj;
31141 size_t result;
31142 char *kwnames[] = {
31143 NULL
31144 };
31145
31146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = (size_t)wxDisplay::GetCount();
31150
31151 wxPyEndAllowThreads(__tstate);
31152 if (PyErr_Occurred()) SWIG_fail;
31153 }
31154 {
31155 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
31156 }
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
31164 PyObject *resultobj;
31165 wxPoint *arg1 = 0 ;
31166 int result;
31167 wxPoint temp1 ;
31168 PyObject * obj0 = 0 ;
31169 char *kwnames[] = {
31170 (char *) "pt", NULL
31171 };
31172
31173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
31174 {
31175 arg1 = &temp1;
31176 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
31177 }
31178 {
31179 PyThreadState* __tstate = wxPyBeginAllowThreads();
31180 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
31181
31182 wxPyEndAllowThreads(__tstate);
31183 if (PyErr_Occurred()) SWIG_fail;
31184 }
31185 {
31186 resultobj = SWIG_From_int((int)(result));
31187 }
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31195 PyObject *resultobj;
31196 wxWindow *arg1 = (wxWindow *) 0 ;
31197 int result;
31198 PyObject * obj0 = 0 ;
31199 char *kwnames[] = {
31200 (char *) "window", NULL
31201 };
31202
31203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
31204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31205 if (SWIG_arg_fail(1)) SWIG_fail;
31206 {
31207 PyThreadState* __tstate = wxPyBeginAllowThreads();
31208 result = (int)Display_GetFromWindow(arg1);
31209
31210 wxPyEndAllowThreads(__tstate);
31211 if (PyErr_Occurred()) SWIG_fail;
31212 }
31213 {
31214 resultobj = SWIG_From_int((int)(result));
31215 }
31216 return resultobj;
31217 fail:
31218 return NULL;
31219 }
31220
31221
31222 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
31223 PyObject *resultobj;
31224 wxDisplay *arg1 = (wxDisplay *) 0 ;
31225 bool result;
31226 PyObject * obj0 = 0 ;
31227 char *kwnames[] = {
31228 (char *) "self", NULL
31229 };
31230
31231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
31232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31233 if (SWIG_arg_fail(1)) SWIG_fail;
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = (bool)((wxDisplay const *)arg1)->IsOk();
31237
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 {
31242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31243 }
31244 return resultobj;
31245 fail:
31246 return NULL;
31247 }
31248
31249
31250 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
31251 PyObject *resultobj;
31252 wxDisplay *arg1 = (wxDisplay *) 0 ;
31253 wxRect result;
31254 PyObject * obj0 = 0 ;
31255 char *kwnames[] = {
31256 (char *) "self", NULL
31257 };
31258
31259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
31260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31261 if (SWIG_arg_fail(1)) SWIG_fail;
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 result = ((wxDisplay const *)arg1)->GetGeometry();
31265
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 {
31270 wxRect * resultptr;
31271 resultptr = new wxRect((wxRect &)(result));
31272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
31273 }
31274 return resultobj;
31275 fail:
31276 return NULL;
31277 }
31278
31279
31280 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
31281 PyObject *resultobj;
31282 wxDisplay *arg1 = (wxDisplay *) 0 ;
31283 wxString result;
31284 PyObject * obj0 = 0 ;
31285 char *kwnames[] = {
31286 (char *) "self", NULL
31287 };
31288
31289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31291 if (SWIG_arg_fail(1)) SWIG_fail;
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 result = ((wxDisplay const *)arg1)->GetName();
31295
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 {
31300 #if wxUSE_UNICODE
31301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31302 #else
31303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31304 #endif
31305 }
31306 return resultobj;
31307 fail:
31308 return NULL;
31309 }
31310
31311
31312 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31313 PyObject *resultobj;
31314 wxDisplay *arg1 = (wxDisplay *) 0 ;
31315 bool result;
31316 PyObject * obj0 = 0 ;
31317 char *kwnames[] = {
31318 (char *) "self", NULL
31319 };
31320
31321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31323 if (SWIG_arg_fail(1)) SWIG_fail;
31324 {
31325 PyThreadState* __tstate = wxPyBeginAllowThreads();
31326 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31327
31328 wxPyEndAllowThreads(__tstate);
31329 if (PyErr_Occurred()) SWIG_fail;
31330 }
31331 {
31332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31333 }
31334 return resultobj;
31335 fail:
31336 return NULL;
31337 }
31338
31339
31340 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31341 PyObject *resultobj;
31342 wxDisplay *arg1 = (wxDisplay *) 0 ;
31343 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31344 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31345 PyObject *result;
31346 PyObject * obj0 = 0 ;
31347 PyObject * obj1 = 0 ;
31348 char *kwnames[] = {
31349 (char *) "self",(char *) "mode", NULL
31350 };
31351
31352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31354 if (SWIG_arg_fail(1)) SWIG_fail;
31355 if (obj1) {
31356 {
31357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31358 if (SWIG_arg_fail(2)) SWIG_fail;
31359 if (arg2 == NULL) {
31360 SWIG_null_ref("wxVideoMode");
31361 }
31362 if (SWIG_arg_fail(2)) SWIG_fail;
31363 }
31364 }
31365 {
31366 PyThreadState* __tstate = wxPyBeginAllowThreads();
31367 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31368
31369 wxPyEndAllowThreads(__tstate);
31370 if (PyErr_Occurred()) SWIG_fail;
31371 }
31372 resultobj = result;
31373 return resultobj;
31374 fail:
31375 return NULL;
31376 }
31377
31378
31379 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31380 PyObject *resultobj;
31381 wxDisplay *arg1 = (wxDisplay *) 0 ;
31382 wxVideoMode result;
31383 PyObject * obj0 = 0 ;
31384 char *kwnames[] = {
31385 (char *) "self", NULL
31386 };
31387
31388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31390 if (SWIG_arg_fail(1)) SWIG_fail;
31391 {
31392 PyThreadState* __tstate = wxPyBeginAllowThreads();
31393 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31394
31395 wxPyEndAllowThreads(__tstate);
31396 if (PyErr_Occurred()) SWIG_fail;
31397 }
31398 {
31399 wxVideoMode * resultptr;
31400 resultptr = new wxVideoMode((wxVideoMode &)(result));
31401 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31402 }
31403 return resultobj;
31404 fail:
31405 return NULL;
31406 }
31407
31408
31409 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31410 PyObject *resultobj;
31411 wxDisplay *arg1 = (wxDisplay *) 0 ;
31412 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31413 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31414 bool result;
31415 PyObject * obj0 = 0 ;
31416 PyObject * obj1 = 0 ;
31417 char *kwnames[] = {
31418 (char *) "self",(char *) "mode", NULL
31419 };
31420
31421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31423 if (SWIG_arg_fail(1)) SWIG_fail;
31424 if (obj1) {
31425 {
31426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31427 if (SWIG_arg_fail(2)) SWIG_fail;
31428 if (arg2 == NULL) {
31429 SWIG_null_ref("wxVideoMode");
31430 }
31431 if (SWIG_arg_fail(2)) SWIG_fail;
31432 }
31433 }
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31437
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 {
31442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31443 }
31444 return resultobj;
31445 fail:
31446 return NULL;
31447 }
31448
31449
31450 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31451 PyObject *resultobj;
31452 wxDisplay *arg1 = (wxDisplay *) 0 ;
31453 PyObject * obj0 = 0 ;
31454 char *kwnames[] = {
31455 (char *) "self", NULL
31456 };
31457
31458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31460 if (SWIG_arg_fail(1)) SWIG_fail;
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 (arg1)->ResetMode();
31464
31465 wxPyEndAllowThreads(__tstate);
31466 if (PyErr_Occurred()) SWIG_fail;
31467 }
31468 Py_INCREF(Py_None); resultobj = Py_None;
31469 return resultobj;
31470 fail:
31471 return NULL;
31472 }
31473
31474
31475 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31476 PyObject *obj;
31477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31478 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31479 Py_INCREF(obj);
31480 return Py_BuildValue((char *)"");
31481 }
31482 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31483 PyObject *resultobj;
31484 wxStandardPaths *result;
31485 char *kwnames[] = {
31486 NULL
31487 };
31488
31489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31490 {
31491 PyThreadState* __tstate = wxPyBeginAllowThreads();
31492 result = (wxStandardPaths *)StandardPaths_Get();
31493
31494 wxPyEndAllowThreads(__tstate);
31495 if (PyErr_Occurred()) SWIG_fail;
31496 }
31497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31498 return resultobj;
31499 fail:
31500 return NULL;
31501 }
31502
31503
31504 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31505 PyObject *resultobj;
31506 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31507 wxString result;
31508 PyObject * obj0 = 0 ;
31509 char *kwnames[] = {
31510 (char *) "self", NULL
31511 };
31512
31513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31515 if (SWIG_arg_fail(1)) SWIG_fail;
31516 {
31517 PyThreadState* __tstate = wxPyBeginAllowThreads();
31518 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31519
31520 wxPyEndAllowThreads(__tstate);
31521 if (PyErr_Occurred()) SWIG_fail;
31522 }
31523 {
31524 #if wxUSE_UNICODE
31525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31526 #else
31527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31528 #endif
31529 }
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31537 PyObject *resultobj;
31538 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31539 wxString result;
31540 PyObject * obj0 = 0 ;
31541 char *kwnames[] = {
31542 (char *) "self", NULL
31543 };
31544
31545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31547 if (SWIG_arg_fail(1)) SWIG_fail;
31548 {
31549 PyThreadState* __tstate = wxPyBeginAllowThreads();
31550 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31551
31552 wxPyEndAllowThreads(__tstate);
31553 if (PyErr_Occurred()) SWIG_fail;
31554 }
31555 {
31556 #if wxUSE_UNICODE
31557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31558 #else
31559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31560 #endif
31561 }
31562 return resultobj;
31563 fail:
31564 return NULL;
31565 }
31566
31567
31568 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31569 PyObject *resultobj;
31570 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31571 wxString result;
31572 PyObject * obj0 = 0 ;
31573 char *kwnames[] = {
31574 (char *) "self", NULL
31575 };
31576
31577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31579 if (SWIG_arg_fail(1)) SWIG_fail;
31580 {
31581 PyThreadState* __tstate = wxPyBeginAllowThreads();
31582 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31583
31584 wxPyEndAllowThreads(__tstate);
31585 if (PyErr_Occurred()) SWIG_fail;
31586 }
31587 {
31588 #if wxUSE_UNICODE
31589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31590 #else
31591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31592 #endif
31593 }
31594 return resultobj;
31595 fail:
31596 return NULL;
31597 }
31598
31599
31600 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31601 PyObject *resultobj;
31602 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31603 wxString result;
31604 PyObject * obj0 = 0 ;
31605 char *kwnames[] = {
31606 (char *) "self", NULL
31607 };
31608
31609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31611 if (SWIG_arg_fail(1)) SWIG_fail;
31612 {
31613 PyThreadState* __tstate = wxPyBeginAllowThreads();
31614 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31615
31616 wxPyEndAllowThreads(__tstate);
31617 if (PyErr_Occurred()) SWIG_fail;
31618 }
31619 {
31620 #if wxUSE_UNICODE
31621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31622 #else
31623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31624 #endif
31625 }
31626 return resultobj;
31627 fail:
31628 return NULL;
31629 }
31630
31631
31632 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31633 PyObject *resultobj;
31634 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31635 wxString result;
31636 PyObject * obj0 = 0 ;
31637 char *kwnames[] = {
31638 (char *) "self", NULL
31639 };
31640
31641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31643 if (SWIG_arg_fail(1)) SWIG_fail;
31644 {
31645 PyThreadState* __tstate = wxPyBeginAllowThreads();
31646 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31647
31648 wxPyEndAllowThreads(__tstate);
31649 if (PyErr_Occurred()) SWIG_fail;
31650 }
31651 {
31652 #if wxUSE_UNICODE
31653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31654 #else
31655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31656 #endif
31657 }
31658 return resultobj;
31659 fail:
31660 return NULL;
31661 }
31662
31663
31664 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31665 PyObject *resultobj;
31666 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31667 wxString result;
31668 PyObject * obj0 = 0 ;
31669 char *kwnames[] = {
31670 (char *) "self", NULL
31671 };
31672
31673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31675 if (SWIG_arg_fail(1)) SWIG_fail;
31676 {
31677 PyThreadState* __tstate = wxPyBeginAllowThreads();
31678 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31679
31680 wxPyEndAllowThreads(__tstate);
31681 if (PyErr_Occurred()) SWIG_fail;
31682 }
31683 {
31684 #if wxUSE_UNICODE
31685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31686 #else
31687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31688 #endif
31689 }
31690 return resultobj;
31691 fail:
31692 return NULL;
31693 }
31694
31695
31696 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31697 PyObject *resultobj;
31698 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31699 wxString result;
31700 PyObject * obj0 = 0 ;
31701 char *kwnames[] = {
31702 (char *) "self", NULL
31703 };
31704
31705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31707 if (SWIG_arg_fail(1)) SWIG_fail;
31708 {
31709 PyThreadState* __tstate = wxPyBeginAllowThreads();
31710 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31711
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 {
31716 #if wxUSE_UNICODE
31717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31718 #else
31719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31720 #endif
31721 }
31722 return resultobj;
31723 fail:
31724 return NULL;
31725 }
31726
31727
31728 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31729 PyObject *resultobj;
31730 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31731 wxString *arg2 = 0 ;
31732 bool temp2 = false ;
31733 PyObject * obj0 = 0 ;
31734 PyObject * obj1 = 0 ;
31735 char *kwnames[] = {
31736 (char *) "self",(char *) "prefix", NULL
31737 };
31738
31739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31741 if (SWIG_arg_fail(1)) SWIG_fail;
31742 {
31743 arg2 = wxString_in_helper(obj1);
31744 if (arg2 == NULL) SWIG_fail;
31745 temp2 = true;
31746 }
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31750
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 Py_INCREF(Py_None); resultobj = Py_None;
31755 {
31756 if (temp2)
31757 delete arg2;
31758 }
31759 return resultobj;
31760 fail:
31761 {
31762 if (temp2)
31763 delete arg2;
31764 }
31765 return NULL;
31766 }
31767
31768
31769 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31770 PyObject *resultobj;
31771 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31772 wxString result;
31773 PyObject * obj0 = 0 ;
31774 char *kwnames[] = {
31775 (char *) "self", NULL
31776 };
31777
31778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31780 if (SWIG_arg_fail(1)) SWIG_fail;
31781 {
31782 PyThreadState* __tstate = wxPyBeginAllowThreads();
31783 result = wxStandardPaths_GetInstallPrefix(arg1);
31784
31785 wxPyEndAllowThreads(__tstate);
31786 if (PyErr_Occurred()) SWIG_fail;
31787 }
31788 {
31789 #if wxUSE_UNICODE
31790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31791 #else
31792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31793 #endif
31794 }
31795 return resultobj;
31796 fail:
31797 return NULL;
31798 }
31799
31800
31801 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31802 PyObject *obj;
31803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31804 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31805 Py_INCREF(obj);
31806 return Py_BuildValue((char *)"");
31807 }
31808 static PyMethodDef SwigMethods[] = {
31809 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31816 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31824 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31889 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31897 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31915 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31918 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31921 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31924 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31930 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31944 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31950 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31956 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31959 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31973 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31976 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31977 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31980 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
32007 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
32009 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
32011 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
32013 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
32020 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
32026 { (char *)"new_LogBuffer", (PyCFunction) _wrap_new_LogBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"LogBuffer_GetBuffer", (PyCFunction) _wrap_LogBuffer_GetBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"LogBuffer_Flush", (PyCFunction) _wrap_LogBuffer_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
32030 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
32044 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
32048 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
32051 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
32068 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
32076 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
32123 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
32141 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
32151 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
32167 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
32183 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
32197 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
32207 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
32250 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
32253 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
32256 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
32260 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
32330 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32333 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32334 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32335 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32336 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32337 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32338 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32339 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32340 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32341 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32342 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32343 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32344 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32345 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32346 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32347 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32348 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32349 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32350 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32351 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32352 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32353 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32354 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32355 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32356 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32357 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32358 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32359 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32360 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32361 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32362 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32363 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32364 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32365 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32366 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32367 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32368 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32369 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32370 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32371 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32372 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32373 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32374 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32375 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32376 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32377 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32378 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32379 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32380 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32381 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32382 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32383 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32384 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32385 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32386 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32387 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32388 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32389 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32390 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32391 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32392 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32393 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32394 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32395 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32396 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32397 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32398 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32399 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32400 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32401 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32402 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32403 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32404 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32405 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32406 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32407 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32408 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32409 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32410 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32411 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32412 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32413 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32414 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32415 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32416 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32417 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32418 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32419 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32420 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32421 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32422 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32423 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32424 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32425 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32426 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32427 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32428 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32429 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32430 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32431 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32432 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32433 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32434 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32435 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32436 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32437 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32438 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32439 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32440 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32441 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32442 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32443 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32444 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32445 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32446 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32447 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32448 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32449 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32450 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32451 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32452 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32453 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32454 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32455 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32456 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32457 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32458 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32459 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32460 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32461 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32462 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32463 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32464 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32465 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32466 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32467 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32468 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32469 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32470 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32471 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32472 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32473 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32474 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32475 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32476 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32477 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32478 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32479 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32480 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32481 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32482 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32483 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32484 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32485 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32486 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32487 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32488 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32489 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32490 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32491 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32492 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32493 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32494 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32495 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32496 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32497 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32498 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32499 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32500 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32501 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32502 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32503 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32504 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32505 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32506 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32507 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32508 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32509 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32510 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32511 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32512 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32513 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32514 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32515 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32516 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32517 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32518 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32519 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32520 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32521 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32522 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32523 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32524 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32525 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32526 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32527 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32528 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32529 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32530 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32531 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32532 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32533 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32534 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32535 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32536 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32537 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32538 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32539 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32540 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32541 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32542 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32543 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32544 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32545 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32546 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32547 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32548 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32549 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32550 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32551 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32552 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32553 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32554 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32555 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32556 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32557 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32558 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32559 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32560 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32561 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32562 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32563 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32564 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32565 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32566 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32567 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32568 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32569 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32570 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32571 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32572 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32573 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32574 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32575 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32576 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32577 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32578 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32579 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32580 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32581 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32582 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32583 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32584 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32585 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32586 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32587 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32588 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32589 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32590 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32591 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32592 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32593 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32594 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32595 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32596 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32597 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32598 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32599 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32600 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32601 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32602 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32603 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32604 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32605 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32606 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32607 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32608 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32609 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32610 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32611 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32612 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32613 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32614 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32615 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32616 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32617 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32618 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32619 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32620 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32621 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32622 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32623 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32624 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32625 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32626 { NULL, NULL, 0, NULL }
32627 };
32628
32629
32630 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32631
32632 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32633 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32634 }
32635 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32636 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32637 }
32638 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32639 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32640 }
32641 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32642 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32643 }
32644 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32645 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32646 }
32647 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32648 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32649 }
32650 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32651 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32652 }
32653 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32654 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32655 }
32656 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32657 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32658 }
32659 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32660 return (void *)((wxEvent *) ((wxPyEvent *) x));
32661 }
32662 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32663 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32664 }
32665 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32666 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32667 }
32668 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32669 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32670 }
32671 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32672 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32673 }
32674 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32675 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32676 }
32677 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32678 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32679 }
32680 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32681 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32682 }
32683 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32684 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32685 }
32686 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32687 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32688 }
32689 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32690 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32691 }
32692 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32693 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32694 }
32695 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32696 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32697 }
32698 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32699 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32700 }
32701 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32702 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32703 }
32704 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32705 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32706 }
32707 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32708 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32709 }
32710 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32711 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32712 }
32713 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32714 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32715 }
32716 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32717 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32718 }
32719 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32720 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32721 }
32722 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32723 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32724 }
32725 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32726 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32727 }
32728 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32729 return (void *)((wxEvent *) ((wxShowEvent *) x));
32730 }
32731 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32732 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32733 }
32734 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32735 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32736 }
32737 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32738 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32739 }
32740 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32741 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32742 }
32743 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32744 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32745 }
32746 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32747 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32748 }
32749 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32750 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32751 }
32752 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32753 return (void *)((wxConfigBase *) ((wxConfig *) x));
32754 }
32755 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32756 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32757 }
32758 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32759 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32760 }
32761 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32762 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32763 }
32764 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32765 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32766 }
32767 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32768 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32769 }
32770 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32771 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32772 }
32773 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32774 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32775 }
32776 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32777 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32778 }
32779 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32780 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32781 }
32782 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32783 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32784 }
32785 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32786 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32787 }
32788 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32789 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32790 }
32791 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32792 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32793 }
32794 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32795 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32796 }
32797 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32798 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32799 }
32800 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32801 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32802 }
32803 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32804 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32805 }
32806 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32807 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32808 }
32809 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32810 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32811 }
32812 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32813 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32814 }
32815 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32816 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32817 }
32818 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32819 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32820 }
32821 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32822 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32823 }
32824 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32825 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32826 }
32827 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32828 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32829 }
32830 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32831 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32832 }
32833 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32834 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32835 }
32836 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32837 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32838 }
32839 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32840 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32841 }
32842 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32843 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32844 }
32845 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32846 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32847 }
32848 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32849 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32850 }
32851 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32852 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32853 }
32854 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32855 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32856 }
32857 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32858 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32859 }
32860 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32861 return (void *)((wxObject *) ((wxSizerItem *) x));
32862 }
32863 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32864 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32865 }
32866 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32867 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32868 }
32869 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32870 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32871 }
32872 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32873 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32874 }
32875 static void *_p_wxSizerTo_p_wxObject(void *x) {
32876 return (void *)((wxObject *) ((wxSizer *) x));
32877 }
32878 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32879 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32880 }
32881 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32882 return (void *)((wxObject *) ((wxFileHistory *) x));
32883 }
32884 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32885 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32886 }
32887 static void *_p_wxEventTo_p_wxObject(void *x) {
32888 return (void *)((wxObject *) ((wxEvent *) x));
32889 }
32890 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32891 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32892 }
32893 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32894 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32895 }
32896 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32897 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32898 }
32899 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32900 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32901 }
32902 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32903 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32904 }
32905 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32906 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32907 }
32908 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32909 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32910 }
32911 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32912 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32913 }
32914 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32915 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32916 }
32917 static void *_p_wxControlTo_p_wxObject(void *x) {
32918 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32919 }
32920 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32921 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32922 }
32923 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32924 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32925 }
32926 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32927 return (void *)((wxObject *) ((wxFSFile *) x));
32928 }
32929 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32930 return (void *)((wxObject *) ((wxClipboard *) x));
32931 }
32932 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32933 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32934 }
32935 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32936 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32937 }
32938 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32939 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32940 }
32941 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32942 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32943 }
32944 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32945 return (void *)((wxObject *) ((wxToolTip *) x));
32946 }
32947 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32948 return (void *)((wxObject *) ((wxMenuItem *) x));
32949 }
32950 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32951 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32952 }
32953 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32954 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32955 }
32956 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32957 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32958 }
32959 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32960 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32961 }
32962 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32963 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32964 }
32965 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32966 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32967 }
32968 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32969 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32970 }
32971 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32972 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32973 }
32974 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32975 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32976 }
32977 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32978 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32979 }
32980 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32981 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32982 }
32983 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32984 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32985 }
32986 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32987 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32988 }
32989 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32990 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32991 }
32992 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32993 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32994 }
32995 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32996 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32997 }
32998 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32999 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
33000 }
33001 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
33002 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
33003 }
33004 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
33005 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
33006 }
33007 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
33008 return (void *)((wxObject *) ((wxImageHandler *) x));
33009 }
33010 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
33011 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
33012 }
33013 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
33014 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
33015 }
33016 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
33017 return (void *)((wxObject *) ((wxEvtHandler *) x));
33018 }
33019 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
33020 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
33021 }
33022 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
33023 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
33024 }
33025 static void *_p_wxImageTo_p_wxObject(void *x) {
33026 return (void *)((wxObject *) ((wxImage *) x));
33027 }
33028 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
33029 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
33030 }
33031 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
33032 return (void *)((wxObject *) ((wxSystemOptions *) x));
33033 }
33034 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
33035 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
33036 }
33037 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
33038 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
33039 }
33040 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
33041 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
33042 }
33043 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
33044 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
33045 }
33046 static void *_p_wxWindowTo_p_wxObject(void *x) {
33047 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
33048 }
33049 static void *_p_wxMenuTo_p_wxObject(void *x) {
33050 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
33051 }
33052 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
33053 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
33054 }
33055 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
33056 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
33057 }
33058 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
33059 return (void *)((wxObject *) ((wxFileSystem *) x));
33060 }
33061 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
33062 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
33063 }
33064 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
33065 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
33066 }
33067 static void *_p_wxPyAppTo_p_wxObject(void *x) {
33068 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
33069 }
33070 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
33071 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
33072 }
33073 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
33074 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
33075 }
33076 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
33077 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
33078 }
33079 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
33080 return (void *)((wxObject *) ((wxBusyInfo *) x));
33081 }
33082 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
33083 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
33084 }
33085 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
33086 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
33087 }
33088 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
33089 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
33090 }
33091 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
33092 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
33093 }
33094 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
33095 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
33096 }
33097 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
33098 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
33099 }
33100 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
33101 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
33102 }
33103 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
33104 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
33105 }
33106 static void *_p_wxValidatorTo_p_wxObject(void *x) {
33107 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
33108 }
33109 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
33110 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
33111 }
33112 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
33113 return (void *)((wxLog *) ((wxLogBuffer *) x));
33114 }
33115 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
33116 return (void *)((wxLog *) ((wxLogStderr *) x));
33117 }
33118 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
33119 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
33120 }
33121 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
33122 return (void *)((wxLog *) ((wxLogWindow *) x));
33123 }
33124 static void *_p_wxLogChainTo_p_wxLog(void *x) {
33125 return (void *)((wxLog *) ((wxLogChain *) x));
33126 }
33127 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
33128 return (void *)((wxLog *) ((wxLogGui *) x));
33129 }
33130 static void *_p_wxPyLogTo_p_wxLog(void *x) {
33131 return (void *)((wxLog *) ((wxPyLog *) x));
33132 }
33133 static void *_p_wxControlTo_p_wxWindow(void *x) {
33134 return (void *)((wxWindow *) ((wxControl *) x));
33135 }
33136 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
33137 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
33138 }
33139 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
33140 return (void *)((wxWindow *) ((wxMenuBar *) x));
33141 }
33142 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
33143 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
33144 }
33145 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
33146 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
33147 }
33148 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}};
33149 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}};
33150 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}};
33151 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}};
33152 static swig_type_info _swigt__p_wxLog[] = {{"_p_wxLog", 0, "wxLog *", 0, 0, 0, 0},{"_p_wxLogBuffer", _p_wxLogBufferTo_p_wxLog, 0, 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}};
33153 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}};
33154 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}};
33155 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}};
33156 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}};
33157 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}};
33158 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}};
33159 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}};
33160 static swig_type_info _swigt__p_wxMemorySize[] = {{"_p_wxMemorySize", 0, "wxMemorySize *", 0, 0, 0, 0},{"_p_wxMemorySize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33161 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}};
33162 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}};
33163 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}};
33164 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}};
33165 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}};
33166 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}};
33167 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0, 0, 0, 0},{"_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33168 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}};
33169 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}};
33170 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}};
33171 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}};
33172 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}};
33173 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}};
33174 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}};
33175 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}};
33176 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}};
33177 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}};
33178 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}};
33179 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}};
33180 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}};
33181 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}};
33182 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}};
33183 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}};
33184 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}};
33185 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}};
33186 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}};
33187 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}};
33188 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}};
33189 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}};
33190 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}};
33191 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}};
33192 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}};
33193 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}};
33194 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}};
33195 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}};
33196 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}};
33197 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}};
33198 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}};
33199 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}};
33200 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}};
33201 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}};
33202 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}};
33203 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}};
33204 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}};
33205 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}};
33206 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}};
33207 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}};
33208 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}};
33209 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}};
33210 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}};
33211 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}};
33212 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}};
33213 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}};
33214 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}};
33215 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}};
33216 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}};
33217 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}};
33218 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}};
33219 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}};
33220 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}};
33221 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_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_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_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_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_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}};
33222 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}};
33223 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}};
33224 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}};
33225 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}};
33226 static swig_type_info _swigt__p_wxLogBuffer[] = {{"_p_wxLogBuffer", 0, "wxLogBuffer *", 0, 0, 0, 0},{"_p_wxLogBuffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33227 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}};
33228 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}};
33229 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}};
33230 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}};
33231 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}};
33232 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}};
33233 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}};
33234 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}};
33235 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}};
33236 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}};
33237 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}};
33238 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}};
33239 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}};
33240 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}};
33241 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}};
33242 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}};
33243 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}};
33244 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}};
33245 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}};
33246 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}};
33247 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}};
33248
33249 static swig_type_info *swig_types_initial[] = {
33250 _swigt__p_wxLogChain,
33251 _swigt__p_wxMutexGuiLocker,
33252 _swigt__p_wxMetafile,
33253 _swigt__p_wxFileHistory,
33254 _swigt__p_wxLog,
33255 _swigt__p_wxMenu,
33256 _swigt__p_wxEvent,
33257 _swigt__p_wxDateTime__TimeZone,
33258 _swigt__p_wxConfigBase,
33259 _swigt__p_wxDisplay,
33260 _swigt__p_wxFileType,
33261 _swigt__p_wxLogGui,
33262 _swigt__p_wxMemorySize,
33263 _swigt__p_wxFont,
33264 _swigt__p_wxDataFormat,
33265 _swigt__p_wxTimerEvent,
33266 _swigt__p_wxCaret,
33267 _swigt__ptrdiff_t,
33268 _swigt__std__ptrdiff_t,
33269 _swigt__p_void,
33270 _swigt__p_int,
33271 _swigt__p_wxSize,
33272 _swigt__p_wxClipboard,
33273 _swigt__p_wxStopWatch,
33274 _swigt__p_wxDC,
33275 _swigt__p_wxClipboardLocker,
33276 _swigt__p_wxIcon,
33277 _swigt__p_wxLogStderr,
33278 _swigt__p_wxLogTextCtrl,
33279 _swigt__p_wxTextCtrl,
33280 _swigt__p_wxBusyCursor,
33281 _swigt__p_wxBitmapDataObject,
33282 _swigt__p_wxTextDataObject,
33283 _swigt__p_wxDataObject,
33284 _swigt__p_wxPyTextDataObject,
33285 _swigt__p_wxPyBitmapDataObject,
33286 _swigt__p_wxFileDataObject,
33287 _swigt__p_wxCustomDataObject,
33288 _swigt__p_wxURLDataObject,
33289 _swigt__p_wxMetafileDataObject,
33290 _swigt__p_wxSound,
33291 _swigt__p_wxTimerRunner,
33292 _swigt__p_wxLogWindow,
33293 _swigt__p_wxTimeSpan,
33294 _swigt__p_wxArrayString,
33295 _swigt__p_wxWindowDisabler,
33296 _swigt__p_form_ops_t,
33297 _swigt__p_wxToolTip,
33298 _swigt__p_wxDataObjectComposite,
33299 _swigt__p_wxSystemSettings,
33300 _swigt__p_wxFileConfig,
33301 _swigt__p_wxVideoMode,
33302 _swigt__p_wxDataObjectSimple,
33303 _swigt__p_wxPyDataObjectSimple,
33304 _swigt__p_wxDuplexMode,
33305 _swigt__p_wxEvtHandler,
33306 _swigt__p_wxRect,
33307 _swigt__p_char,
33308 _swigt__p_wxSingleInstanceChecker,
33309 _swigt__p_wxStandardPaths,
33310 _swigt__p_wxFileTypeInfo,
33311 _swigt__p_wxFrame,
33312 _swigt__p_wxTimer,
33313 _swigt__p_wxPaperSize,
33314 _swigt__p_wxMimeTypesManager,
33315 _swigt__p_wxPyTipProvider,
33316 _swigt__p_wxTipProvider,
33317 _swigt__p_wxJoystick,
33318 _swigt__p_wxSystemOptions,
33319 _swigt__p_wxPyArtProvider,
33320 _swigt__p_wxPoint,
33321 _swigt__p_wxJoystickEvent,
33322 _swigt__p_wxCursor,
33323 _swigt__p_wxObject,
33324 _swigt__p_wxOutputStream,
33325 _swigt__p_wxDateTime,
33326 _swigt__p_wxPyDropSource,
33327 _swigt__p_unsigned_long,
33328 _swigt__p_wxLogBuffer,
33329 _swigt__p_wxKillError,
33330 _swigt__p_wxWindow,
33331 _swigt__p_wxString,
33332 _swigt__p_wxPyProcess,
33333 _swigt__p_wxBitmap,
33334 _swigt__unsigned_int,
33335 _swigt__p_unsigned_int,
33336 _swigt__p_wxConfig,
33337 _swigt__p_unsigned_char,
33338 _swigt__p_wxChar,
33339 _swigt__p_wxBusyInfo,
33340 _swigt__p_wxPyDropTarget,
33341 _swigt__p_wxPyTextDropTarget,
33342 _swigt__p_wxPyFileDropTarget,
33343 _swigt__p_wxProcessEvent,
33344 _swigt__p_wxPyLog,
33345 _swigt__p_wxLogNull,
33346 _swigt__p_wxColour,
33347 _swigt__p_wxPyTimer,
33348 _swigt__p_wxConfigPathChanger,
33349 _swigt__p_wxDateSpan,
33350 0
33351 };
33352
33353
33354 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33355
33356 static swig_const_info swig_const_table[] = {
33357 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33358 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33359 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33360 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33361 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33362 {0, 0, 0, 0.0, 0, 0}};
33363
33364 #ifdef __cplusplus
33365 }
33366 #endif
33367
33368
33369 #ifdef __cplusplus
33370 extern "C" {
33371 #endif
33372
33373 /* Python-specific SWIG API */
33374 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33375 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33376 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33377
33378 /* -----------------------------------------------------------------------------
33379 * global variable support code.
33380 * ----------------------------------------------------------------------------- */
33381
33382 typedef struct swig_globalvar {
33383 char *name; /* Name of global variable */
33384 PyObject *(*get_attr)(); /* Return the current value */
33385 int (*set_attr)(PyObject *); /* Set the value */
33386 struct swig_globalvar *next;
33387 } swig_globalvar;
33388
33389 typedef struct swig_varlinkobject {
33390 PyObject_HEAD
33391 swig_globalvar *vars;
33392 } swig_varlinkobject;
33393
33394 static PyObject *
33395 swig_varlink_repr(swig_varlinkobject *v) {
33396 v = v;
33397 return PyString_FromString("<Swig global variables>");
33398 }
33399
33400 static int
33401 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33402 swig_globalvar *var;
33403 flags = flags;
33404 fprintf(fp,"Swig global variables { ");
33405 for (var = v->vars; var; var=var->next) {
33406 fprintf(fp,"%s", var->name);
33407 if (var->next) fprintf(fp,", ");
33408 }
33409 fprintf(fp," }\n");
33410 return 0;
33411 }
33412
33413 static PyObject *
33414 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33415 swig_globalvar *var = v->vars;
33416 while (var) {
33417 if (strcmp(var->name,n) == 0) {
33418 return (*var->get_attr)();
33419 }
33420 var = var->next;
33421 }
33422 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33423 return NULL;
33424 }
33425
33426 static int
33427 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33428 swig_globalvar *var = v->vars;
33429 while (var) {
33430 if (strcmp(var->name,n) == 0) {
33431 return (*var->set_attr)(p);
33432 }
33433 var = var->next;
33434 }
33435 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33436 return 1;
33437 }
33438
33439 static PyTypeObject varlinktype = {
33440 PyObject_HEAD_INIT(0)
33441 0, /* Number of items in variable part (ob_size) */
33442 (char *)"swigvarlink", /* Type name (tp_name) */
33443 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33444 0, /* Itemsize (tp_itemsize) */
33445 0, /* Deallocator (tp_dealloc) */
33446 (printfunc) swig_varlink_print, /* Print (tp_print) */
33447 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33448 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33449 0, /* tp_compare */
33450 (reprfunc) swig_varlink_repr, /* tp_repr */
33451 0, /* tp_as_number */
33452 0, /* tp_as_sequence */
33453 0, /* tp_as_mapping */
33454 0, /* tp_hash */
33455 0, /* tp_call */
33456 0, /* tp_str */
33457 0, /* tp_getattro */
33458 0, /* tp_setattro */
33459 0, /* tp_as_buffer */
33460 0, /* tp_flags */
33461 0, /* tp_doc */
33462 #if PY_VERSION_HEX >= 0x02000000
33463 0, /* tp_traverse */
33464 0, /* tp_clear */
33465 #endif
33466 #if PY_VERSION_HEX >= 0x02010000
33467 0, /* tp_richcompare */
33468 0, /* tp_weaklistoffset */
33469 #endif
33470 #if PY_VERSION_HEX >= 0x02020000
33471 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33472 #endif
33473 #if PY_VERSION_HEX >= 0x02030000
33474 0, /* tp_del */
33475 #endif
33476 #ifdef COUNT_ALLOCS
33477 0,0,0,0 /* tp_alloc -> tp_next */
33478 #endif
33479 };
33480
33481 /* Create a variable linking object for use later */
33482 static PyObject *
33483 SWIG_Python_newvarlink(void) {
33484 swig_varlinkobject *result = 0;
33485 result = PyMem_NEW(swig_varlinkobject,1);
33486 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33487 result->ob_type = &varlinktype;
33488 result->vars = 0;
33489 result->ob_refcnt = 0;
33490 Py_XINCREF((PyObject *) result);
33491 return ((PyObject*) result);
33492 }
33493
33494 static void
33495 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33496 swig_varlinkobject *v;
33497 swig_globalvar *gv;
33498 v= (swig_varlinkobject *) p;
33499 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33500 gv->name = (char *) malloc(strlen(name)+1);
33501 strcpy(gv->name,name);
33502 gv->get_attr = get_attr;
33503 gv->set_attr = set_attr;
33504 gv->next = v->vars;
33505 v->vars = gv;
33506 }
33507
33508 /* -----------------------------------------------------------------------------
33509 * constants/methods manipulation
33510 * ----------------------------------------------------------------------------- */
33511
33512 /* Install Constants */
33513 static void
33514 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33515 PyObject *obj = 0;
33516 size_t i;
33517 for (i = 0; constants[i].type; i++) {
33518 switch(constants[i].type) {
33519 case SWIG_PY_INT:
33520 obj = PyInt_FromLong(constants[i].lvalue);
33521 break;
33522 case SWIG_PY_FLOAT:
33523 obj = PyFloat_FromDouble(constants[i].dvalue);
33524 break;
33525 case SWIG_PY_STRING:
33526 if (constants[i].pvalue) {
33527 obj = PyString_FromString((char *) constants[i].pvalue);
33528 } else {
33529 Py_INCREF(Py_None);
33530 obj = Py_None;
33531 }
33532 break;
33533 case SWIG_PY_POINTER:
33534 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33535 break;
33536 case SWIG_PY_BINARY:
33537 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33538 break;
33539 default:
33540 obj = 0;
33541 break;
33542 }
33543 if (obj) {
33544 PyDict_SetItemString(d,constants[i].name,obj);
33545 Py_DECREF(obj);
33546 }
33547 }
33548 }
33549
33550 /* -----------------------------------------------------------------------------*/
33551 /* Fix SwigMethods to carry the callback ptrs when needed */
33552 /* -----------------------------------------------------------------------------*/
33553
33554 static void
33555 SWIG_Python_FixMethods(PyMethodDef *methods,
33556 swig_const_info *const_table,
33557 swig_type_info **types,
33558 swig_type_info **types_initial) {
33559 size_t i;
33560 for (i = 0; methods[i].ml_name; ++i) {
33561 char *c = methods[i].ml_doc;
33562 if (c && (c = strstr(c, "swig_ptr: "))) {
33563 int j;
33564 swig_const_info *ci = 0;
33565 char *name = c + 10;
33566 for (j = 0; const_table[j].type; j++) {
33567 if (strncmp(const_table[j].name, name,
33568 strlen(const_table[j].name)) == 0) {
33569 ci = &(const_table[j]);
33570 break;
33571 }
33572 }
33573 if (ci) {
33574 size_t shift = (ci->ptype) - types;
33575 swig_type_info *ty = types_initial[shift];
33576 size_t ldoc = (c - methods[i].ml_doc);
33577 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33578 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33579 char *buff = ndoc;
33580 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33581 strncpy(buff, methods[i].ml_doc, ldoc);
33582 buff += ldoc;
33583 strncpy(buff, "swig_ptr: ", 10);
33584 buff += 10;
33585 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33586 methods[i].ml_doc = ndoc;
33587 }
33588 }
33589 }
33590 }
33591
33592 /* -----------------------------------------------------------------------------*
33593 * Initialize type list
33594 * -----------------------------------------------------------------------------*/
33595
33596 #if PY_MAJOR_VERSION < 2
33597 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33598 is copied out of Python/modsupport.c in python version 2.3.4 */
33599 static int
33600 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33601 {
33602 PyObject *dict;
33603 if (!PyModule_Check(m)) {
33604 PyErr_SetString(PyExc_TypeError,
33605 "PyModule_AddObject() needs module as first arg");
33606 return -1;
33607 }
33608 if (!o) {
33609 PyErr_SetString(PyExc_TypeError,
33610 "PyModule_AddObject() needs non-NULL value");
33611 return -1;
33612 }
33613
33614 dict = PyModule_GetDict(m);
33615 if (dict == NULL) {
33616 /* Internal error -- modules must have a dict! */
33617 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33618 PyModule_GetName(m));
33619 return -1;
33620 }
33621 if (PyDict_SetItemString(dict, name, o))
33622 return -1;
33623 Py_DECREF(o);
33624 return 0;
33625 }
33626 #endif
33627
33628 static swig_type_info **
33629 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33630 static PyMethodDef swig_empty_runtime_method_table[] = {
33631 {
33632 NULL, NULL, 0, NULL
33633 }
33634 };/* Sentinel */
33635
33636 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33637 swig_empty_runtime_method_table);
33638 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33639 if (pointer && module) {
33640 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33641 }
33642 return type_list_handle;
33643 }
33644
33645 static swig_type_info **
33646 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33647 swig_type_info **type_pointer;
33648
33649 /* first check if module already created */
33650 type_pointer = SWIG_Python_GetTypeListHandle();
33651 if (type_pointer) {
33652 return type_pointer;
33653 } else {
33654 /* create a new module and variable */
33655 return SWIG_Python_SetTypeListHandle(type_list_handle);
33656 }
33657 }
33658
33659 #ifdef __cplusplus
33660 }
33661 #endif
33662
33663 /* -----------------------------------------------------------------------------*
33664 * Partial Init method
33665 * -----------------------------------------------------------------------------*/
33666
33667 #ifdef SWIG_LINK_RUNTIME
33668 #ifdef __cplusplus
33669 extern "C"
33670 #endif
33671 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33672 #endif
33673
33674 #ifdef __cplusplus
33675 extern "C"
33676 #endif
33677 SWIGEXPORT(void) SWIG_init(void) {
33678 static PyObject *SWIG_globals = 0;
33679 static int typeinit = 0;
33680 PyObject *m, *d;
33681 int i;
33682 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33683
33684 /* Fix SwigMethods to carry the callback ptrs when needed */
33685 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33686
33687 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33688 d = PyModule_GetDict(m);
33689
33690 if (!typeinit) {
33691 #ifdef SWIG_LINK_RUNTIME
33692 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33693 #else
33694 # ifndef SWIG_STATIC_RUNTIME
33695 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33696 # endif
33697 #endif
33698 for (i = 0; swig_types_initial[i]; i++) {
33699 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33700 }
33701 typeinit = 1;
33702 }
33703 SWIG_InstallConstants(d,swig_const_table);
33704
33705 {
33706 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33977 }
33978 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33979 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33980 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33981 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33982 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33983 {
33984 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33994 }
33995 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33996
33997 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33998
33999 {
34000 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
34031 }
34032 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
34033 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
34034 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
34035 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
34036 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
34037 {
34038 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
34129 }
34130 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
34131 {
34132 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
34145 }
34146
34147 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
34148
34149 {
34150 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
34169 }
34170 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
34171 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
34172 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
34173 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
34174 {
34175 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
34197 }
34198 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
34199 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
34200 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
34201 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
34202 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
34203 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
34204 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
34205 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
34206 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
34207 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
34208 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
34209 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
34210 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
34211 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
34212 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
34213 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
34214 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
34215 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
34216 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
34217 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
34218 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
34219 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
34220 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
34221 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
34222 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
34223 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
34224 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
34225 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
34226 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
34227 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
34228 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
34229 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
34230 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
34231 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
34232 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
34233 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
34234 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
34235 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
34236 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
34237 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
34238 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
34239 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
34240 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
34241 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
34242 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
34243 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
34244 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
34245 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
34246 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
34247 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
34248 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
34249 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
34250 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
34251 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
34252 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
34253 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
34254 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
34255
34256 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
34257
34258 {
34259 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
34266 }
34267 {
34268 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
34284 }
34285 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
34286 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
34287 {
34288 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34403 }
34404 {
34405 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34406 }
34407 {
34408 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34409 }
34410 {
34411 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34412 }
34413 {
34414 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34415 }
34416 {
34417 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34418 }
34419 {
34420 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34460 }
34461 {
34462 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34463 }
34464 {
34465 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34466 }
34467 {
34468 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34469 }
34470 {
34471 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34472 }
34473 {
34474 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34475 }
34476 {
34477 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34478 }
34479 {
34480 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34481 }
34482 {
34483 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34484 }
34485 {
34486 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34487 }
34488 {
34489 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34490 }
34491 {
34492 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34493 }
34494 {
34495 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34496 }
34497 {
34498 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34499 }
34500 {
34501 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34502 }
34503 {
34504 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34505 }
34506 {
34507 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34508 }
34509 {
34510 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34511 }
34512 {
34513 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34514 }
34515 {
34516 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34517 }
34518 {
34519 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34520 }
34521 {
34522 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34523 }
34524 {
34525 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34526 }
34527 {
34528 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34529 }
34530 {
34531 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34532 }
34533 {
34534 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34535 }
34536 {
34537 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34538 }
34539 {
34540 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34541 }
34542 {
34543 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34544 }
34545 {
34546 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34547 }
34548 {
34549 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34550 }
34551 {
34552 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34553 }
34554 {
34555 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34556 }
34557 {
34558 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34559 }
34560 {
34561 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34562 }
34563 {
34564 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34565 }
34566 {
34567 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34568 }
34569 {
34570 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34571 }
34572 {
34573 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34574 }
34575 {
34576 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34577 }
34578 {
34579 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34580 }
34581 {
34582 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34583 }
34584 {
34585 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34586 }
34587 {
34588 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34589 }
34590 {
34591 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34592 }
34593 {
34594 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34595 }
34596 {
34597 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34598 }
34599 {
34600 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34601 }
34602 {
34603 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34604 }
34605 {
34606 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34607 }
34608 {
34609 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34610 }
34611 {
34612 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34613 }
34614 {
34615 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34616 }
34617 {
34618 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34619 }
34620 {
34621 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34622 }
34623 {
34624 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34625 }
34626 {
34627 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34628 }
34629 {
34630 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34631 }
34632 {
34633 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34634 }
34635 {
34636 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34637 }
34638 {
34639 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34640 }
34641 {
34642 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34643 }
34644 {
34645 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34646 }
34647 {
34648 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34649 }
34650 {
34651 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34652 }
34653 {
34654 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34655 }
34656 {
34657 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34658 }
34659 {
34660 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34661 }
34662 {
34663 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34664 }
34665 {
34666 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34667 }
34668 {
34669 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34670 }
34671 {
34672 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34673 }
34674 {
34675 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34676 }
34677 {
34678 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34679 }
34680 {
34681 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34682 }
34683 {
34684 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34685 }
34686 {
34687 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34688 }
34689 {
34690 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34691 }
34692 {
34693 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34694 }
34695 {
34696 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34697 }
34698 {
34699 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34700 }
34701 {
34702 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34703 }
34704 {
34705 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34706 }
34707 {
34708 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34709 }
34710 {
34711 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34712 }
34713 {
34714 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34715 }
34716 {
34717 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34718 }
34719 {
34720 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34721 }
34722 {
34723 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34724 }
34725 {
34726 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34727 }
34728 {
34729 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34730 }
34731 {
34732 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34733 }
34734 {
34735 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34736 }
34737 {
34738 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34739 }
34740 {
34741 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34742 }
34743 {
34744 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34745 }
34746 {
34747 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34748 }
34749 {
34750 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34751 }
34752 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34753 {
34754 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34755 }
34756 {
34757 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34758 }
34759 {
34760 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34761 }
34762 {
34763 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34764 }
34765 {
34766 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34767 }
34768 {
34769 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34770 }
34771 {
34772 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34773 }
34774 {
34775 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34776 }
34777 {
34778 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34779 }
34780 {
34781 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34782 }
34783 {
34784 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34785 }
34786 {
34787 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34788 }
34789 {
34790 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34791 }
34792 {
34793 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34794 }
34795 {
34796 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34797 }
34798 {
34799 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34800 }
34801 {
34802 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34803 }
34804 {
34805 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34806 }
34807 {
34808 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34809 }
34810 {
34811 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34812 }
34813 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34814 {
34815 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34816 }
34817 {
34818 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34819 }
34820 {
34821 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34822 }
34823 {
34824 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34825 }
34826 {
34827 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34828 }
34829 {
34830 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34831 }
34832 {
34833 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34834 }
34835 {
34836 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34837 }
34838 {
34839 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34840 }
34841 {
34842 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34843 }
34844 {
34845 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34846 }
34847 {
34848 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34849 }
34850
34851 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34852 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34853 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34854 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34855
34856 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34857 }
34858
wxWidgets (Impactor)