]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
determine the slider event type more precisely (i.e. generate LINE/PAGE UP/DOWN and...
[wxWidgets.git] / wxPython / src / msw / _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 /*@C:\\SWIG-1.3.24\\Lib\\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 /*@C:\\SWIG-1.3.24\\Lib\\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 iconIndex = loc.GetIndex();
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 /*@C:\\SWIG-1.3.24\\Lib\\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 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2547 #define SWIG_From_unsigned_SS_int SWIG_From_long
2548 /*@@*/
2549 #else
2550 /*@C:\\SWIG-1.3.24\\Lib\\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_Append(list, obj);
2649 Py_DECREF(obj);
2650 }
2651 wxPyEndBlockThreads(blocked);
2652 delete [] formats;
2653 return list;
2654 }
2655 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2656 PyObject* rval = NULL;
2657 size_t size = self->GetDataSize(format);
2658 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2659 if (size) {
2660 char* buf = new char[size];
2661 if (self->GetDataHere(format, buf))
2662 rval = PyString_FromStringAndSize(buf, size);
2663 delete [] buf;
2664 }
2665 if (! rval) {
2666 rval = Py_None;
2667 Py_INCREF(rval);
2668 }
2669 wxPyEndBlockThreads(blocked);
2670 return rval;
2671 }
2672 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2673 bool rval;
2674 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2675 if (PyString_Check(data)) {
2676 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2677 }
2678 else {
2679 // raise a TypeError if not a string
2680 PyErr_SetString(PyExc_TypeError, "String expected.");
2681 rval = false;
2682 }
2683 wxPyEndBlockThreads(blocked);
2684 return rval;
2685 }
2686 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2687 PyObject* rval = NULL;
2688 size_t size = self->GetDataSize();
2689 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2690 if (size) {
2691 char* buf = new char[size];
2692 if (self->GetDataHere(buf))
2693 rval = PyString_FromStringAndSize(buf, size);
2694 delete [] buf;
2695 }
2696 if (! rval) {
2697 rval = Py_None;
2698 Py_INCREF(rval);
2699 }
2700 wxPyEndBlockThreads(blocked);
2701 return rval;
2702 }
2703 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2704 bool rval;
2705 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2706 if (PyString_Check(data)) {
2707 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2708 }
2709 else {
2710 // raise a TypeError if not a string
2711 PyErr_SetString(PyExc_TypeError, "String expected.");
2712 rval = false;
2713 }
2714 wxPyEndBlockThreads(blocked);
2715 return rval;
2716 }
2717 // Create a new class for wxPython to use
2718 class wxPyDataObjectSimple : public wxDataObjectSimple {
2719 public:
2720 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2721 : wxDataObjectSimple(format) {}
2722
2723 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2724 bool GetDataHere(void *buf) const;
2725 bool SetData(size_t len, const void *buf) const;
2726 PYPRIVATE;
2727 };
2728
2729 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2730
2731 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2732 // We need to get the data for this object and write it to buf. I think
2733 // the best way to do this for wxPython is to have the Python method
2734 // return either a string or None and then act appropriately with the
2735 // C++ version.
2736
2737 bool rval = false;
2738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2739 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2740 PyObject* ro;
2741 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2742 if (ro) {
2743 rval = (ro != Py_None && PyString_Check(ro));
2744 if (rval)
2745 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2746 Py_DECREF(ro);
2747 }
2748 }
2749 wxPyEndBlockThreads(blocked);
2750 return rval;
2751 }
2752
2753 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2754 // For this one we simply need to make a string from buf and len
2755 // and send it to the Python method.
2756 bool rval = false;
2757 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2758 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2759 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2760 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2761 Py_DECREF(data);
2762 }
2763 wxPyEndBlockThreads(blocked);
2764 return rval;
2765 }
2766
2767 // Create a new class for wxPython to use
2768 class wxPyTextDataObject : public wxTextDataObject {
2769 public:
2770 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2771 : wxTextDataObject(text) {}
2772
2773 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2774 DEC_PYCALLBACK_STRING__const(GetText);
2775 DEC_PYCALLBACK__STRING(SetText);
2776 PYPRIVATE;
2777 };
2778
2779 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2780 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2781 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2782
2783
2784 // Create a new class for wxPython to use
2785 class wxPyBitmapDataObject : public wxBitmapDataObject {
2786 public:
2787 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2788 : wxBitmapDataObject(bitmap) {}
2789
2790 wxBitmap GetBitmap() const;
2791 void SetBitmap(const wxBitmap& bitmap);
2792 PYPRIVATE;
2793 };
2794
2795 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2796 wxBitmap* rval = &wxNullBitmap;
2797 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2798 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2799 PyObject* ro;
2800 wxBitmap* ptr;
2801 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2802 if (ro) {
2803 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2804 rval = ptr;
2805 Py_DECREF(ro);
2806 }
2807 }
2808 wxPyEndBlockThreads(blocked);
2809 return *rval;
2810 }
2811
2812 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2814 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2815 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2816 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2817 Py_DECREF(bo);
2818 }
2819 wxPyEndBlockThreads(blocked);
2820 }
2821
2822 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2823 return new wxCustomDataObject(wxDataFormat(formatName));
2824 }
2825 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2826 bool rval;
2827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2828 if (PyString_Check(data)) {
2829 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2830 }
2831 else {
2832 // raise a TypeError if not a string
2833 PyErr_SetString(PyExc_TypeError, "String expected.");
2834 rval = false;
2835 }
2836 wxPyEndBlockThreads(blocked);
2837 return rval;
2838 }
2839 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2840 PyObject* obj;
2841 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2842 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2843 wxPyEndBlockThreads(blocked);
2844 return obj;
2845 }
2846
2847 #include <wx/metafile.h>
2848
2849
2850 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2851
2852
2853 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2854 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2855 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2856 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2857 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2858
2859
2860 class wxPyTextDropTarget : public wxTextDropTarget {
2861 public:
2862 wxPyTextDropTarget() {}
2863
2864 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2865
2866 DEC_PYCALLBACK__(OnLeave);
2867 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2868 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2869 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2870 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2871
2872 PYPRIVATE;
2873 };
2874
2875 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2876 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2877 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2878 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2879 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2880 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2881
2882
2883
2884 class wxPyFileDropTarget : public wxFileDropTarget {
2885 public:
2886 wxPyFileDropTarget() {}
2887
2888 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2889
2890 DEC_PYCALLBACK__(OnLeave);
2891 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2892 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2893 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2894 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2895
2896 PYPRIVATE;
2897 };
2898
2899 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2900 const wxArrayString& filenames) {
2901 bool rval = false;
2902 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2903 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2904 PyObject* list = wxArrayString2PyList_helper(filenames);
2905 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2906 Py_DECREF(list);
2907 }
2908 wxPyEndBlockThreads(blocked);
2909 return rval;
2910 }
2911
2912
2913
2914 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2915 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2916 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2917 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2918 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2919
2920
2921
2922
2923 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2924
2925 #include <wx/display.h>
2926
2927 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2928 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2929
2930 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2931 #if !wxUSE_DISPLAY
2932 #include <wx/dynarray.h>
2933 #include <wx/vidmode.h>
2934
2935 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2936 #include "wx/arrimpl.cpp"
2937 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2938 const wxVideoMode wxDefaultVideoMode;
2939
2940 class wxDisplay
2941 {
2942 public:
2943 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2944 ~wxDisplay() {}
2945
2946 static size_t GetCount()
2947 { wxPyRaiseNotImplemented(); return 0; }
2948
2949 static int GetFromPoint(const wxPoint& pt)
2950 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2951 static int GetFromWindow(wxWindow *window)
2952 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2953
2954 virtual bool IsOk() const { return false; }
2955 virtual wxRect GetGeometry() const { wxRect r; return r; }
2956 virtual wxString GetName() const { return wxEmptyString; }
2957 bool IsPrimary() const { return false; }
2958
2959 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2960 { wxArrayVideoModes a; return a; }
2961
2962 virtual wxVideoMode GetCurrentMode() const
2963 { return wxDefaultVideoMode; }
2964
2965 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2966 { return false; }
2967
2968 void ResetMode() {}
2969 };
2970 #endif
2971
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_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21392 PyObject *resultobj;
21393 wxDateTime *arg1 = (wxDateTime *) 0 ;
21394 bool arg2 = (bool) false ;
21395 wxDateTime result;
21396 PyObject * obj0 = 0 ;
21397 PyObject * obj1 = 0 ;
21398 char *kwnames[] = {
21399 (char *) "self",(char *) "noDST", NULL
21400 };
21401
21402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21404 if (SWIG_arg_fail(1)) SWIG_fail;
21405 if (obj1) {
21406 {
21407 arg2 = (bool)(SWIG_As_bool(obj1));
21408 if (SWIG_arg_fail(2)) SWIG_fail;
21409 }
21410 }
21411 {
21412 PyThreadState* __tstate = wxPyBeginAllowThreads();
21413 result = (arg1)->ToGMT(arg2);
21414
21415 wxPyEndAllowThreads(__tstate);
21416 if (PyErr_Occurred()) SWIG_fail;
21417 }
21418 {
21419 wxDateTime * resultptr;
21420 resultptr = new wxDateTime((wxDateTime &)(result));
21421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21422 }
21423 return resultobj;
21424 fail:
21425 return NULL;
21426 }
21427
21428
21429 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21430 PyObject *resultobj;
21431 wxDateTime *arg1 = (wxDateTime *) 0 ;
21432 bool arg2 = (bool) false ;
21433 wxDateTime *result;
21434 PyObject * obj0 = 0 ;
21435 PyObject * obj1 = 0 ;
21436 char *kwnames[] = {
21437 (char *) "self",(char *) "noDST", NULL
21438 };
21439
21440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21442 if (SWIG_arg_fail(1)) SWIG_fail;
21443 if (obj1) {
21444 {
21445 arg2 = (bool)(SWIG_As_bool(obj1));
21446 if (SWIG_arg_fail(2)) SWIG_fail;
21447 }
21448 }
21449 {
21450 PyThreadState* __tstate = wxPyBeginAllowThreads();
21451 {
21452 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21453 result = (wxDateTime *) &_result_ref;
21454 }
21455
21456 wxPyEndAllowThreads(__tstate);
21457 if (PyErr_Occurred()) SWIG_fail;
21458 }
21459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21460 return resultobj;
21461 fail:
21462 return NULL;
21463 }
21464
21465
21466 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21467 PyObject *resultobj;
21468 wxDateTime *arg1 = (wxDateTime *) 0 ;
21469 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21470 int result;
21471 PyObject * obj0 = 0 ;
21472 PyObject * obj1 = 0 ;
21473 char *kwnames[] = {
21474 (char *) "self",(char *) "country", NULL
21475 };
21476
21477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21479 if (SWIG_arg_fail(1)) SWIG_fail;
21480 if (obj1) {
21481 {
21482 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21483 if (SWIG_arg_fail(2)) SWIG_fail;
21484 }
21485 }
21486 {
21487 PyThreadState* __tstate = wxPyBeginAllowThreads();
21488 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21489
21490 wxPyEndAllowThreads(__tstate);
21491 if (PyErr_Occurred()) SWIG_fail;
21492 }
21493 {
21494 resultobj = SWIG_From_int((int)(result));
21495 }
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21503 PyObject *resultobj;
21504 wxDateTime *arg1 = (wxDateTime *) 0 ;
21505 bool result;
21506 PyObject * obj0 = 0 ;
21507 char *kwnames[] = {
21508 (char *) "self", NULL
21509 };
21510
21511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21513 if (SWIG_arg_fail(1)) SWIG_fail;
21514 {
21515 PyThreadState* __tstate = wxPyBeginAllowThreads();
21516 result = (bool)((wxDateTime const *)arg1)->IsValid();
21517
21518 wxPyEndAllowThreads(__tstate);
21519 if (PyErr_Occurred()) SWIG_fail;
21520 }
21521 {
21522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21523 }
21524 return resultobj;
21525 fail:
21526 return NULL;
21527 }
21528
21529
21530 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj;
21532 wxDateTime *arg1 = (wxDateTime *) 0 ;
21533 time_t result;
21534 PyObject * obj0 = 0 ;
21535 char *kwnames[] = {
21536 (char *) "self", NULL
21537 };
21538
21539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21541 if (SWIG_arg_fail(1)) SWIG_fail;
21542 {
21543 PyThreadState* __tstate = wxPyBeginAllowThreads();
21544 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21545
21546 wxPyEndAllowThreads(__tstate);
21547 if (PyErr_Occurred()) SWIG_fail;
21548 }
21549 {
21550 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21551 }
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21559 PyObject *resultobj;
21560 wxDateTime *arg1 = (wxDateTime *) 0 ;
21561 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21562 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21563 int result;
21564 bool temp2 = false ;
21565 PyObject * obj0 = 0 ;
21566 PyObject * obj1 = 0 ;
21567 char *kwnames[] = {
21568 (char *) "self",(char *) "tz", NULL
21569 };
21570
21571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21573 if (SWIG_arg_fail(1)) SWIG_fail;
21574 if (obj1) {
21575 {
21576 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21577 temp2 = true;
21578 }
21579 }
21580 {
21581 PyThreadState* __tstate = wxPyBeginAllowThreads();
21582 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21583
21584 wxPyEndAllowThreads(__tstate);
21585 if (PyErr_Occurred()) SWIG_fail;
21586 }
21587 {
21588 resultobj = SWIG_From_int((int)(result));
21589 }
21590 {
21591 if (temp2) delete arg2;
21592 }
21593 return resultobj;
21594 fail:
21595 {
21596 if (temp2) delete arg2;
21597 }
21598 return NULL;
21599 }
21600
21601
21602 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21603 PyObject *resultobj;
21604 wxDateTime *arg1 = (wxDateTime *) 0 ;
21605 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21606 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21607 wxDateTime::Month result;
21608 bool temp2 = false ;
21609 PyObject * obj0 = 0 ;
21610 PyObject * obj1 = 0 ;
21611 char *kwnames[] = {
21612 (char *) "self",(char *) "tz", NULL
21613 };
21614
21615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21617 if (SWIG_arg_fail(1)) SWIG_fail;
21618 if (obj1) {
21619 {
21620 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21621 temp2 = true;
21622 }
21623 }
21624 {
21625 PyThreadState* __tstate = wxPyBeginAllowThreads();
21626 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21627
21628 wxPyEndAllowThreads(__tstate);
21629 if (PyErr_Occurred()) SWIG_fail;
21630 }
21631 resultobj = SWIG_From_int((result));
21632 {
21633 if (temp2) delete arg2;
21634 }
21635 return resultobj;
21636 fail:
21637 {
21638 if (temp2) delete arg2;
21639 }
21640 return NULL;
21641 }
21642
21643
21644 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj;
21646 wxDateTime *arg1 = (wxDateTime *) 0 ;
21647 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21648 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21649 int result;
21650 bool temp2 = false ;
21651 PyObject * obj0 = 0 ;
21652 PyObject * obj1 = 0 ;
21653 char *kwnames[] = {
21654 (char *) "self",(char *) "tz", NULL
21655 };
21656
21657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21659 if (SWIG_arg_fail(1)) SWIG_fail;
21660 if (obj1) {
21661 {
21662 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21663 temp2 = true;
21664 }
21665 }
21666 {
21667 PyThreadState* __tstate = wxPyBeginAllowThreads();
21668 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21669
21670 wxPyEndAllowThreads(__tstate);
21671 if (PyErr_Occurred()) SWIG_fail;
21672 }
21673 {
21674 resultobj = SWIG_From_int((int)(result));
21675 }
21676 {
21677 if (temp2) delete arg2;
21678 }
21679 return resultobj;
21680 fail:
21681 {
21682 if (temp2) delete arg2;
21683 }
21684 return NULL;
21685 }
21686
21687
21688 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21689 PyObject *resultobj;
21690 wxDateTime *arg1 = (wxDateTime *) 0 ;
21691 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21692 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21693 wxDateTime::WeekDay result;
21694 bool temp2 = false ;
21695 PyObject * obj0 = 0 ;
21696 PyObject * obj1 = 0 ;
21697 char *kwnames[] = {
21698 (char *) "self",(char *) "tz", NULL
21699 };
21700
21701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21703 if (SWIG_arg_fail(1)) SWIG_fail;
21704 if (obj1) {
21705 {
21706 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21707 temp2 = true;
21708 }
21709 }
21710 {
21711 PyThreadState* __tstate = wxPyBeginAllowThreads();
21712 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21713
21714 wxPyEndAllowThreads(__tstate);
21715 if (PyErr_Occurred()) SWIG_fail;
21716 }
21717 resultobj = SWIG_From_int((result));
21718 {
21719 if (temp2) delete arg2;
21720 }
21721 return resultobj;
21722 fail:
21723 {
21724 if (temp2) delete arg2;
21725 }
21726 return NULL;
21727 }
21728
21729
21730 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21731 PyObject *resultobj;
21732 wxDateTime *arg1 = (wxDateTime *) 0 ;
21733 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21734 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21735 int result;
21736 bool temp2 = false ;
21737 PyObject * obj0 = 0 ;
21738 PyObject * obj1 = 0 ;
21739 char *kwnames[] = {
21740 (char *) "self",(char *) "tz", NULL
21741 };
21742
21743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21745 if (SWIG_arg_fail(1)) SWIG_fail;
21746 if (obj1) {
21747 {
21748 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21749 temp2 = true;
21750 }
21751 }
21752 {
21753 PyThreadState* __tstate = wxPyBeginAllowThreads();
21754 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21755
21756 wxPyEndAllowThreads(__tstate);
21757 if (PyErr_Occurred()) SWIG_fail;
21758 }
21759 {
21760 resultobj = SWIG_From_int((int)(result));
21761 }
21762 {
21763 if (temp2) delete arg2;
21764 }
21765 return resultobj;
21766 fail:
21767 {
21768 if (temp2) delete arg2;
21769 }
21770 return NULL;
21771 }
21772
21773
21774 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21775 PyObject *resultobj;
21776 wxDateTime *arg1 = (wxDateTime *) 0 ;
21777 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21778 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21779 int result;
21780 bool temp2 = false ;
21781 PyObject * obj0 = 0 ;
21782 PyObject * obj1 = 0 ;
21783 char *kwnames[] = {
21784 (char *) "self",(char *) "tz", NULL
21785 };
21786
21787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21789 if (SWIG_arg_fail(1)) SWIG_fail;
21790 if (obj1) {
21791 {
21792 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21793 temp2 = true;
21794 }
21795 }
21796 {
21797 PyThreadState* __tstate = wxPyBeginAllowThreads();
21798 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21799
21800 wxPyEndAllowThreads(__tstate);
21801 if (PyErr_Occurred()) SWIG_fail;
21802 }
21803 {
21804 resultobj = SWIG_From_int((int)(result));
21805 }
21806 {
21807 if (temp2) delete arg2;
21808 }
21809 return resultobj;
21810 fail:
21811 {
21812 if (temp2) delete arg2;
21813 }
21814 return NULL;
21815 }
21816
21817
21818 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21819 PyObject *resultobj;
21820 wxDateTime *arg1 = (wxDateTime *) 0 ;
21821 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21822 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21823 int result;
21824 bool temp2 = false ;
21825 PyObject * obj0 = 0 ;
21826 PyObject * obj1 = 0 ;
21827 char *kwnames[] = {
21828 (char *) "self",(char *) "tz", NULL
21829 };
21830
21831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21833 if (SWIG_arg_fail(1)) SWIG_fail;
21834 if (obj1) {
21835 {
21836 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21837 temp2 = true;
21838 }
21839 }
21840 {
21841 PyThreadState* __tstate = wxPyBeginAllowThreads();
21842 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21843
21844 wxPyEndAllowThreads(__tstate);
21845 if (PyErr_Occurred()) SWIG_fail;
21846 }
21847 {
21848 resultobj = SWIG_From_int((int)(result));
21849 }
21850 {
21851 if (temp2) delete arg2;
21852 }
21853 return resultobj;
21854 fail:
21855 {
21856 if (temp2) delete arg2;
21857 }
21858 return NULL;
21859 }
21860
21861
21862 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21863 PyObject *resultobj;
21864 wxDateTime *arg1 = (wxDateTime *) 0 ;
21865 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21866 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21867 int result;
21868 bool temp2 = false ;
21869 PyObject * obj0 = 0 ;
21870 PyObject * obj1 = 0 ;
21871 char *kwnames[] = {
21872 (char *) "self",(char *) "tz", NULL
21873 };
21874
21875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21877 if (SWIG_arg_fail(1)) SWIG_fail;
21878 if (obj1) {
21879 {
21880 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21881 temp2 = true;
21882 }
21883 }
21884 {
21885 PyThreadState* __tstate = wxPyBeginAllowThreads();
21886 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21887
21888 wxPyEndAllowThreads(__tstate);
21889 if (PyErr_Occurred()) SWIG_fail;
21890 }
21891 {
21892 resultobj = SWIG_From_int((int)(result));
21893 }
21894 {
21895 if (temp2) delete arg2;
21896 }
21897 return resultobj;
21898 fail:
21899 {
21900 if (temp2) delete arg2;
21901 }
21902 return NULL;
21903 }
21904
21905
21906 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21907 PyObject *resultobj;
21908 wxDateTime *arg1 = (wxDateTime *) 0 ;
21909 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21910 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21911 int result;
21912 bool temp2 = false ;
21913 PyObject * obj0 = 0 ;
21914 PyObject * obj1 = 0 ;
21915 char *kwnames[] = {
21916 (char *) "self",(char *) "tz", NULL
21917 };
21918
21919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21921 if (SWIG_arg_fail(1)) SWIG_fail;
21922 if (obj1) {
21923 {
21924 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21925 temp2 = true;
21926 }
21927 }
21928 {
21929 PyThreadState* __tstate = wxPyBeginAllowThreads();
21930 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21931
21932 wxPyEndAllowThreads(__tstate);
21933 if (PyErr_Occurred()) SWIG_fail;
21934 }
21935 {
21936 resultobj = SWIG_From_int((int)(result));
21937 }
21938 {
21939 if (temp2) delete arg2;
21940 }
21941 return resultobj;
21942 fail:
21943 {
21944 if (temp2) delete arg2;
21945 }
21946 return NULL;
21947 }
21948
21949
21950 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21951 PyObject *resultobj;
21952 wxDateTime *arg1 = (wxDateTime *) 0 ;
21953 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21954 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21955 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21956 int result;
21957 bool temp3 = false ;
21958 PyObject * obj0 = 0 ;
21959 PyObject * obj1 = 0 ;
21960 PyObject * obj2 = 0 ;
21961 char *kwnames[] = {
21962 (char *) "self",(char *) "flags",(char *) "tz", NULL
21963 };
21964
21965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21967 if (SWIG_arg_fail(1)) SWIG_fail;
21968 if (obj1) {
21969 {
21970 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21971 if (SWIG_arg_fail(2)) SWIG_fail;
21972 }
21973 }
21974 if (obj2) {
21975 {
21976 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21977 temp3 = true;
21978 }
21979 }
21980 {
21981 PyThreadState* __tstate = wxPyBeginAllowThreads();
21982 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21983
21984 wxPyEndAllowThreads(__tstate);
21985 if (PyErr_Occurred()) SWIG_fail;
21986 }
21987 {
21988 resultobj = SWIG_From_int((int)(result));
21989 }
21990 {
21991 if (temp3) delete arg3;
21992 }
21993 return resultobj;
21994 fail:
21995 {
21996 if (temp3) delete arg3;
21997 }
21998 return NULL;
21999 }
22000
22001
22002 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22003 PyObject *resultobj;
22004 wxDateTime *arg1 = (wxDateTime *) 0 ;
22005 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22006 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22007 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22008 int result;
22009 bool temp3 = false ;
22010 PyObject * obj0 = 0 ;
22011 PyObject * obj1 = 0 ;
22012 PyObject * obj2 = 0 ;
22013 char *kwnames[] = {
22014 (char *) "self",(char *) "flags",(char *) "tz", NULL
22015 };
22016
22017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22019 if (SWIG_arg_fail(1)) SWIG_fail;
22020 if (obj1) {
22021 {
22022 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22023 if (SWIG_arg_fail(2)) SWIG_fail;
22024 }
22025 }
22026 if (obj2) {
22027 {
22028 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22029 temp3 = true;
22030 }
22031 }
22032 {
22033 PyThreadState* __tstate = wxPyBeginAllowThreads();
22034 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22035
22036 wxPyEndAllowThreads(__tstate);
22037 if (PyErr_Occurred()) SWIG_fail;
22038 }
22039 {
22040 resultobj = SWIG_From_int((int)(result));
22041 }
22042 {
22043 if (temp3) delete arg3;
22044 }
22045 return resultobj;
22046 fail:
22047 {
22048 if (temp3) delete arg3;
22049 }
22050 return NULL;
22051 }
22052
22053
22054 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22055 PyObject *resultobj;
22056 wxDateTime *arg1 = (wxDateTime *) 0 ;
22057 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22058 bool result;
22059 PyObject * obj0 = 0 ;
22060 PyObject * obj1 = 0 ;
22061 char *kwnames[] = {
22062 (char *) "self",(char *) "country", NULL
22063 };
22064
22065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22067 if (SWIG_arg_fail(1)) SWIG_fail;
22068 if (obj1) {
22069 {
22070 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22071 if (SWIG_arg_fail(2)) SWIG_fail;
22072 }
22073 }
22074 {
22075 PyThreadState* __tstate = wxPyBeginAllowThreads();
22076 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22077
22078 wxPyEndAllowThreads(__tstate);
22079 if (PyErr_Occurred()) SWIG_fail;
22080 }
22081 {
22082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22083 }
22084 return resultobj;
22085 fail:
22086 return NULL;
22087 }
22088
22089
22090 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22091 PyObject *resultobj;
22092 wxDateTime *arg1 = (wxDateTime *) 0 ;
22093 wxDateTime *arg2 = 0 ;
22094 bool result;
22095 PyObject * obj0 = 0 ;
22096 PyObject * obj1 = 0 ;
22097 char *kwnames[] = {
22098 (char *) "self",(char *) "datetime", NULL
22099 };
22100
22101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22103 if (SWIG_arg_fail(1)) SWIG_fail;
22104 {
22105 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22106 if (SWIG_arg_fail(2)) SWIG_fail;
22107 if (arg2 == NULL) {
22108 SWIG_null_ref("wxDateTime");
22109 }
22110 if (SWIG_arg_fail(2)) SWIG_fail;
22111 }
22112 {
22113 PyThreadState* __tstate = wxPyBeginAllowThreads();
22114 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22115
22116 wxPyEndAllowThreads(__tstate);
22117 if (PyErr_Occurred()) SWIG_fail;
22118 }
22119 {
22120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22121 }
22122 return resultobj;
22123 fail:
22124 return NULL;
22125 }
22126
22127
22128 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22129 PyObject *resultobj;
22130 wxDateTime *arg1 = (wxDateTime *) 0 ;
22131 wxDateTime *arg2 = 0 ;
22132 bool result;
22133 PyObject * obj0 = 0 ;
22134 PyObject * obj1 = 0 ;
22135 char *kwnames[] = {
22136 (char *) "self",(char *) "datetime", NULL
22137 };
22138
22139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22141 if (SWIG_arg_fail(1)) SWIG_fail;
22142 {
22143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22144 if (SWIG_arg_fail(2)) SWIG_fail;
22145 if (arg2 == NULL) {
22146 SWIG_null_ref("wxDateTime");
22147 }
22148 if (SWIG_arg_fail(2)) SWIG_fail;
22149 }
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22153
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 {
22158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22159 }
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22167 PyObject *resultobj;
22168 wxDateTime *arg1 = (wxDateTime *) 0 ;
22169 wxDateTime *arg2 = 0 ;
22170 bool result;
22171 PyObject * obj0 = 0 ;
22172 PyObject * obj1 = 0 ;
22173 char *kwnames[] = {
22174 (char *) "self",(char *) "datetime", NULL
22175 };
22176
22177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22179 if (SWIG_arg_fail(1)) SWIG_fail;
22180 {
22181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22182 if (SWIG_arg_fail(2)) SWIG_fail;
22183 if (arg2 == NULL) {
22184 SWIG_null_ref("wxDateTime");
22185 }
22186 if (SWIG_arg_fail(2)) SWIG_fail;
22187 }
22188 {
22189 PyThreadState* __tstate = wxPyBeginAllowThreads();
22190 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22191
22192 wxPyEndAllowThreads(__tstate);
22193 if (PyErr_Occurred()) SWIG_fail;
22194 }
22195 {
22196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22197 }
22198 return resultobj;
22199 fail:
22200 return NULL;
22201 }
22202
22203
22204 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22205 PyObject *resultobj;
22206 wxDateTime *arg1 = (wxDateTime *) 0 ;
22207 wxDateTime *arg2 = 0 ;
22208 wxDateTime *arg3 = 0 ;
22209 bool result;
22210 PyObject * obj0 = 0 ;
22211 PyObject * obj1 = 0 ;
22212 PyObject * obj2 = 0 ;
22213 char *kwnames[] = {
22214 (char *) "self",(char *) "t1",(char *) "t2", NULL
22215 };
22216
22217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22219 if (SWIG_arg_fail(1)) SWIG_fail;
22220 {
22221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22222 if (SWIG_arg_fail(2)) SWIG_fail;
22223 if (arg2 == NULL) {
22224 SWIG_null_ref("wxDateTime");
22225 }
22226 if (SWIG_arg_fail(2)) SWIG_fail;
22227 }
22228 {
22229 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22230 if (SWIG_arg_fail(3)) SWIG_fail;
22231 if (arg3 == NULL) {
22232 SWIG_null_ref("wxDateTime");
22233 }
22234 if (SWIG_arg_fail(3)) SWIG_fail;
22235 }
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22239
22240 wxPyEndAllowThreads(__tstate);
22241 if (PyErr_Occurred()) SWIG_fail;
22242 }
22243 {
22244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22245 }
22246 return resultobj;
22247 fail:
22248 return NULL;
22249 }
22250
22251
22252 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22253 PyObject *resultobj;
22254 wxDateTime *arg1 = (wxDateTime *) 0 ;
22255 wxDateTime *arg2 = 0 ;
22256 wxDateTime *arg3 = 0 ;
22257 bool result;
22258 PyObject * obj0 = 0 ;
22259 PyObject * obj1 = 0 ;
22260 PyObject * obj2 = 0 ;
22261 char *kwnames[] = {
22262 (char *) "self",(char *) "t1",(char *) "t2", NULL
22263 };
22264
22265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22267 if (SWIG_arg_fail(1)) SWIG_fail;
22268 {
22269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22270 if (SWIG_arg_fail(2)) SWIG_fail;
22271 if (arg2 == NULL) {
22272 SWIG_null_ref("wxDateTime");
22273 }
22274 if (SWIG_arg_fail(2)) SWIG_fail;
22275 }
22276 {
22277 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22278 if (SWIG_arg_fail(3)) SWIG_fail;
22279 if (arg3 == NULL) {
22280 SWIG_null_ref("wxDateTime");
22281 }
22282 if (SWIG_arg_fail(3)) SWIG_fail;
22283 }
22284 {
22285 PyThreadState* __tstate = wxPyBeginAllowThreads();
22286 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22287
22288 wxPyEndAllowThreads(__tstate);
22289 if (PyErr_Occurred()) SWIG_fail;
22290 }
22291 {
22292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22293 }
22294 return resultobj;
22295 fail:
22296 return NULL;
22297 }
22298
22299
22300 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22301 PyObject *resultobj;
22302 wxDateTime *arg1 = (wxDateTime *) 0 ;
22303 wxDateTime *arg2 = 0 ;
22304 bool result;
22305 PyObject * obj0 = 0 ;
22306 PyObject * obj1 = 0 ;
22307 char *kwnames[] = {
22308 (char *) "self",(char *) "dt", NULL
22309 };
22310
22311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22313 if (SWIG_arg_fail(1)) SWIG_fail;
22314 {
22315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22316 if (SWIG_arg_fail(2)) SWIG_fail;
22317 if (arg2 == NULL) {
22318 SWIG_null_ref("wxDateTime");
22319 }
22320 if (SWIG_arg_fail(2)) SWIG_fail;
22321 }
22322 {
22323 PyThreadState* __tstate = wxPyBeginAllowThreads();
22324 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22325
22326 wxPyEndAllowThreads(__tstate);
22327 if (PyErr_Occurred()) SWIG_fail;
22328 }
22329 {
22330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22331 }
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22339 PyObject *resultobj;
22340 wxDateTime *arg1 = (wxDateTime *) 0 ;
22341 wxDateTime *arg2 = 0 ;
22342 bool result;
22343 PyObject * obj0 = 0 ;
22344 PyObject * obj1 = 0 ;
22345 char *kwnames[] = {
22346 (char *) "self",(char *) "dt", NULL
22347 };
22348
22349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22351 if (SWIG_arg_fail(1)) SWIG_fail;
22352 {
22353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22354 if (SWIG_arg_fail(2)) SWIG_fail;
22355 if (arg2 == NULL) {
22356 SWIG_null_ref("wxDateTime");
22357 }
22358 if (SWIG_arg_fail(2)) SWIG_fail;
22359 }
22360 {
22361 PyThreadState* __tstate = wxPyBeginAllowThreads();
22362 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22363
22364 wxPyEndAllowThreads(__tstate);
22365 if (PyErr_Occurred()) SWIG_fail;
22366 }
22367 {
22368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22369 }
22370 return resultobj;
22371 fail:
22372 return NULL;
22373 }
22374
22375
22376 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22377 PyObject *resultobj;
22378 wxDateTime *arg1 = (wxDateTime *) 0 ;
22379 wxDateTime *arg2 = 0 ;
22380 wxTimeSpan *arg3 = 0 ;
22381 bool result;
22382 PyObject * obj0 = 0 ;
22383 PyObject * obj1 = 0 ;
22384 PyObject * obj2 = 0 ;
22385 char *kwnames[] = {
22386 (char *) "self",(char *) "dt",(char *) "ts", NULL
22387 };
22388
22389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22391 if (SWIG_arg_fail(1)) SWIG_fail;
22392 {
22393 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22394 if (SWIG_arg_fail(2)) SWIG_fail;
22395 if (arg2 == NULL) {
22396 SWIG_null_ref("wxDateTime");
22397 }
22398 if (SWIG_arg_fail(2)) SWIG_fail;
22399 }
22400 {
22401 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22402 if (SWIG_arg_fail(3)) SWIG_fail;
22403 if (arg3 == NULL) {
22404 SWIG_null_ref("wxTimeSpan");
22405 }
22406 if (SWIG_arg_fail(3)) SWIG_fail;
22407 }
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22411
22412 wxPyEndAllowThreads(__tstate);
22413 if (PyErr_Occurred()) SWIG_fail;
22414 }
22415 {
22416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22417 }
22418 return resultobj;
22419 fail:
22420 return NULL;
22421 }
22422
22423
22424 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22425 PyObject *resultobj;
22426 wxDateTime *arg1 = (wxDateTime *) 0 ;
22427 wxTimeSpan *arg2 = 0 ;
22428 wxDateTime *result;
22429 PyObject * obj0 = 0 ;
22430 PyObject * obj1 = 0 ;
22431 char *kwnames[] = {
22432 (char *) "self",(char *) "diff", NULL
22433 };
22434
22435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22437 if (SWIG_arg_fail(1)) SWIG_fail;
22438 {
22439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22440 if (SWIG_arg_fail(2)) SWIG_fail;
22441 if (arg2 == NULL) {
22442 SWIG_null_ref("wxTimeSpan");
22443 }
22444 if (SWIG_arg_fail(2)) SWIG_fail;
22445 }
22446 {
22447 PyThreadState* __tstate = wxPyBeginAllowThreads();
22448 {
22449 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22450 result = (wxDateTime *) &_result_ref;
22451 }
22452
22453 wxPyEndAllowThreads(__tstate);
22454 if (PyErr_Occurred()) SWIG_fail;
22455 }
22456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22464 PyObject *resultobj;
22465 wxDateTime *arg1 = (wxDateTime *) 0 ;
22466 wxDateSpan *arg2 = 0 ;
22467 wxDateTime *result;
22468 PyObject * obj0 = 0 ;
22469 PyObject * obj1 = 0 ;
22470 char *kwnames[] = {
22471 (char *) "self",(char *) "diff", NULL
22472 };
22473
22474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 {
22478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22479 if (SWIG_arg_fail(2)) SWIG_fail;
22480 if (arg2 == NULL) {
22481 SWIG_null_ref("wxDateSpan");
22482 }
22483 if (SWIG_arg_fail(2)) SWIG_fail;
22484 }
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 {
22488 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22489 result = (wxDateTime *) &_result_ref;
22490 }
22491
22492 wxPyEndAllowThreads(__tstate);
22493 if (PyErr_Occurred()) SWIG_fail;
22494 }
22495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22496 return resultobj;
22497 fail:
22498 return NULL;
22499 }
22500
22501
22502 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22503 PyObject *resultobj;
22504 wxDateTime *arg1 = (wxDateTime *) 0 ;
22505 wxTimeSpan *arg2 = 0 ;
22506 wxDateTime *result;
22507 PyObject * obj0 = 0 ;
22508 PyObject * obj1 = 0 ;
22509 char *kwnames[] = {
22510 (char *) "self",(char *) "diff", NULL
22511 };
22512
22513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22515 if (SWIG_arg_fail(1)) SWIG_fail;
22516 {
22517 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22518 if (SWIG_arg_fail(2)) SWIG_fail;
22519 if (arg2 == NULL) {
22520 SWIG_null_ref("wxTimeSpan");
22521 }
22522 if (SWIG_arg_fail(2)) SWIG_fail;
22523 }
22524 {
22525 PyThreadState* __tstate = wxPyBeginAllowThreads();
22526 {
22527 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22528 result = (wxDateTime *) &_result_ref;
22529 }
22530
22531 wxPyEndAllowThreads(__tstate);
22532 if (PyErr_Occurred()) SWIG_fail;
22533 }
22534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22535 return resultobj;
22536 fail:
22537 return NULL;
22538 }
22539
22540
22541 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22542 PyObject *resultobj;
22543 wxDateTime *arg1 = (wxDateTime *) 0 ;
22544 wxDateSpan *arg2 = 0 ;
22545 wxDateTime *result;
22546 PyObject * obj0 = 0 ;
22547 PyObject * obj1 = 0 ;
22548 char *kwnames[] = {
22549 (char *) "self",(char *) "diff", NULL
22550 };
22551
22552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22554 if (SWIG_arg_fail(1)) SWIG_fail;
22555 {
22556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22557 if (SWIG_arg_fail(2)) SWIG_fail;
22558 if (arg2 == NULL) {
22559 SWIG_null_ref("wxDateSpan");
22560 }
22561 if (SWIG_arg_fail(2)) SWIG_fail;
22562 }
22563 {
22564 PyThreadState* __tstate = wxPyBeginAllowThreads();
22565 {
22566 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22567 result = (wxDateTime *) &_result_ref;
22568 }
22569
22570 wxPyEndAllowThreads(__tstate);
22571 if (PyErr_Occurred()) SWIG_fail;
22572 }
22573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22574 return resultobj;
22575 fail:
22576 return NULL;
22577 }
22578
22579
22580 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22581 PyObject *resultobj;
22582 wxDateTime *arg1 = (wxDateTime *) 0 ;
22583 wxDateTime *arg2 = 0 ;
22584 wxTimeSpan result;
22585 PyObject * obj0 = 0 ;
22586 PyObject * obj1 = 0 ;
22587 char *kwnames[] = {
22588 (char *) "self",(char *) "dt", NULL
22589 };
22590
22591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22593 if (SWIG_arg_fail(1)) SWIG_fail;
22594 {
22595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22596 if (SWIG_arg_fail(2)) SWIG_fail;
22597 if (arg2 == NULL) {
22598 SWIG_null_ref("wxDateTime");
22599 }
22600 if (SWIG_arg_fail(2)) SWIG_fail;
22601 }
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22605
22606 wxPyEndAllowThreads(__tstate);
22607 if (PyErr_Occurred()) SWIG_fail;
22608 }
22609 {
22610 wxTimeSpan * resultptr;
22611 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22612 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22613 }
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22621 PyObject *resultobj;
22622 wxDateTime *arg1 = (wxDateTime *) 0 ;
22623 wxTimeSpan *arg2 = 0 ;
22624 wxDateTime *result;
22625 PyObject * obj0 = 0 ;
22626 PyObject * obj1 = 0 ;
22627
22628 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22630 if (SWIG_arg_fail(1)) SWIG_fail;
22631 {
22632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22633 if (SWIG_arg_fail(2)) SWIG_fail;
22634 if (arg2 == NULL) {
22635 SWIG_null_ref("wxTimeSpan");
22636 }
22637 if (SWIG_arg_fail(2)) SWIG_fail;
22638 }
22639 {
22640 PyThreadState* __tstate = wxPyBeginAllowThreads();
22641 {
22642 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22643 result = (wxDateTime *) &_result_ref;
22644 }
22645
22646 wxPyEndAllowThreads(__tstate);
22647 if (PyErr_Occurred()) SWIG_fail;
22648 }
22649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22650 return resultobj;
22651 fail:
22652 return NULL;
22653 }
22654
22655
22656 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22657 PyObject *resultobj;
22658 wxDateTime *arg1 = (wxDateTime *) 0 ;
22659 wxDateSpan *arg2 = 0 ;
22660 wxDateTime *result;
22661 PyObject * obj0 = 0 ;
22662 PyObject * obj1 = 0 ;
22663
22664 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22666 if (SWIG_arg_fail(1)) SWIG_fail;
22667 {
22668 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22669 if (SWIG_arg_fail(2)) SWIG_fail;
22670 if (arg2 == NULL) {
22671 SWIG_null_ref("wxDateSpan");
22672 }
22673 if (SWIG_arg_fail(2)) SWIG_fail;
22674 }
22675 {
22676 PyThreadState* __tstate = wxPyBeginAllowThreads();
22677 {
22678 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22679 result = (wxDateTime *) &_result_ref;
22680 }
22681
22682 wxPyEndAllowThreads(__tstate);
22683 if (PyErr_Occurred()) SWIG_fail;
22684 }
22685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22693 int argc;
22694 PyObject *argv[3];
22695 int ii;
22696
22697 argc = PyObject_Length(args);
22698 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22699 argv[ii] = PyTuple_GetItem(args,ii);
22700 }
22701 if (argc == 2) {
22702 int _v;
22703 {
22704 void *ptr;
22705 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22706 _v = 0;
22707 PyErr_Clear();
22708 } else {
22709 _v = 1;
22710 }
22711 }
22712 if (_v) {
22713 {
22714 void *ptr = 0;
22715 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22716 _v = 0;
22717 PyErr_Clear();
22718 } else {
22719 _v = (ptr != 0);
22720 }
22721 }
22722 if (_v) {
22723 return _wrap_DateTime___iadd____SWIG_0(self,args);
22724 }
22725 }
22726 }
22727 if (argc == 2) {
22728 int _v;
22729 {
22730 void *ptr;
22731 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22732 _v = 0;
22733 PyErr_Clear();
22734 } else {
22735 _v = 1;
22736 }
22737 }
22738 if (_v) {
22739 {
22740 void *ptr = 0;
22741 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22742 _v = 0;
22743 PyErr_Clear();
22744 } else {
22745 _v = (ptr != 0);
22746 }
22747 }
22748 if (_v) {
22749 return _wrap_DateTime___iadd____SWIG_1(self,args);
22750 }
22751 }
22752 }
22753
22754 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22755 return NULL;
22756 }
22757
22758
22759 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22760 PyObject *resultobj;
22761 wxDateTime *arg1 = (wxDateTime *) 0 ;
22762 wxTimeSpan *arg2 = 0 ;
22763 wxDateTime *result;
22764 PyObject * obj0 = 0 ;
22765 PyObject * obj1 = 0 ;
22766
22767 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22769 if (SWIG_arg_fail(1)) SWIG_fail;
22770 {
22771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22772 if (SWIG_arg_fail(2)) SWIG_fail;
22773 if (arg2 == NULL) {
22774 SWIG_null_ref("wxTimeSpan");
22775 }
22776 if (SWIG_arg_fail(2)) SWIG_fail;
22777 }
22778 {
22779 PyThreadState* __tstate = wxPyBeginAllowThreads();
22780 {
22781 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22782 result = (wxDateTime *) &_result_ref;
22783 }
22784
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22796 PyObject *resultobj;
22797 wxDateTime *arg1 = (wxDateTime *) 0 ;
22798 wxDateSpan *arg2 = 0 ;
22799 wxDateTime *result;
22800 PyObject * obj0 = 0 ;
22801 PyObject * obj1 = 0 ;
22802
22803 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
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)->operator -=((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, 1);
22825 return resultobj;
22826 fail:
22827 return NULL;
22828 }
22829
22830
22831 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22832 int argc;
22833 PyObject *argv[3];
22834 int ii;
22835
22836 argc = PyObject_Length(args);
22837 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22838 argv[ii] = PyTuple_GetItem(args,ii);
22839 }
22840 if (argc == 2) {
22841 int _v;
22842 {
22843 void *ptr;
22844 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22845 _v = 0;
22846 PyErr_Clear();
22847 } else {
22848 _v = 1;
22849 }
22850 }
22851 if (_v) {
22852 {
22853 void *ptr = 0;
22854 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22855 _v = 0;
22856 PyErr_Clear();
22857 } else {
22858 _v = (ptr != 0);
22859 }
22860 }
22861 if (_v) {
22862 return _wrap_DateTime___isub____SWIG_0(self,args);
22863 }
22864 }
22865 }
22866 if (argc == 2) {
22867 int _v;
22868 {
22869 void *ptr;
22870 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22871 _v = 0;
22872 PyErr_Clear();
22873 } else {
22874 _v = 1;
22875 }
22876 }
22877 if (_v) {
22878 {
22879 void *ptr = 0;
22880 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22881 _v = 0;
22882 PyErr_Clear();
22883 } else {
22884 _v = (ptr != 0);
22885 }
22886 }
22887 if (_v) {
22888 return _wrap_DateTime___isub____SWIG_1(self,args);
22889 }
22890 }
22891 }
22892
22893 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22899 PyObject *resultobj;
22900 wxDateTime *arg1 = (wxDateTime *) 0 ;
22901 wxTimeSpan *arg2 = 0 ;
22902 wxDateTime result;
22903 PyObject * obj0 = 0 ;
22904 PyObject * obj1 = 0 ;
22905
22906 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(1)) SWIG_fail;
22909 {
22910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22911 if (SWIG_arg_fail(2)) SWIG_fail;
22912 if (arg2 == NULL) {
22913 SWIG_null_ref("wxTimeSpan");
22914 }
22915 if (SWIG_arg_fail(2)) SWIG_fail;
22916 }
22917 {
22918 PyThreadState* __tstate = wxPyBeginAllowThreads();
22919 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22920
22921 wxPyEndAllowThreads(__tstate);
22922 if (PyErr_Occurred()) SWIG_fail;
22923 }
22924 {
22925 wxDateTime * resultptr;
22926 resultptr = new wxDateTime((wxDateTime &)(result));
22927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22928 }
22929 return resultobj;
22930 fail:
22931 return NULL;
22932 }
22933
22934
22935 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22936 PyObject *resultobj;
22937 wxDateTime *arg1 = (wxDateTime *) 0 ;
22938 wxDateSpan *arg2 = 0 ;
22939 wxDateTime result;
22940 PyObject * obj0 = 0 ;
22941 PyObject * obj1 = 0 ;
22942
22943 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22945 if (SWIG_arg_fail(1)) SWIG_fail;
22946 {
22947 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22948 if (SWIG_arg_fail(2)) SWIG_fail;
22949 if (arg2 == NULL) {
22950 SWIG_null_ref("wxDateSpan");
22951 }
22952 if (SWIG_arg_fail(2)) SWIG_fail;
22953 }
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22957
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 {
22962 wxDateTime * resultptr;
22963 resultptr = new wxDateTime((wxDateTime &)(result));
22964 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22965 }
22966 return resultobj;
22967 fail:
22968 return NULL;
22969 }
22970
22971
22972 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22973 int argc;
22974 PyObject *argv[3];
22975 int ii;
22976
22977 argc = PyObject_Length(args);
22978 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22979 argv[ii] = PyTuple_GetItem(args,ii);
22980 }
22981 if (argc == 2) {
22982 int _v;
22983 {
22984 void *ptr;
22985 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22986 _v = 0;
22987 PyErr_Clear();
22988 } else {
22989 _v = 1;
22990 }
22991 }
22992 if (_v) {
22993 {
22994 void *ptr = 0;
22995 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22996 _v = 0;
22997 PyErr_Clear();
22998 } else {
22999 _v = (ptr != 0);
23000 }
23001 }
23002 if (_v) {
23003 return _wrap_DateTime___add____SWIG_0(self,args);
23004 }
23005 }
23006 }
23007 if (argc == 2) {
23008 int _v;
23009 {
23010 void *ptr;
23011 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23012 _v = 0;
23013 PyErr_Clear();
23014 } else {
23015 _v = 1;
23016 }
23017 }
23018 if (_v) {
23019 {
23020 void *ptr = 0;
23021 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23022 _v = 0;
23023 PyErr_Clear();
23024 } else {
23025 _v = (ptr != 0);
23026 }
23027 }
23028 if (_v) {
23029 return _wrap_DateTime___add____SWIG_1(self,args);
23030 }
23031 }
23032 }
23033
23034 Py_INCREF(Py_NotImplemented);
23035 return Py_NotImplemented;
23036 }
23037
23038
23039 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23040 PyObject *resultobj;
23041 wxDateTime *arg1 = (wxDateTime *) 0 ;
23042 wxDateTime *arg2 = 0 ;
23043 wxTimeSpan result;
23044 PyObject * obj0 = 0 ;
23045 PyObject * obj1 = 0 ;
23046
23047 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23049 if (SWIG_arg_fail(1)) SWIG_fail;
23050 {
23051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23052 if (SWIG_arg_fail(2)) SWIG_fail;
23053 if (arg2 == NULL) {
23054 SWIG_null_ref("wxDateTime");
23055 }
23056 if (SWIG_arg_fail(2)) SWIG_fail;
23057 }
23058 {
23059 PyThreadState* __tstate = wxPyBeginAllowThreads();
23060 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23061
23062 wxPyEndAllowThreads(__tstate);
23063 if (PyErr_Occurred()) SWIG_fail;
23064 }
23065 {
23066 wxTimeSpan * resultptr;
23067 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23069 }
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23077 PyObject *resultobj;
23078 wxDateTime *arg1 = (wxDateTime *) 0 ;
23079 wxTimeSpan *arg2 = 0 ;
23080 wxDateTime result;
23081 PyObject * obj0 = 0 ;
23082 PyObject * obj1 = 0 ;
23083
23084 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23086 if (SWIG_arg_fail(1)) SWIG_fail;
23087 {
23088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23089 if (SWIG_arg_fail(2)) SWIG_fail;
23090 if (arg2 == NULL) {
23091 SWIG_null_ref("wxTimeSpan");
23092 }
23093 if (SWIG_arg_fail(2)) SWIG_fail;
23094 }
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23098
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 {
23103 wxDateTime * resultptr;
23104 resultptr = new wxDateTime((wxDateTime &)(result));
23105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23106 }
23107 return resultobj;
23108 fail:
23109 return NULL;
23110 }
23111
23112
23113 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23114 PyObject *resultobj;
23115 wxDateTime *arg1 = (wxDateTime *) 0 ;
23116 wxDateSpan *arg2 = 0 ;
23117 wxDateTime result;
23118 PyObject * obj0 = 0 ;
23119 PyObject * obj1 = 0 ;
23120
23121 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23123 if (SWIG_arg_fail(1)) SWIG_fail;
23124 {
23125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23126 if (SWIG_arg_fail(2)) SWIG_fail;
23127 if (arg2 == NULL) {
23128 SWIG_null_ref("wxDateSpan");
23129 }
23130 if (SWIG_arg_fail(2)) SWIG_fail;
23131 }
23132 {
23133 PyThreadState* __tstate = wxPyBeginAllowThreads();
23134 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23135
23136 wxPyEndAllowThreads(__tstate);
23137 if (PyErr_Occurred()) SWIG_fail;
23138 }
23139 {
23140 wxDateTime * resultptr;
23141 resultptr = new wxDateTime((wxDateTime &)(result));
23142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23143 }
23144 return resultobj;
23145 fail:
23146 return NULL;
23147 }
23148
23149
23150 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23151 int argc;
23152 PyObject *argv[3];
23153 int ii;
23154
23155 argc = PyObject_Length(args);
23156 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23157 argv[ii] = PyTuple_GetItem(args,ii);
23158 }
23159 if (argc == 2) {
23160 int _v;
23161 {
23162 void *ptr;
23163 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23164 _v = 0;
23165 PyErr_Clear();
23166 } else {
23167 _v = 1;
23168 }
23169 }
23170 if (_v) {
23171 {
23172 void *ptr = 0;
23173 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23174 _v = 0;
23175 PyErr_Clear();
23176 } else {
23177 _v = (ptr != 0);
23178 }
23179 }
23180 if (_v) {
23181 return _wrap_DateTime___sub____SWIG_0(self,args);
23182 }
23183 }
23184 }
23185 if (argc == 2) {
23186 int _v;
23187 {
23188 void *ptr;
23189 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23190 _v = 0;
23191 PyErr_Clear();
23192 } else {
23193 _v = 1;
23194 }
23195 }
23196 if (_v) {
23197 {
23198 void *ptr = 0;
23199 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23200 _v = 0;
23201 PyErr_Clear();
23202 } else {
23203 _v = (ptr != 0);
23204 }
23205 }
23206 if (_v) {
23207 return _wrap_DateTime___sub____SWIG_1(self,args);
23208 }
23209 }
23210 }
23211 if (argc == 2) {
23212 int _v;
23213 {
23214 void *ptr;
23215 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23216 _v = 0;
23217 PyErr_Clear();
23218 } else {
23219 _v = 1;
23220 }
23221 }
23222 if (_v) {
23223 {
23224 void *ptr = 0;
23225 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23226 _v = 0;
23227 PyErr_Clear();
23228 } else {
23229 _v = (ptr != 0);
23230 }
23231 }
23232 if (_v) {
23233 return _wrap_DateTime___sub____SWIG_2(self,args);
23234 }
23235 }
23236 }
23237
23238 Py_INCREF(Py_NotImplemented);
23239 return Py_NotImplemented;
23240 }
23241
23242
23243 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23244 PyObject *resultobj;
23245 wxDateTime *arg1 = (wxDateTime *) 0 ;
23246 wxDateTime *arg2 = (wxDateTime *) 0 ;
23247 bool result;
23248 PyObject * obj0 = 0 ;
23249 PyObject * obj1 = 0 ;
23250 char *kwnames[] = {
23251 (char *) "self",(char *) "other", NULL
23252 };
23253
23254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23256 if (SWIG_arg_fail(1)) SWIG_fail;
23257 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23258 if (SWIG_arg_fail(2)) SWIG_fail;
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23262
23263 wxPyEndAllowThreads(__tstate);
23264 if (PyErr_Occurred()) SWIG_fail;
23265 }
23266 {
23267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23268 }
23269 return resultobj;
23270 fail:
23271 return NULL;
23272 }
23273
23274
23275 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23276 PyObject *resultobj;
23277 wxDateTime *arg1 = (wxDateTime *) 0 ;
23278 wxDateTime *arg2 = (wxDateTime *) 0 ;
23279 bool result;
23280 PyObject * obj0 = 0 ;
23281 PyObject * obj1 = 0 ;
23282 char *kwnames[] = {
23283 (char *) "self",(char *) "other", NULL
23284 };
23285
23286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23288 if (SWIG_arg_fail(1)) SWIG_fail;
23289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23290 if (SWIG_arg_fail(2)) SWIG_fail;
23291 {
23292 PyThreadState* __tstate = wxPyBeginAllowThreads();
23293 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23294
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 {
23299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23300 }
23301 return resultobj;
23302 fail:
23303 return NULL;
23304 }
23305
23306
23307 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23308 PyObject *resultobj;
23309 wxDateTime *arg1 = (wxDateTime *) 0 ;
23310 wxDateTime *arg2 = (wxDateTime *) 0 ;
23311 bool result;
23312 PyObject * obj0 = 0 ;
23313 PyObject * obj1 = 0 ;
23314 char *kwnames[] = {
23315 (char *) "self",(char *) "other", NULL
23316 };
23317
23318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23320 if (SWIG_arg_fail(1)) SWIG_fail;
23321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23322 if (SWIG_arg_fail(2)) SWIG_fail;
23323 {
23324 PyThreadState* __tstate = wxPyBeginAllowThreads();
23325 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23326
23327 wxPyEndAllowThreads(__tstate);
23328 if (PyErr_Occurred()) SWIG_fail;
23329 }
23330 {
23331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23332 }
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23340 PyObject *resultobj;
23341 wxDateTime *arg1 = (wxDateTime *) 0 ;
23342 wxDateTime *arg2 = (wxDateTime *) 0 ;
23343 bool result;
23344 PyObject * obj0 = 0 ;
23345 PyObject * obj1 = 0 ;
23346 char *kwnames[] = {
23347 (char *) "self",(char *) "other", NULL
23348 };
23349
23350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23352 if (SWIG_arg_fail(1)) SWIG_fail;
23353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23354 if (SWIG_arg_fail(2)) SWIG_fail;
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23358
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 {
23363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23364 }
23365 return resultobj;
23366 fail:
23367 return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23372 PyObject *resultobj;
23373 wxDateTime *arg1 = (wxDateTime *) 0 ;
23374 wxDateTime *arg2 = (wxDateTime *) 0 ;
23375 bool result;
23376 PyObject * obj0 = 0 ;
23377 PyObject * obj1 = 0 ;
23378 char *kwnames[] = {
23379 (char *) "self",(char *) "other", NULL
23380 };
23381
23382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23384 if (SWIG_arg_fail(1)) SWIG_fail;
23385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23386 if (SWIG_arg_fail(2)) SWIG_fail;
23387 {
23388 PyThreadState* __tstate = wxPyBeginAllowThreads();
23389 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23390
23391 wxPyEndAllowThreads(__tstate);
23392 if (PyErr_Occurred()) SWIG_fail;
23393 }
23394 {
23395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23396 }
23397 return resultobj;
23398 fail:
23399 return NULL;
23400 }
23401
23402
23403 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23404 PyObject *resultobj;
23405 wxDateTime *arg1 = (wxDateTime *) 0 ;
23406 wxDateTime *arg2 = (wxDateTime *) 0 ;
23407 bool result;
23408 PyObject * obj0 = 0 ;
23409 PyObject * obj1 = 0 ;
23410 char *kwnames[] = {
23411 (char *) "self",(char *) "other", NULL
23412 };
23413
23414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23416 if (SWIG_arg_fail(1)) SWIG_fail;
23417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23418 if (SWIG_arg_fail(2)) SWIG_fail;
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23422
23423 wxPyEndAllowThreads(__tstate);
23424 if (PyErr_Occurred()) SWIG_fail;
23425 }
23426 {
23427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23428 }
23429 return resultobj;
23430 fail:
23431 return NULL;
23432 }
23433
23434
23435 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23436 PyObject *resultobj;
23437 wxDateTime *arg1 = (wxDateTime *) 0 ;
23438 wxString *arg2 = 0 ;
23439 int result;
23440 bool temp2 = false ;
23441 PyObject * obj0 = 0 ;
23442 PyObject * obj1 = 0 ;
23443 char *kwnames[] = {
23444 (char *) "self",(char *) "date", NULL
23445 };
23446
23447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23449 if (SWIG_arg_fail(1)) SWIG_fail;
23450 {
23451 arg2 = wxString_in_helper(obj1);
23452 if (arg2 == NULL) SWIG_fail;
23453 temp2 = true;
23454 }
23455 {
23456 PyThreadState* __tstate = wxPyBeginAllowThreads();
23457 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23458
23459 wxPyEndAllowThreads(__tstate);
23460 if (PyErr_Occurred()) SWIG_fail;
23461 }
23462 {
23463 resultobj = SWIG_From_int((int)(result));
23464 }
23465 {
23466 if (temp2)
23467 delete arg2;
23468 }
23469 return resultobj;
23470 fail:
23471 {
23472 if (temp2)
23473 delete arg2;
23474 }
23475 return NULL;
23476 }
23477
23478
23479 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23480 PyObject *resultobj;
23481 wxDateTime *arg1 = (wxDateTime *) 0 ;
23482 wxString *arg2 = 0 ;
23483 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23484 wxString *arg3 = (wxString *) &arg3_defvalue ;
23485 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23486 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23487 int result;
23488 bool temp2 = false ;
23489 bool temp3 = false ;
23490 PyObject * obj0 = 0 ;
23491 PyObject * obj1 = 0 ;
23492 PyObject * obj2 = 0 ;
23493 PyObject * obj3 = 0 ;
23494 char *kwnames[] = {
23495 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23496 };
23497
23498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23500 if (SWIG_arg_fail(1)) SWIG_fail;
23501 {
23502 arg2 = wxString_in_helper(obj1);
23503 if (arg2 == NULL) SWIG_fail;
23504 temp2 = true;
23505 }
23506 if (obj2) {
23507 {
23508 arg3 = wxString_in_helper(obj2);
23509 if (arg3 == NULL) SWIG_fail;
23510 temp3 = true;
23511 }
23512 }
23513 if (obj3) {
23514 {
23515 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23516 if (SWIG_arg_fail(4)) SWIG_fail;
23517 if (arg4 == NULL) {
23518 SWIG_null_ref("wxDateTime");
23519 }
23520 if (SWIG_arg_fail(4)) SWIG_fail;
23521 }
23522 }
23523 {
23524 PyThreadState* __tstate = wxPyBeginAllowThreads();
23525 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23526
23527 wxPyEndAllowThreads(__tstate);
23528 if (PyErr_Occurred()) SWIG_fail;
23529 }
23530 {
23531 resultobj = SWIG_From_int((int)(result));
23532 }
23533 {
23534 if (temp2)
23535 delete arg2;
23536 }
23537 {
23538 if (temp3)
23539 delete arg3;
23540 }
23541 return resultobj;
23542 fail:
23543 {
23544 if (temp2)
23545 delete arg2;
23546 }
23547 {
23548 if (temp3)
23549 delete arg3;
23550 }
23551 return NULL;
23552 }
23553
23554
23555 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23556 PyObject *resultobj;
23557 wxDateTime *arg1 = (wxDateTime *) 0 ;
23558 wxString *arg2 = 0 ;
23559 int result;
23560 bool temp2 = false ;
23561 PyObject * obj0 = 0 ;
23562 PyObject * obj1 = 0 ;
23563 char *kwnames[] = {
23564 (char *) "self",(char *) "datetime", NULL
23565 };
23566
23567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23569 if (SWIG_arg_fail(1)) SWIG_fail;
23570 {
23571 arg2 = wxString_in_helper(obj1);
23572 if (arg2 == NULL) SWIG_fail;
23573 temp2 = true;
23574 }
23575 {
23576 PyThreadState* __tstate = wxPyBeginAllowThreads();
23577 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23578
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 {
23583 resultobj = SWIG_From_int((int)(result));
23584 }
23585 {
23586 if (temp2)
23587 delete arg2;
23588 }
23589 return resultobj;
23590 fail:
23591 {
23592 if (temp2)
23593 delete arg2;
23594 }
23595 return NULL;
23596 }
23597
23598
23599 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23600 PyObject *resultobj;
23601 wxDateTime *arg1 = (wxDateTime *) 0 ;
23602 wxString *arg2 = 0 ;
23603 int result;
23604 bool temp2 = false ;
23605 PyObject * obj0 = 0 ;
23606 PyObject * obj1 = 0 ;
23607 char *kwnames[] = {
23608 (char *) "self",(char *) "date", NULL
23609 };
23610
23611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23613 if (SWIG_arg_fail(1)) SWIG_fail;
23614 {
23615 arg2 = wxString_in_helper(obj1);
23616 if (arg2 == NULL) SWIG_fail;
23617 temp2 = true;
23618 }
23619 {
23620 PyThreadState* __tstate = wxPyBeginAllowThreads();
23621 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23622
23623 wxPyEndAllowThreads(__tstate);
23624 if (PyErr_Occurred()) SWIG_fail;
23625 }
23626 {
23627 resultobj = SWIG_From_int((int)(result));
23628 }
23629 {
23630 if (temp2)
23631 delete arg2;
23632 }
23633 return resultobj;
23634 fail:
23635 {
23636 if (temp2)
23637 delete arg2;
23638 }
23639 return NULL;
23640 }
23641
23642
23643 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23644 PyObject *resultobj;
23645 wxDateTime *arg1 = (wxDateTime *) 0 ;
23646 wxString *arg2 = 0 ;
23647 int result;
23648 bool temp2 = false ;
23649 PyObject * obj0 = 0 ;
23650 PyObject * obj1 = 0 ;
23651 char *kwnames[] = {
23652 (char *) "self",(char *) "time", NULL
23653 };
23654
23655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23657 if (SWIG_arg_fail(1)) SWIG_fail;
23658 {
23659 arg2 = wxString_in_helper(obj1);
23660 if (arg2 == NULL) SWIG_fail;
23661 temp2 = true;
23662 }
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23666
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 {
23671 resultobj = SWIG_From_int((int)(result));
23672 }
23673 {
23674 if (temp2)
23675 delete arg2;
23676 }
23677 return resultobj;
23678 fail:
23679 {
23680 if (temp2)
23681 delete arg2;
23682 }
23683 return NULL;
23684 }
23685
23686
23687 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23688 PyObject *resultobj;
23689 wxDateTime *arg1 = (wxDateTime *) 0 ;
23690 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23691 wxString *arg2 = (wxString *) &arg2_defvalue ;
23692 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23693 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23694 wxString result;
23695 bool temp2 = false ;
23696 bool temp3 = false ;
23697 PyObject * obj0 = 0 ;
23698 PyObject * obj1 = 0 ;
23699 PyObject * obj2 = 0 ;
23700 char *kwnames[] = {
23701 (char *) "self",(char *) "format",(char *) "tz", NULL
23702 };
23703
23704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23706 if (SWIG_arg_fail(1)) SWIG_fail;
23707 if (obj1) {
23708 {
23709 arg2 = wxString_in_helper(obj1);
23710 if (arg2 == NULL) SWIG_fail;
23711 temp2 = true;
23712 }
23713 }
23714 if (obj2) {
23715 {
23716 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23717 temp3 = true;
23718 }
23719 }
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23723
23724 wxPyEndAllowThreads(__tstate);
23725 if (PyErr_Occurred()) SWIG_fail;
23726 }
23727 {
23728 #if wxUSE_UNICODE
23729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23730 #else
23731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23732 #endif
23733 }
23734 {
23735 if (temp2)
23736 delete arg2;
23737 }
23738 {
23739 if (temp3) delete arg3;
23740 }
23741 return resultobj;
23742 fail:
23743 {
23744 if (temp2)
23745 delete arg2;
23746 }
23747 {
23748 if (temp3) delete arg3;
23749 }
23750 return NULL;
23751 }
23752
23753
23754 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23755 PyObject *resultobj;
23756 wxDateTime *arg1 = (wxDateTime *) 0 ;
23757 wxString result;
23758 PyObject * obj0 = 0 ;
23759 char *kwnames[] = {
23760 (char *) "self", NULL
23761 };
23762
23763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23765 if (SWIG_arg_fail(1)) SWIG_fail;
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = ((wxDateTime const *)arg1)->FormatDate();
23769
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 {
23774 #if wxUSE_UNICODE
23775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23776 #else
23777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23778 #endif
23779 }
23780 return resultobj;
23781 fail:
23782 return NULL;
23783 }
23784
23785
23786 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj;
23788 wxDateTime *arg1 = (wxDateTime *) 0 ;
23789 wxString result;
23790 PyObject * obj0 = 0 ;
23791 char *kwnames[] = {
23792 (char *) "self", NULL
23793 };
23794
23795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23797 if (SWIG_arg_fail(1)) SWIG_fail;
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 result = ((wxDateTime const *)arg1)->FormatTime();
23801
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 {
23806 #if wxUSE_UNICODE
23807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23808 #else
23809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23810 #endif
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj;
23820 wxDateTime *arg1 = (wxDateTime *) 0 ;
23821 wxString result;
23822 PyObject * obj0 = 0 ;
23823 char *kwnames[] = {
23824 (char *) "self", NULL
23825 };
23826
23827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23829 if (SWIG_arg_fail(1)) SWIG_fail;
23830 {
23831 PyThreadState* __tstate = wxPyBeginAllowThreads();
23832 result = ((wxDateTime const *)arg1)->FormatISODate();
23833
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 {
23838 #if wxUSE_UNICODE
23839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23840 #else
23841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23842 #endif
23843 }
23844 return resultobj;
23845 fail:
23846 return NULL;
23847 }
23848
23849
23850 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23851 PyObject *resultobj;
23852 wxDateTime *arg1 = (wxDateTime *) 0 ;
23853 wxString result;
23854 PyObject * obj0 = 0 ;
23855 char *kwnames[] = {
23856 (char *) "self", NULL
23857 };
23858
23859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23861 if (SWIG_arg_fail(1)) SWIG_fail;
23862 {
23863 PyThreadState* __tstate = wxPyBeginAllowThreads();
23864 result = ((wxDateTime const *)arg1)->FormatISOTime();
23865
23866 wxPyEndAllowThreads(__tstate);
23867 if (PyErr_Occurred()) SWIG_fail;
23868 }
23869 {
23870 #if wxUSE_UNICODE
23871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23872 #else
23873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23874 #endif
23875 }
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23883 PyObject *obj;
23884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23885 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23886 Py_INCREF(obj);
23887 return Py_BuildValue((char *)"");
23888 }
23889 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23890 PyObject *resultobj;
23891 long arg1 ;
23892 wxTimeSpan result;
23893 PyObject * obj0 = 0 ;
23894 char *kwnames[] = {
23895 (char *) "sec", NULL
23896 };
23897
23898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23899 {
23900 arg1 = (long)(SWIG_As_long(obj0));
23901 if (SWIG_arg_fail(1)) SWIG_fail;
23902 }
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 result = wxTimeSpan::Seconds(arg1);
23906
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 {
23911 wxTimeSpan * resultptr;
23912 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23914 }
23915 return resultobj;
23916 fail:
23917 return NULL;
23918 }
23919
23920
23921 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23922 PyObject *resultobj;
23923 wxTimeSpan result;
23924 char *kwnames[] = {
23925 NULL
23926 };
23927
23928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23929 {
23930 PyThreadState* __tstate = wxPyBeginAllowThreads();
23931 result = wxTimeSpan::Second();
23932
23933 wxPyEndAllowThreads(__tstate);
23934 if (PyErr_Occurred()) SWIG_fail;
23935 }
23936 {
23937 wxTimeSpan * resultptr;
23938 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23939 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23940 }
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23948 PyObject *resultobj;
23949 long arg1 ;
23950 wxTimeSpan result;
23951 PyObject * obj0 = 0 ;
23952 char *kwnames[] = {
23953 (char *) "min", NULL
23954 };
23955
23956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23957 {
23958 arg1 = (long)(SWIG_As_long(obj0));
23959 if (SWIG_arg_fail(1)) SWIG_fail;
23960 }
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = wxTimeSpan::Minutes(arg1);
23964
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 {
23969 wxTimeSpan * resultptr;
23970 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23971 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23972 }
23973 return resultobj;
23974 fail:
23975 return NULL;
23976 }
23977
23978
23979 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23980 PyObject *resultobj;
23981 wxTimeSpan result;
23982 char *kwnames[] = {
23983 NULL
23984 };
23985
23986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23987 {
23988 PyThreadState* __tstate = wxPyBeginAllowThreads();
23989 result = wxTimeSpan::Minute();
23990
23991 wxPyEndAllowThreads(__tstate);
23992 if (PyErr_Occurred()) SWIG_fail;
23993 }
23994 {
23995 wxTimeSpan * resultptr;
23996 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23997 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23998 }
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24006 PyObject *resultobj;
24007 long arg1 ;
24008 wxTimeSpan result;
24009 PyObject * obj0 = 0 ;
24010 char *kwnames[] = {
24011 (char *) "hours", NULL
24012 };
24013
24014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24015 {
24016 arg1 = (long)(SWIG_As_long(obj0));
24017 if (SWIG_arg_fail(1)) SWIG_fail;
24018 }
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 result = wxTimeSpan::Hours(arg1);
24022
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 {
24027 wxTimeSpan * resultptr;
24028 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24029 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24030 }
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24038 PyObject *resultobj;
24039 wxTimeSpan result;
24040 char *kwnames[] = {
24041 NULL
24042 };
24043
24044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24045 {
24046 PyThreadState* __tstate = wxPyBeginAllowThreads();
24047 result = wxTimeSpan::Hour();
24048
24049 wxPyEndAllowThreads(__tstate);
24050 if (PyErr_Occurred()) SWIG_fail;
24051 }
24052 {
24053 wxTimeSpan * resultptr;
24054 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24056 }
24057 return resultobj;
24058 fail:
24059 return NULL;
24060 }
24061
24062
24063 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24064 PyObject *resultobj;
24065 long arg1 ;
24066 wxTimeSpan result;
24067 PyObject * obj0 = 0 ;
24068 char *kwnames[] = {
24069 (char *) "days", NULL
24070 };
24071
24072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24073 {
24074 arg1 = (long)(SWIG_As_long(obj0));
24075 if (SWIG_arg_fail(1)) SWIG_fail;
24076 }
24077 {
24078 PyThreadState* __tstate = wxPyBeginAllowThreads();
24079 result = wxTimeSpan::Days(arg1);
24080
24081 wxPyEndAllowThreads(__tstate);
24082 if (PyErr_Occurred()) SWIG_fail;
24083 }
24084 {
24085 wxTimeSpan * resultptr;
24086 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24087 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24088 }
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24096 PyObject *resultobj;
24097 wxTimeSpan result;
24098 char *kwnames[] = {
24099 NULL
24100 };
24101
24102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24103 {
24104 PyThreadState* __tstate = wxPyBeginAllowThreads();
24105 result = wxTimeSpan::Day();
24106
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 {
24111 wxTimeSpan * resultptr;
24112 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24114 }
24115 return resultobj;
24116 fail:
24117 return NULL;
24118 }
24119
24120
24121 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24122 PyObject *resultobj;
24123 long arg1 ;
24124 wxTimeSpan result;
24125 PyObject * obj0 = 0 ;
24126 char *kwnames[] = {
24127 (char *) "days", NULL
24128 };
24129
24130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24131 {
24132 arg1 = (long)(SWIG_As_long(obj0));
24133 if (SWIG_arg_fail(1)) SWIG_fail;
24134 }
24135 {
24136 PyThreadState* __tstate = wxPyBeginAllowThreads();
24137 result = wxTimeSpan::Weeks(arg1);
24138
24139 wxPyEndAllowThreads(__tstate);
24140 if (PyErr_Occurred()) SWIG_fail;
24141 }
24142 {
24143 wxTimeSpan * resultptr;
24144 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24146 }
24147 return resultobj;
24148 fail:
24149 return NULL;
24150 }
24151
24152
24153 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24154 PyObject *resultobj;
24155 wxTimeSpan result;
24156 char *kwnames[] = {
24157 NULL
24158 };
24159
24160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24161 {
24162 PyThreadState* __tstate = wxPyBeginAllowThreads();
24163 result = wxTimeSpan::Week();
24164
24165 wxPyEndAllowThreads(__tstate);
24166 if (PyErr_Occurred()) SWIG_fail;
24167 }
24168 {
24169 wxTimeSpan * resultptr;
24170 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24172 }
24173 return resultobj;
24174 fail:
24175 return NULL;
24176 }
24177
24178
24179 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24180 PyObject *resultobj;
24181 long arg1 = (long) 0 ;
24182 long arg2 = (long) 0 ;
24183 long arg3 = (long) 0 ;
24184 long arg4 = (long) 0 ;
24185 wxTimeSpan *result;
24186 PyObject * obj0 = 0 ;
24187 PyObject * obj1 = 0 ;
24188 PyObject * obj2 = 0 ;
24189 PyObject * obj3 = 0 ;
24190 char *kwnames[] = {
24191 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24192 };
24193
24194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24195 if (obj0) {
24196 {
24197 arg1 = (long)(SWIG_As_long(obj0));
24198 if (SWIG_arg_fail(1)) SWIG_fail;
24199 }
24200 }
24201 if (obj1) {
24202 {
24203 arg2 = (long)(SWIG_As_long(obj1));
24204 if (SWIG_arg_fail(2)) SWIG_fail;
24205 }
24206 }
24207 if (obj2) {
24208 {
24209 arg3 = (long)(SWIG_As_long(obj2));
24210 if (SWIG_arg_fail(3)) SWIG_fail;
24211 }
24212 }
24213 if (obj3) {
24214 {
24215 arg4 = (long)(SWIG_As_long(obj3));
24216 if (SWIG_arg_fail(4)) SWIG_fail;
24217 }
24218 }
24219 {
24220 PyThreadState* __tstate = wxPyBeginAllowThreads();
24221 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24222
24223 wxPyEndAllowThreads(__tstate);
24224 if (PyErr_Occurred()) SWIG_fail;
24225 }
24226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24227 return resultobj;
24228 fail:
24229 return NULL;
24230 }
24231
24232
24233 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24234 PyObject *resultobj;
24235 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24236 PyObject * obj0 = 0 ;
24237 char *kwnames[] = {
24238 (char *) "self", NULL
24239 };
24240
24241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24243 if (SWIG_arg_fail(1)) SWIG_fail;
24244 {
24245 PyThreadState* __tstate = wxPyBeginAllowThreads();
24246 delete arg1;
24247
24248 wxPyEndAllowThreads(__tstate);
24249 if (PyErr_Occurred()) SWIG_fail;
24250 }
24251 Py_INCREF(Py_None); resultobj = Py_None;
24252 return resultobj;
24253 fail:
24254 return NULL;
24255 }
24256
24257
24258 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24259 PyObject *resultobj;
24260 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24261 wxTimeSpan *arg2 = 0 ;
24262 wxTimeSpan *result;
24263 PyObject * obj0 = 0 ;
24264 PyObject * obj1 = 0 ;
24265 char *kwnames[] = {
24266 (char *) "self",(char *) "diff", NULL
24267 };
24268
24269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24271 if (SWIG_arg_fail(1)) SWIG_fail;
24272 {
24273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24274 if (SWIG_arg_fail(2)) SWIG_fail;
24275 if (arg2 == NULL) {
24276 SWIG_null_ref("wxTimeSpan");
24277 }
24278 if (SWIG_arg_fail(2)) SWIG_fail;
24279 }
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 {
24283 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24284 result = (wxTimeSpan *) &_result_ref;
24285 }
24286
24287 wxPyEndAllowThreads(__tstate);
24288 if (PyErr_Occurred()) SWIG_fail;
24289 }
24290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24291 return resultobj;
24292 fail:
24293 return NULL;
24294 }
24295
24296
24297 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24298 PyObject *resultobj;
24299 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24300 wxTimeSpan *arg2 = 0 ;
24301 wxTimeSpan *result;
24302 PyObject * obj0 = 0 ;
24303 PyObject * obj1 = 0 ;
24304 char *kwnames[] = {
24305 (char *) "self",(char *) "diff", NULL
24306 };
24307
24308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24310 if (SWIG_arg_fail(1)) SWIG_fail;
24311 {
24312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24313 if (SWIG_arg_fail(2)) SWIG_fail;
24314 if (arg2 == NULL) {
24315 SWIG_null_ref("wxTimeSpan");
24316 }
24317 if (SWIG_arg_fail(2)) SWIG_fail;
24318 }
24319 {
24320 PyThreadState* __tstate = wxPyBeginAllowThreads();
24321 {
24322 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24323 result = (wxTimeSpan *) &_result_ref;
24324 }
24325
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24330 return resultobj;
24331 fail:
24332 return NULL;
24333 }
24334
24335
24336 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24337 PyObject *resultobj;
24338 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24339 int arg2 ;
24340 wxTimeSpan *result;
24341 PyObject * obj0 = 0 ;
24342 PyObject * obj1 = 0 ;
24343 char *kwnames[] = {
24344 (char *) "self",(char *) "n", NULL
24345 };
24346
24347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24349 if (SWIG_arg_fail(1)) SWIG_fail;
24350 {
24351 arg2 = (int)(SWIG_As_int(obj1));
24352 if (SWIG_arg_fail(2)) SWIG_fail;
24353 }
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 {
24357 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24358 result = (wxTimeSpan *) &_result_ref;
24359 }
24360
24361 wxPyEndAllowThreads(__tstate);
24362 if (PyErr_Occurred()) SWIG_fail;
24363 }
24364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24365 return resultobj;
24366 fail:
24367 return NULL;
24368 }
24369
24370
24371 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24372 PyObject *resultobj;
24373 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24374 wxTimeSpan *result;
24375 PyObject * obj0 = 0 ;
24376 char *kwnames[] = {
24377 (char *) "self", NULL
24378 };
24379
24380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24382 if (SWIG_arg_fail(1)) SWIG_fail;
24383 {
24384 PyThreadState* __tstate = wxPyBeginAllowThreads();
24385 {
24386 wxTimeSpan &_result_ref = (arg1)->Neg();
24387 result = (wxTimeSpan *) &_result_ref;
24388 }
24389
24390 wxPyEndAllowThreads(__tstate);
24391 if (PyErr_Occurred()) SWIG_fail;
24392 }
24393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24394 return resultobj;
24395 fail:
24396 return NULL;
24397 }
24398
24399
24400 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24401 PyObject *resultobj;
24402 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24403 wxTimeSpan result;
24404 PyObject * obj0 = 0 ;
24405 char *kwnames[] = {
24406 (char *) "self", NULL
24407 };
24408
24409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24411 if (SWIG_arg_fail(1)) SWIG_fail;
24412 {
24413 PyThreadState* __tstate = wxPyBeginAllowThreads();
24414 result = ((wxTimeSpan const *)arg1)->Abs();
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_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj;
24432 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24433 wxTimeSpan *arg2 = 0 ;
24434 wxTimeSpan *result;
24435 PyObject * obj0 = 0 ;
24436 PyObject * obj1 = 0 ;
24437 char *kwnames[] = {
24438 (char *) "self",(char *) "diff", NULL
24439 };
24440
24441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24443 if (SWIG_arg_fail(1)) SWIG_fail;
24444 {
24445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24446 if (SWIG_arg_fail(2)) SWIG_fail;
24447 if (arg2 == NULL) {
24448 SWIG_null_ref("wxTimeSpan");
24449 }
24450 if (SWIG_arg_fail(2)) SWIG_fail;
24451 }
24452 {
24453 PyThreadState* __tstate = wxPyBeginAllowThreads();
24454 {
24455 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24456 result = (wxTimeSpan *) &_result_ref;
24457 }
24458
24459 wxPyEndAllowThreads(__tstate);
24460 if (PyErr_Occurred()) SWIG_fail;
24461 }
24462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24470 PyObject *resultobj;
24471 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24472 wxTimeSpan *arg2 = 0 ;
24473 wxTimeSpan *result;
24474 PyObject * obj0 = 0 ;
24475 PyObject * obj1 = 0 ;
24476 char *kwnames[] = {
24477 (char *) "self",(char *) "diff", NULL
24478 };
24479
24480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24482 if (SWIG_arg_fail(1)) SWIG_fail;
24483 {
24484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24485 if (SWIG_arg_fail(2)) SWIG_fail;
24486 if (arg2 == NULL) {
24487 SWIG_null_ref("wxTimeSpan");
24488 }
24489 if (SWIG_arg_fail(2)) SWIG_fail;
24490 }
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 {
24494 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24495 result = (wxTimeSpan *) &_result_ref;
24496 }
24497
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24509 PyObject *resultobj;
24510 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24511 int arg2 ;
24512 wxTimeSpan *result;
24513 PyObject * obj0 = 0 ;
24514 PyObject * obj1 = 0 ;
24515 char *kwnames[] = {
24516 (char *) "self",(char *) "n", NULL
24517 };
24518
24519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24521 if (SWIG_arg_fail(1)) SWIG_fail;
24522 {
24523 arg2 = (int)(SWIG_As_int(obj1));
24524 if (SWIG_arg_fail(2)) SWIG_fail;
24525 }
24526 {
24527 PyThreadState* __tstate = wxPyBeginAllowThreads();
24528 {
24529 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24530 result = (wxTimeSpan *) &_result_ref;
24531 }
24532
24533 wxPyEndAllowThreads(__tstate);
24534 if (PyErr_Occurred()) SWIG_fail;
24535 }
24536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24537 return resultobj;
24538 fail:
24539 return NULL;
24540 }
24541
24542
24543 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24544 PyObject *resultobj;
24545 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24546 wxTimeSpan *result;
24547 PyObject * obj0 = 0 ;
24548 char *kwnames[] = {
24549 (char *) "self", NULL
24550 };
24551
24552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24554 if (SWIG_arg_fail(1)) SWIG_fail;
24555 {
24556 PyThreadState* __tstate = wxPyBeginAllowThreads();
24557 {
24558 wxTimeSpan &_result_ref = (arg1)->operator -();
24559 result = (wxTimeSpan *) &_result_ref;
24560 }
24561
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24566 return resultobj;
24567 fail:
24568 return NULL;
24569 }
24570
24571
24572 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24573 PyObject *resultobj;
24574 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24575 wxTimeSpan *arg2 = 0 ;
24576 wxTimeSpan result;
24577 PyObject * obj0 = 0 ;
24578 PyObject * obj1 = 0 ;
24579 char *kwnames[] = {
24580 (char *) "self",(char *) "other", NULL
24581 };
24582
24583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24585 if (SWIG_arg_fail(1)) SWIG_fail;
24586 {
24587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24588 if (SWIG_arg_fail(2)) SWIG_fail;
24589 if (arg2 == NULL) {
24590 SWIG_null_ref("wxTimeSpan");
24591 }
24592 if (SWIG_arg_fail(2)) SWIG_fail;
24593 }
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24597
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 {
24602 wxTimeSpan * resultptr;
24603 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24605 }
24606 return resultobj;
24607 fail:
24608 return NULL;
24609 }
24610
24611
24612 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24613 PyObject *resultobj;
24614 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24615 wxTimeSpan *arg2 = 0 ;
24616 wxTimeSpan result;
24617 PyObject * obj0 = 0 ;
24618 PyObject * obj1 = 0 ;
24619 char *kwnames[] = {
24620 (char *) "self",(char *) "other", NULL
24621 };
24622
24623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24625 if (SWIG_arg_fail(1)) SWIG_fail;
24626 {
24627 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24628 if (SWIG_arg_fail(2)) SWIG_fail;
24629 if (arg2 == NULL) {
24630 SWIG_null_ref("wxTimeSpan");
24631 }
24632 if (SWIG_arg_fail(2)) SWIG_fail;
24633 }
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24637
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 {
24642 wxTimeSpan * resultptr;
24643 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24645 }
24646 return resultobj;
24647 fail:
24648 return NULL;
24649 }
24650
24651
24652 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj;
24654 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24655 int arg2 ;
24656 wxTimeSpan result;
24657 PyObject * obj0 = 0 ;
24658 PyObject * obj1 = 0 ;
24659 char *kwnames[] = {
24660 (char *) "self",(char *) "n", NULL
24661 };
24662
24663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24665 if (SWIG_arg_fail(1)) SWIG_fail;
24666 {
24667 arg2 = (int)(SWIG_As_int(obj1));
24668 if (SWIG_arg_fail(2)) SWIG_fail;
24669 }
24670 {
24671 PyThreadState* __tstate = wxPyBeginAllowThreads();
24672 result = wxTimeSpan___mul__(arg1,arg2);
24673
24674 wxPyEndAllowThreads(__tstate);
24675 if (PyErr_Occurred()) SWIG_fail;
24676 }
24677 {
24678 wxTimeSpan * resultptr;
24679 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24680 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24681 }
24682 return resultobj;
24683 fail:
24684 return NULL;
24685 }
24686
24687
24688 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24689 PyObject *resultobj;
24690 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24691 int arg2 ;
24692 wxTimeSpan result;
24693 PyObject * obj0 = 0 ;
24694 PyObject * obj1 = 0 ;
24695 char *kwnames[] = {
24696 (char *) "self",(char *) "n", NULL
24697 };
24698
24699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24701 if (SWIG_arg_fail(1)) SWIG_fail;
24702 {
24703 arg2 = (int)(SWIG_As_int(obj1));
24704 if (SWIG_arg_fail(2)) SWIG_fail;
24705 }
24706 {
24707 PyThreadState* __tstate = wxPyBeginAllowThreads();
24708 result = wxTimeSpan___rmul__(arg1,arg2);
24709
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 {
24714 wxTimeSpan * resultptr;
24715 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24716 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24725 PyObject *resultobj;
24726 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24727 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24728 bool result;
24729 PyObject * obj0 = 0 ;
24730 PyObject * obj1 = 0 ;
24731 char *kwnames[] = {
24732 (char *) "self",(char *) "other", NULL
24733 };
24734
24735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24737 if (SWIG_arg_fail(1)) SWIG_fail;
24738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24739 if (SWIG_arg_fail(2)) SWIG_fail;
24740 {
24741 PyThreadState* __tstate = wxPyBeginAllowThreads();
24742 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24743
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 {
24748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24749 }
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24757 PyObject *resultobj;
24758 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24759 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24760 bool result;
24761 PyObject * obj0 = 0 ;
24762 PyObject * obj1 = 0 ;
24763 char *kwnames[] = {
24764 (char *) "self",(char *) "other", NULL
24765 };
24766
24767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24769 if (SWIG_arg_fail(1)) SWIG_fail;
24770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24771 if (SWIG_arg_fail(2)) SWIG_fail;
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24775
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 {
24780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24781 }
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj;
24790 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24791 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24792 bool result;
24793 PyObject * obj0 = 0 ;
24794 PyObject * obj1 = 0 ;
24795 char *kwnames[] = {
24796 (char *) "self",(char *) "other", NULL
24797 };
24798
24799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24801 if (SWIG_arg_fail(1)) SWIG_fail;
24802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24803 if (SWIG_arg_fail(2)) SWIG_fail;
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24807
24808 wxPyEndAllowThreads(__tstate);
24809 if (PyErr_Occurred()) SWIG_fail;
24810 }
24811 {
24812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24813 }
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24821 PyObject *resultobj;
24822 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24823 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24824 bool result;
24825 PyObject * obj0 = 0 ;
24826 PyObject * obj1 = 0 ;
24827 char *kwnames[] = {
24828 (char *) "self",(char *) "other", NULL
24829 };
24830
24831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24833 if (SWIG_arg_fail(1)) SWIG_fail;
24834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24835 if (SWIG_arg_fail(2)) SWIG_fail;
24836 {
24837 PyThreadState* __tstate = wxPyBeginAllowThreads();
24838 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24839
24840 wxPyEndAllowThreads(__tstate);
24841 if (PyErr_Occurred()) SWIG_fail;
24842 }
24843 {
24844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24845 }
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24853 PyObject *resultobj;
24854 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24855 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24856 bool result;
24857 PyObject * obj0 = 0 ;
24858 PyObject * obj1 = 0 ;
24859 char *kwnames[] = {
24860 (char *) "self",(char *) "other", NULL
24861 };
24862
24863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24865 if (SWIG_arg_fail(1)) SWIG_fail;
24866 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24867 if (SWIG_arg_fail(2)) SWIG_fail;
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24871
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 {
24876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24877 }
24878 return resultobj;
24879 fail:
24880 return NULL;
24881 }
24882
24883
24884 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24885 PyObject *resultobj;
24886 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24887 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24888 bool result;
24889 PyObject * obj0 = 0 ;
24890 PyObject * obj1 = 0 ;
24891 char *kwnames[] = {
24892 (char *) "self",(char *) "other", NULL
24893 };
24894
24895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24897 if (SWIG_arg_fail(1)) SWIG_fail;
24898 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24899 if (SWIG_arg_fail(2)) SWIG_fail;
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24903
24904 wxPyEndAllowThreads(__tstate);
24905 if (PyErr_Occurred()) SWIG_fail;
24906 }
24907 {
24908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24909 }
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24917 PyObject *resultobj;
24918 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24919 bool result;
24920 PyObject * obj0 = 0 ;
24921 char *kwnames[] = {
24922 (char *) "self", NULL
24923 };
24924
24925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24927 if (SWIG_arg_fail(1)) SWIG_fail;
24928 {
24929 PyThreadState* __tstate = wxPyBeginAllowThreads();
24930 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24931
24932 wxPyEndAllowThreads(__tstate);
24933 if (PyErr_Occurred()) SWIG_fail;
24934 }
24935 {
24936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24937 }
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24947 bool result;
24948 PyObject * obj0 = 0 ;
24949 char *kwnames[] = {
24950 (char *) "self", NULL
24951 };
24952
24953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24955 if (SWIG_arg_fail(1)) SWIG_fail;
24956 {
24957 PyThreadState* __tstate = wxPyBeginAllowThreads();
24958 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24959
24960 wxPyEndAllowThreads(__tstate);
24961 if (PyErr_Occurred()) SWIG_fail;
24962 }
24963 {
24964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24965 }
24966 return resultobj;
24967 fail:
24968 return NULL;
24969 }
24970
24971
24972 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24973 PyObject *resultobj;
24974 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24975 bool result;
24976 PyObject * obj0 = 0 ;
24977 char *kwnames[] = {
24978 (char *) "self", NULL
24979 };
24980
24981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24983 if (SWIG_arg_fail(1)) SWIG_fail;
24984 {
24985 PyThreadState* __tstate = wxPyBeginAllowThreads();
24986 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24987
24988 wxPyEndAllowThreads(__tstate);
24989 if (PyErr_Occurred()) SWIG_fail;
24990 }
24991 {
24992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24993 }
24994 return resultobj;
24995 fail:
24996 return NULL;
24997 }
24998
24999
25000 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
25001 PyObject *resultobj;
25002 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25003 wxTimeSpan *arg2 = 0 ;
25004 bool result;
25005 PyObject * obj0 = 0 ;
25006 PyObject * obj1 = 0 ;
25007 char *kwnames[] = {
25008 (char *) "self",(char *) "ts", NULL
25009 };
25010
25011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25013 if (SWIG_arg_fail(1)) SWIG_fail;
25014 {
25015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25016 if (SWIG_arg_fail(2)) SWIG_fail;
25017 if (arg2 == NULL) {
25018 SWIG_null_ref("wxTimeSpan");
25019 }
25020 if (SWIG_arg_fail(2)) SWIG_fail;
25021 }
25022 {
25023 PyThreadState* __tstate = wxPyBeginAllowThreads();
25024 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25025
25026 wxPyEndAllowThreads(__tstate);
25027 if (PyErr_Occurred()) SWIG_fail;
25028 }
25029 {
25030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25031 }
25032 return resultobj;
25033 fail:
25034 return NULL;
25035 }
25036
25037
25038 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25039 PyObject *resultobj;
25040 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25041 wxTimeSpan *arg2 = 0 ;
25042 bool result;
25043 PyObject * obj0 = 0 ;
25044 PyObject * obj1 = 0 ;
25045 char *kwnames[] = {
25046 (char *) "self",(char *) "ts", NULL
25047 };
25048
25049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25051 if (SWIG_arg_fail(1)) SWIG_fail;
25052 {
25053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25054 if (SWIG_arg_fail(2)) SWIG_fail;
25055 if (arg2 == NULL) {
25056 SWIG_null_ref("wxTimeSpan");
25057 }
25058 if (SWIG_arg_fail(2)) SWIG_fail;
25059 }
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25063
25064 wxPyEndAllowThreads(__tstate);
25065 if (PyErr_Occurred()) SWIG_fail;
25066 }
25067 {
25068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25069 }
25070 return resultobj;
25071 fail:
25072 return NULL;
25073 }
25074
25075
25076 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25077 PyObject *resultobj;
25078 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25079 wxTimeSpan *arg2 = 0 ;
25080 bool result;
25081 PyObject * obj0 = 0 ;
25082 PyObject * obj1 = 0 ;
25083 char *kwnames[] = {
25084 (char *) "self",(char *) "t", NULL
25085 };
25086
25087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25089 if (SWIG_arg_fail(1)) SWIG_fail;
25090 {
25091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25092 if (SWIG_arg_fail(2)) SWIG_fail;
25093 if (arg2 == NULL) {
25094 SWIG_null_ref("wxTimeSpan");
25095 }
25096 if (SWIG_arg_fail(2)) SWIG_fail;
25097 }
25098 {
25099 PyThreadState* __tstate = wxPyBeginAllowThreads();
25100 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25101
25102 wxPyEndAllowThreads(__tstate);
25103 if (PyErr_Occurred()) SWIG_fail;
25104 }
25105 {
25106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25107 }
25108 return resultobj;
25109 fail:
25110 return NULL;
25111 }
25112
25113
25114 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25115 PyObject *resultobj;
25116 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25117 int result;
25118 PyObject * obj0 = 0 ;
25119 char *kwnames[] = {
25120 (char *) "self", NULL
25121 };
25122
25123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25125 if (SWIG_arg_fail(1)) SWIG_fail;
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25129
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 {
25134 resultobj = SWIG_From_int((int)(result));
25135 }
25136 return resultobj;
25137 fail:
25138 return NULL;
25139 }
25140
25141
25142 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25143 PyObject *resultobj;
25144 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25145 int result;
25146 PyObject * obj0 = 0 ;
25147 char *kwnames[] = {
25148 (char *) "self", NULL
25149 };
25150
25151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25153 if (SWIG_arg_fail(1)) SWIG_fail;
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 resultobj = SWIG_From_int((int)(result));
25163 }
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj;
25172 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25173 int result;
25174 PyObject * obj0 = 0 ;
25175 char *kwnames[] = {
25176 (char *) "self", NULL
25177 };
25178
25179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25181 if (SWIG_arg_fail(1)) SWIG_fail;
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25185
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 {
25190 resultobj = SWIG_From_int((int)(result));
25191 }
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj;
25200 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25201 int result;
25202 PyObject * obj0 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "self", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(1)) SWIG_fail;
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25213
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 resultobj = SWIG_From_int((int)(result));
25219 }
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25227 PyObject *resultobj;
25228 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25229 wxLongLong result;
25230 PyObject * obj0 = 0 ;
25231 char *kwnames[] = {
25232 (char *) "self", NULL
25233 };
25234
25235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25237 if (SWIG_arg_fail(1)) SWIG_fail;
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25241
25242 wxPyEndAllowThreads(__tstate);
25243 if (PyErr_Occurred()) SWIG_fail;
25244 }
25245 {
25246 PyObject *hi, *lo, *shifter, *shifted;
25247 hi = PyLong_FromLong( (&result)->GetHi() );
25248 lo = PyLong_FromLong( (&result)->GetLo() );
25249 shifter = PyLong_FromLong(32);
25250 shifted = PyNumber_Lshift(hi, shifter);
25251 resultobj = PyNumber_Or(shifted, lo);
25252 Py_DECREF(hi);
25253 Py_DECREF(lo);
25254 Py_DECREF(shifter);
25255 Py_DECREF(shifted);
25256 }
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25264 PyObject *resultobj;
25265 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25266 wxLongLong result;
25267 PyObject * obj0 = 0 ;
25268 char *kwnames[] = {
25269 (char *) "self", NULL
25270 };
25271
25272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25274 if (SWIG_arg_fail(1)) SWIG_fail;
25275 {
25276 PyThreadState* __tstate = wxPyBeginAllowThreads();
25277 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25278
25279 wxPyEndAllowThreads(__tstate);
25280 if (PyErr_Occurred()) SWIG_fail;
25281 }
25282 {
25283 PyObject *hi, *lo, *shifter, *shifted;
25284 hi = PyLong_FromLong( (&result)->GetHi() );
25285 lo = PyLong_FromLong( (&result)->GetLo() );
25286 shifter = PyLong_FromLong(32);
25287 shifted = PyNumber_Lshift(hi, shifter);
25288 resultobj = PyNumber_Or(shifted, lo);
25289 Py_DECREF(hi);
25290 Py_DECREF(lo);
25291 Py_DECREF(shifter);
25292 Py_DECREF(shifted);
25293 }
25294 return resultobj;
25295 fail:
25296 return NULL;
25297 }
25298
25299
25300 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25301 PyObject *resultobj;
25302 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25303 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25304 wxString *arg2 = (wxString *) &arg2_defvalue ;
25305 wxString result;
25306 bool temp2 = false ;
25307 PyObject * obj0 = 0 ;
25308 PyObject * obj1 = 0 ;
25309 char *kwnames[] = {
25310 (char *) "self",(char *) "format", NULL
25311 };
25312
25313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25315 if (SWIG_arg_fail(1)) SWIG_fail;
25316 if (obj1) {
25317 {
25318 arg2 = wxString_in_helper(obj1);
25319 if (arg2 == NULL) SWIG_fail;
25320 temp2 = true;
25321 }
25322 }
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25326
25327 wxPyEndAllowThreads(__tstate);
25328 if (PyErr_Occurred()) SWIG_fail;
25329 }
25330 {
25331 #if wxUSE_UNICODE
25332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25333 #else
25334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25335 #endif
25336 }
25337 {
25338 if (temp2)
25339 delete arg2;
25340 }
25341 return resultobj;
25342 fail:
25343 {
25344 if (temp2)
25345 delete arg2;
25346 }
25347 return NULL;
25348 }
25349
25350
25351 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25352 PyObject *obj;
25353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25354 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25355 Py_INCREF(obj);
25356 return Py_BuildValue((char *)"");
25357 }
25358 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25359 PyObject *resultobj;
25360 int arg1 = (int) 0 ;
25361 int arg2 = (int) 0 ;
25362 int arg3 = (int) 0 ;
25363 int arg4 = (int) 0 ;
25364 wxDateSpan *result;
25365 PyObject * obj0 = 0 ;
25366 PyObject * obj1 = 0 ;
25367 PyObject * obj2 = 0 ;
25368 PyObject * obj3 = 0 ;
25369 char *kwnames[] = {
25370 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25371 };
25372
25373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25374 if (obj0) {
25375 {
25376 arg1 = (int)(SWIG_As_int(obj0));
25377 if (SWIG_arg_fail(1)) SWIG_fail;
25378 }
25379 }
25380 if (obj1) {
25381 {
25382 arg2 = (int)(SWIG_As_int(obj1));
25383 if (SWIG_arg_fail(2)) SWIG_fail;
25384 }
25385 }
25386 if (obj2) {
25387 {
25388 arg3 = (int)(SWIG_As_int(obj2));
25389 if (SWIG_arg_fail(3)) SWIG_fail;
25390 }
25391 }
25392 if (obj3) {
25393 {
25394 arg4 = (int)(SWIG_As_int(obj3));
25395 if (SWIG_arg_fail(4)) SWIG_fail;
25396 }
25397 }
25398 {
25399 PyThreadState* __tstate = wxPyBeginAllowThreads();
25400 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25401
25402 wxPyEndAllowThreads(__tstate);
25403 if (PyErr_Occurred()) SWIG_fail;
25404 }
25405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25406 return resultobj;
25407 fail:
25408 return NULL;
25409 }
25410
25411
25412 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25413 PyObject *resultobj;
25414 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25415 PyObject * obj0 = 0 ;
25416 char *kwnames[] = {
25417 (char *) "self", NULL
25418 };
25419
25420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25422 if (SWIG_arg_fail(1)) SWIG_fail;
25423 {
25424 PyThreadState* __tstate = wxPyBeginAllowThreads();
25425 delete arg1;
25426
25427 wxPyEndAllowThreads(__tstate);
25428 if (PyErr_Occurred()) SWIG_fail;
25429 }
25430 Py_INCREF(Py_None); resultobj = Py_None;
25431 return resultobj;
25432 fail:
25433 return NULL;
25434 }
25435
25436
25437 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25438 PyObject *resultobj;
25439 int arg1 ;
25440 wxDateSpan result;
25441 PyObject * obj0 = 0 ;
25442 char *kwnames[] = {
25443 (char *) "days", NULL
25444 };
25445
25446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25447 {
25448 arg1 = (int)(SWIG_As_int(obj0));
25449 if (SWIG_arg_fail(1)) SWIG_fail;
25450 }
25451 {
25452 PyThreadState* __tstate = wxPyBeginAllowThreads();
25453 result = wxDateSpan::Days(arg1);
25454
25455 wxPyEndAllowThreads(__tstate);
25456 if (PyErr_Occurred()) SWIG_fail;
25457 }
25458 {
25459 wxDateSpan * resultptr;
25460 resultptr = new wxDateSpan((wxDateSpan &)(result));
25461 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25462 }
25463 return resultobj;
25464 fail:
25465 return NULL;
25466 }
25467
25468
25469 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25470 PyObject *resultobj;
25471 wxDateSpan result;
25472 char *kwnames[] = {
25473 NULL
25474 };
25475
25476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25477 {
25478 PyThreadState* __tstate = wxPyBeginAllowThreads();
25479 result = wxDateSpan::Day();
25480
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 {
25485 wxDateSpan * resultptr;
25486 resultptr = new wxDateSpan((wxDateSpan &)(result));
25487 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25488 }
25489 return resultobj;
25490 fail:
25491 return NULL;
25492 }
25493
25494
25495 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj;
25497 int arg1 ;
25498 wxDateSpan result;
25499 PyObject * obj0 = 0 ;
25500 char *kwnames[] = {
25501 (char *) "weeks", NULL
25502 };
25503
25504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25505 {
25506 arg1 = (int)(SWIG_As_int(obj0));
25507 if (SWIG_arg_fail(1)) SWIG_fail;
25508 }
25509 {
25510 PyThreadState* __tstate = wxPyBeginAllowThreads();
25511 result = wxDateSpan::Weeks(arg1);
25512
25513 wxPyEndAllowThreads(__tstate);
25514 if (PyErr_Occurred()) SWIG_fail;
25515 }
25516 {
25517 wxDateSpan * resultptr;
25518 resultptr = new wxDateSpan((wxDateSpan &)(result));
25519 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25520 }
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25528 PyObject *resultobj;
25529 wxDateSpan result;
25530 char *kwnames[] = {
25531 NULL
25532 };
25533
25534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25535 {
25536 PyThreadState* __tstate = wxPyBeginAllowThreads();
25537 result = wxDateSpan::Week();
25538
25539 wxPyEndAllowThreads(__tstate);
25540 if (PyErr_Occurred()) SWIG_fail;
25541 }
25542 {
25543 wxDateSpan * resultptr;
25544 resultptr = new wxDateSpan((wxDateSpan &)(result));
25545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25546 }
25547 return resultobj;
25548 fail:
25549 return NULL;
25550 }
25551
25552
25553 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25554 PyObject *resultobj;
25555 int arg1 ;
25556 wxDateSpan result;
25557 PyObject * obj0 = 0 ;
25558 char *kwnames[] = {
25559 (char *) "mon", NULL
25560 };
25561
25562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25563 {
25564 arg1 = (int)(SWIG_As_int(obj0));
25565 if (SWIG_arg_fail(1)) SWIG_fail;
25566 }
25567 {
25568 PyThreadState* __tstate = wxPyBeginAllowThreads();
25569 result = wxDateSpan::Months(arg1);
25570
25571 wxPyEndAllowThreads(__tstate);
25572 if (PyErr_Occurred()) SWIG_fail;
25573 }
25574 {
25575 wxDateSpan * resultptr;
25576 resultptr = new wxDateSpan((wxDateSpan &)(result));
25577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25578 }
25579 return resultobj;
25580 fail:
25581 return NULL;
25582 }
25583
25584
25585 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25586 PyObject *resultobj;
25587 wxDateSpan result;
25588 char *kwnames[] = {
25589 NULL
25590 };
25591
25592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25593 {
25594 PyThreadState* __tstate = wxPyBeginAllowThreads();
25595 result = wxDateSpan::Month();
25596
25597 wxPyEndAllowThreads(__tstate);
25598 if (PyErr_Occurred()) SWIG_fail;
25599 }
25600 {
25601 wxDateSpan * resultptr;
25602 resultptr = new wxDateSpan((wxDateSpan &)(result));
25603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25604 }
25605 return resultobj;
25606 fail:
25607 return NULL;
25608 }
25609
25610
25611 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25612 PyObject *resultobj;
25613 int arg1 ;
25614 wxDateSpan result;
25615 PyObject * obj0 = 0 ;
25616 char *kwnames[] = {
25617 (char *) "years", NULL
25618 };
25619
25620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25621 {
25622 arg1 = (int)(SWIG_As_int(obj0));
25623 if (SWIG_arg_fail(1)) SWIG_fail;
25624 }
25625 {
25626 PyThreadState* __tstate = wxPyBeginAllowThreads();
25627 result = wxDateSpan::Years(arg1);
25628
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 {
25633 wxDateSpan * resultptr;
25634 resultptr = new wxDateSpan((wxDateSpan &)(result));
25635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25644 PyObject *resultobj;
25645 wxDateSpan result;
25646 char *kwnames[] = {
25647 NULL
25648 };
25649
25650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 result = wxDateSpan::Year();
25654
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 {
25659 wxDateSpan * resultptr;
25660 resultptr = new wxDateSpan((wxDateSpan &)(result));
25661 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25662 }
25663 return resultobj;
25664 fail:
25665 return NULL;
25666 }
25667
25668
25669 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25670 PyObject *resultobj;
25671 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25672 int arg2 ;
25673 wxDateSpan *result;
25674 PyObject * obj0 = 0 ;
25675 PyObject * obj1 = 0 ;
25676 char *kwnames[] = {
25677 (char *) "self",(char *) "n", NULL
25678 };
25679
25680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25682 if (SWIG_arg_fail(1)) SWIG_fail;
25683 {
25684 arg2 = (int)(SWIG_As_int(obj1));
25685 if (SWIG_arg_fail(2)) SWIG_fail;
25686 }
25687 {
25688 PyThreadState* __tstate = wxPyBeginAllowThreads();
25689 {
25690 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25691 result = (wxDateSpan *) &_result_ref;
25692 }
25693
25694 wxPyEndAllowThreads(__tstate);
25695 if (PyErr_Occurred()) SWIG_fail;
25696 }
25697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25705 PyObject *resultobj;
25706 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25707 int arg2 ;
25708 wxDateSpan *result;
25709 PyObject * obj0 = 0 ;
25710 PyObject * obj1 = 0 ;
25711 char *kwnames[] = {
25712 (char *) "self",(char *) "n", NULL
25713 };
25714
25715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25717 if (SWIG_arg_fail(1)) SWIG_fail;
25718 {
25719 arg2 = (int)(SWIG_As_int(obj1));
25720 if (SWIG_arg_fail(2)) SWIG_fail;
25721 }
25722 {
25723 PyThreadState* __tstate = wxPyBeginAllowThreads();
25724 {
25725 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25726 result = (wxDateSpan *) &_result_ref;
25727 }
25728
25729 wxPyEndAllowThreads(__tstate);
25730 if (PyErr_Occurred()) SWIG_fail;
25731 }
25732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj;
25741 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25742 int arg2 ;
25743 wxDateSpan *result;
25744 PyObject * obj0 = 0 ;
25745 PyObject * obj1 = 0 ;
25746 char *kwnames[] = {
25747 (char *) "self",(char *) "n", NULL
25748 };
25749
25750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25752 if (SWIG_arg_fail(1)) SWIG_fail;
25753 {
25754 arg2 = (int)(SWIG_As_int(obj1));
25755 if (SWIG_arg_fail(2)) SWIG_fail;
25756 }
25757 {
25758 PyThreadState* __tstate = wxPyBeginAllowThreads();
25759 {
25760 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25761 result = (wxDateSpan *) &_result_ref;
25762 }
25763
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25775 PyObject *resultobj;
25776 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25777 int arg2 ;
25778 wxDateSpan *result;
25779 PyObject * obj0 = 0 ;
25780 PyObject * obj1 = 0 ;
25781 char *kwnames[] = {
25782 (char *) "self",(char *) "n", NULL
25783 };
25784
25785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25787 if (SWIG_arg_fail(1)) SWIG_fail;
25788 {
25789 arg2 = (int)(SWIG_As_int(obj1));
25790 if (SWIG_arg_fail(2)) SWIG_fail;
25791 }
25792 {
25793 PyThreadState* __tstate = wxPyBeginAllowThreads();
25794 {
25795 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25796 result = (wxDateSpan *) &_result_ref;
25797 }
25798
25799 wxPyEndAllowThreads(__tstate);
25800 if (PyErr_Occurred()) SWIG_fail;
25801 }
25802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25803 return resultobj;
25804 fail:
25805 return NULL;
25806 }
25807
25808
25809 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25810 PyObject *resultobj;
25811 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25812 int result;
25813 PyObject * obj0 = 0 ;
25814 char *kwnames[] = {
25815 (char *) "self", NULL
25816 };
25817
25818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25820 if (SWIG_arg_fail(1)) SWIG_fail;
25821 {
25822 PyThreadState* __tstate = wxPyBeginAllowThreads();
25823 result = (int)((wxDateSpan const *)arg1)->GetYears();
25824
25825 wxPyEndAllowThreads(__tstate);
25826 if (PyErr_Occurred()) SWIG_fail;
25827 }
25828 {
25829 resultobj = SWIG_From_int((int)(result));
25830 }
25831 return resultobj;
25832 fail:
25833 return NULL;
25834 }
25835
25836
25837 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25838 PyObject *resultobj;
25839 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25840 int result;
25841 PyObject * obj0 = 0 ;
25842 char *kwnames[] = {
25843 (char *) "self", NULL
25844 };
25845
25846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25848 if (SWIG_arg_fail(1)) SWIG_fail;
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25852
25853 wxPyEndAllowThreads(__tstate);
25854 if (PyErr_Occurred()) SWIG_fail;
25855 }
25856 {
25857 resultobj = SWIG_From_int((int)(result));
25858 }
25859 return resultobj;
25860 fail:
25861 return NULL;
25862 }
25863
25864
25865 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj;
25867 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25868 int result;
25869 PyObject * obj0 = 0 ;
25870 char *kwnames[] = {
25871 (char *) "self", NULL
25872 };
25873
25874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25876 if (SWIG_arg_fail(1)) SWIG_fail;
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25880
25881 wxPyEndAllowThreads(__tstate);
25882 if (PyErr_Occurred()) SWIG_fail;
25883 }
25884 {
25885 resultobj = SWIG_From_int((int)(result));
25886 }
25887 return resultobj;
25888 fail:
25889 return NULL;
25890 }
25891
25892
25893 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25894 PyObject *resultobj;
25895 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25896 int result;
25897 PyObject * obj0 = 0 ;
25898 char *kwnames[] = {
25899 (char *) "self", NULL
25900 };
25901
25902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25904 if (SWIG_arg_fail(1)) SWIG_fail;
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 result = (int)((wxDateSpan const *)arg1)->GetDays();
25908
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 {
25913 resultobj = SWIG_From_int((int)(result));
25914 }
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25922 PyObject *resultobj;
25923 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25924 int result;
25925 PyObject * obj0 = 0 ;
25926 char *kwnames[] = {
25927 (char *) "self", NULL
25928 };
25929
25930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25932 if (SWIG_arg_fail(1)) SWIG_fail;
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25936
25937 wxPyEndAllowThreads(__tstate);
25938 if (PyErr_Occurred()) SWIG_fail;
25939 }
25940 {
25941 resultobj = SWIG_From_int((int)(result));
25942 }
25943 return resultobj;
25944 fail:
25945 return NULL;
25946 }
25947
25948
25949 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25950 PyObject *resultobj;
25951 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25952 wxDateSpan *arg2 = 0 ;
25953 wxDateSpan *result;
25954 PyObject * obj0 = 0 ;
25955 PyObject * obj1 = 0 ;
25956 char *kwnames[] = {
25957 (char *) "self",(char *) "other", NULL
25958 };
25959
25960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25962 if (SWIG_arg_fail(1)) SWIG_fail;
25963 {
25964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25965 if (SWIG_arg_fail(2)) SWIG_fail;
25966 if (arg2 == NULL) {
25967 SWIG_null_ref("wxDateSpan");
25968 }
25969 if (SWIG_arg_fail(2)) SWIG_fail;
25970 }
25971 {
25972 PyThreadState* __tstate = wxPyBeginAllowThreads();
25973 {
25974 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25975 result = (wxDateSpan *) &_result_ref;
25976 }
25977
25978 wxPyEndAllowThreads(__tstate);
25979 if (PyErr_Occurred()) SWIG_fail;
25980 }
25981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25982 return resultobj;
25983 fail:
25984 return NULL;
25985 }
25986
25987
25988 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25989 PyObject *resultobj;
25990 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25991 wxDateSpan *arg2 = 0 ;
25992 wxDateSpan *result;
25993 PyObject * obj0 = 0 ;
25994 PyObject * obj1 = 0 ;
25995 char *kwnames[] = {
25996 (char *) "self",(char *) "other", NULL
25997 };
25998
25999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
26000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26001 if (SWIG_arg_fail(1)) SWIG_fail;
26002 {
26003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26004 if (SWIG_arg_fail(2)) SWIG_fail;
26005 if (arg2 == NULL) {
26006 SWIG_null_ref("wxDateSpan");
26007 }
26008 if (SWIG_arg_fail(2)) SWIG_fail;
26009 }
26010 {
26011 PyThreadState* __tstate = wxPyBeginAllowThreads();
26012 {
26013 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26014 result = (wxDateSpan *) &_result_ref;
26015 }
26016
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj;
26029 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26030 wxDateSpan *result;
26031 PyObject * obj0 = 0 ;
26032 char *kwnames[] = {
26033 (char *) "self", NULL
26034 };
26035
26036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 {
26042 wxDateSpan &_result_ref = (arg1)->Neg();
26043 result = (wxDateSpan *) &_result_ref;
26044 }
26045
26046 wxPyEndAllowThreads(__tstate);
26047 if (PyErr_Occurred()) SWIG_fail;
26048 }
26049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26050 return resultobj;
26051 fail:
26052 return NULL;
26053 }
26054
26055
26056 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26057 PyObject *resultobj;
26058 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26059 int arg2 ;
26060 wxDateSpan *result;
26061 PyObject * obj0 = 0 ;
26062 PyObject * obj1 = 0 ;
26063 char *kwnames[] = {
26064 (char *) "self",(char *) "factor", NULL
26065 };
26066
26067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26069 if (SWIG_arg_fail(1)) SWIG_fail;
26070 {
26071 arg2 = (int)(SWIG_As_int(obj1));
26072 if (SWIG_arg_fail(2)) SWIG_fail;
26073 }
26074 {
26075 PyThreadState* __tstate = wxPyBeginAllowThreads();
26076 {
26077 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26078 result = (wxDateSpan *) &_result_ref;
26079 }
26080
26081 wxPyEndAllowThreads(__tstate);
26082 if (PyErr_Occurred()) SWIG_fail;
26083 }
26084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26092 PyObject *resultobj;
26093 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26094 wxDateSpan *arg2 = 0 ;
26095 wxDateSpan *result;
26096 PyObject * obj0 = 0 ;
26097 PyObject * obj1 = 0 ;
26098 char *kwnames[] = {
26099 (char *) "self",(char *) "other", NULL
26100 };
26101
26102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26104 if (SWIG_arg_fail(1)) SWIG_fail;
26105 {
26106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26107 if (SWIG_arg_fail(2)) SWIG_fail;
26108 if (arg2 == NULL) {
26109 SWIG_null_ref("wxDateSpan");
26110 }
26111 if (SWIG_arg_fail(2)) SWIG_fail;
26112 }
26113 {
26114 PyThreadState* __tstate = wxPyBeginAllowThreads();
26115 {
26116 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26117 result = (wxDateSpan *) &_result_ref;
26118 }
26119
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26131 PyObject *resultobj;
26132 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26133 wxDateSpan *arg2 = 0 ;
26134 wxDateSpan *result;
26135 PyObject * obj0 = 0 ;
26136 PyObject * obj1 = 0 ;
26137 char *kwnames[] = {
26138 (char *) "self",(char *) "other", NULL
26139 };
26140
26141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26143 if (SWIG_arg_fail(1)) SWIG_fail;
26144 {
26145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26146 if (SWIG_arg_fail(2)) SWIG_fail;
26147 if (arg2 == NULL) {
26148 SWIG_null_ref("wxDateSpan");
26149 }
26150 if (SWIG_arg_fail(2)) SWIG_fail;
26151 }
26152 {
26153 PyThreadState* __tstate = wxPyBeginAllowThreads();
26154 {
26155 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26156 result = (wxDateSpan *) &_result_ref;
26157 }
26158
26159 wxPyEndAllowThreads(__tstate);
26160 if (PyErr_Occurred()) SWIG_fail;
26161 }
26162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26163 return resultobj;
26164 fail:
26165 return NULL;
26166 }
26167
26168
26169 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26170 PyObject *resultobj;
26171 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26172 wxDateSpan *result;
26173 PyObject * obj0 = 0 ;
26174 char *kwnames[] = {
26175 (char *) "self", NULL
26176 };
26177
26178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26180 if (SWIG_arg_fail(1)) SWIG_fail;
26181 {
26182 PyThreadState* __tstate = wxPyBeginAllowThreads();
26183 {
26184 wxDateSpan &_result_ref = (arg1)->operator -();
26185 result = (wxDateSpan *) &_result_ref;
26186 }
26187
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26192 return resultobj;
26193 fail:
26194 return NULL;
26195 }
26196
26197
26198 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26199 PyObject *resultobj;
26200 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26201 int arg2 ;
26202 wxDateSpan *result;
26203 PyObject * obj0 = 0 ;
26204 PyObject * obj1 = 0 ;
26205 char *kwnames[] = {
26206 (char *) "self",(char *) "factor", NULL
26207 };
26208
26209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26211 if (SWIG_arg_fail(1)) SWIG_fail;
26212 {
26213 arg2 = (int)(SWIG_As_int(obj1));
26214 if (SWIG_arg_fail(2)) SWIG_fail;
26215 }
26216 {
26217 PyThreadState* __tstate = wxPyBeginAllowThreads();
26218 {
26219 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26220 result = (wxDateSpan *) &_result_ref;
26221 }
26222
26223 wxPyEndAllowThreads(__tstate);
26224 if (PyErr_Occurred()) SWIG_fail;
26225 }
26226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26227 return resultobj;
26228 fail:
26229 return NULL;
26230 }
26231
26232
26233 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26234 PyObject *resultobj;
26235 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26236 wxDateSpan *arg2 = 0 ;
26237 wxDateSpan result;
26238 PyObject * obj0 = 0 ;
26239 PyObject * obj1 = 0 ;
26240 char *kwnames[] = {
26241 (char *) "self",(char *) "other", NULL
26242 };
26243
26244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26246 if (SWIG_arg_fail(1)) SWIG_fail;
26247 {
26248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26249 if (SWIG_arg_fail(2)) SWIG_fail;
26250 if (arg2 == NULL) {
26251 SWIG_null_ref("wxDateSpan");
26252 }
26253 if (SWIG_arg_fail(2)) SWIG_fail;
26254 }
26255 {
26256 PyThreadState* __tstate = wxPyBeginAllowThreads();
26257 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26258
26259 wxPyEndAllowThreads(__tstate);
26260 if (PyErr_Occurred()) SWIG_fail;
26261 }
26262 {
26263 wxDateSpan * resultptr;
26264 resultptr = new wxDateSpan((wxDateSpan &)(result));
26265 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26266 }
26267 return resultobj;
26268 fail:
26269 return NULL;
26270 }
26271
26272
26273 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26274 PyObject *resultobj;
26275 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26276 wxDateSpan *arg2 = 0 ;
26277 wxDateSpan result;
26278 PyObject * obj0 = 0 ;
26279 PyObject * obj1 = 0 ;
26280 char *kwnames[] = {
26281 (char *) "self",(char *) "other", NULL
26282 };
26283
26284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26286 if (SWIG_arg_fail(1)) SWIG_fail;
26287 {
26288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26289 if (SWIG_arg_fail(2)) SWIG_fail;
26290 if (arg2 == NULL) {
26291 SWIG_null_ref("wxDateSpan");
26292 }
26293 if (SWIG_arg_fail(2)) SWIG_fail;
26294 }
26295 {
26296 PyThreadState* __tstate = wxPyBeginAllowThreads();
26297 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26298
26299 wxPyEndAllowThreads(__tstate);
26300 if (PyErr_Occurred()) SWIG_fail;
26301 }
26302 {
26303 wxDateSpan * resultptr;
26304 resultptr = new wxDateSpan((wxDateSpan &)(result));
26305 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26306 }
26307 return resultobj;
26308 fail:
26309 return NULL;
26310 }
26311
26312
26313 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26314 PyObject *resultobj;
26315 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26316 int arg2 ;
26317 wxDateSpan result;
26318 PyObject * obj0 = 0 ;
26319 PyObject * obj1 = 0 ;
26320 char *kwnames[] = {
26321 (char *) "self",(char *) "n", NULL
26322 };
26323
26324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26326 if (SWIG_arg_fail(1)) SWIG_fail;
26327 {
26328 arg2 = (int)(SWIG_As_int(obj1));
26329 if (SWIG_arg_fail(2)) SWIG_fail;
26330 }
26331 {
26332 PyThreadState* __tstate = wxPyBeginAllowThreads();
26333 result = wxDateSpan___mul__(arg1,arg2);
26334
26335 wxPyEndAllowThreads(__tstate);
26336 if (PyErr_Occurred()) SWIG_fail;
26337 }
26338 {
26339 wxDateSpan * resultptr;
26340 resultptr = new wxDateSpan((wxDateSpan &)(result));
26341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26342 }
26343 return resultobj;
26344 fail:
26345 return NULL;
26346 }
26347
26348
26349 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26350 PyObject *resultobj;
26351 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26352 int arg2 ;
26353 wxDateSpan result;
26354 PyObject * obj0 = 0 ;
26355 PyObject * obj1 = 0 ;
26356 char *kwnames[] = {
26357 (char *) "self",(char *) "n", NULL
26358 };
26359
26360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26362 if (SWIG_arg_fail(1)) SWIG_fail;
26363 {
26364 arg2 = (int)(SWIG_As_int(obj1));
26365 if (SWIG_arg_fail(2)) SWIG_fail;
26366 }
26367 {
26368 PyThreadState* __tstate = wxPyBeginAllowThreads();
26369 result = wxDateSpan___rmul__(arg1,arg2);
26370
26371 wxPyEndAllowThreads(__tstate);
26372 if (PyErr_Occurred()) SWIG_fail;
26373 }
26374 {
26375 wxDateSpan * resultptr;
26376 resultptr = new wxDateSpan((wxDateSpan &)(result));
26377 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26378 }
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26386 PyObject *resultobj;
26387 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26388 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26389 bool result;
26390 PyObject * obj0 = 0 ;
26391 PyObject * obj1 = 0 ;
26392 char *kwnames[] = {
26393 (char *) "self",(char *) "other", NULL
26394 };
26395
26396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26398 if (SWIG_arg_fail(1)) SWIG_fail;
26399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26400 if (SWIG_arg_fail(2)) SWIG_fail;
26401 {
26402 PyThreadState* __tstate = wxPyBeginAllowThreads();
26403 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26404
26405 wxPyEndAllowThreads(__tstate);
26406 if (PyErr_Occurred()) SWIG_fail;
26407 }
26408 {
26409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26410 }
26411 return resultobj;
26412 fail:
26413 return NULL;
26414 }
26415
26416
26417 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26418 PyObject *resultobj;
26419 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26420 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26421 bool result;
26422 PyObject * obj0 = 0 ;
26423 PyObject * obj1 = 0 ;
26424 char *kwnames[] = {
26425 (char *) "self",(char *) "other", NULL
26426 };
26427
26428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26430 if (SWIG_arg_fail(1)) SWIG_fail;
26431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26432 if (SWIG_arg_fail(2)) SWIG_fail;
26433 {
26434 PyThreadState* __tstate = wxPyBeginAllowThreads();
26435 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26436
26437 wxPyEndAllowThreads(__tstate);
26438 if (PyErr_Occurred()) SWIG_fail;
26439 }
26440 {
26441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26442 }
26443 return resultobj;
26444 fail:
26445 return NULL;
26446 }
26447
26448
26449 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26450 PyObject *obj;
26451 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26452 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26453 Py_INCREF(obj);
26454 return Py_BuildValue((char *)"");
26455 }
26456 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26457 PyObject *resultobj;
26458 long result;
26459 char *kwnames[] = {
26460 NULL
26461 };
26462
26463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 result = (long)wxGetLocalTime();
26467
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 {
26472 resultobj = SWIG_From_long((long)(result));
26473 }
26474 return resultobj;
26475 fail:
26476 return NULL;
26477 }
26478
26479
26480 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26481 PyObject *resultobj;
26482 long result;
26483 char *kwnames[] = {
26484 NULL
26485 };
26486
26487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26488 {
26489 PyThreadState* __tstate = wxPyBeginAllowThreads();
26490 result = (long)wxGetUTCTime();
26491
26492 wxPyEndAllowThreads(__tstate);
26493 if (PyErr_Occurred()) SWIG_fail;
26494 }
26495 {
26496 resultobj = SWIG_From_long((long)(result));
26497 }
26498 return resultobj;
26499 fail:
26500 return NULL;
26501 }
26502
26503
26504 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26505 PyObject *resultobj;
26506 long result;
26507 char *kwnames[] = {
26508 NULL
26509 };
26510
26511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26512 {
26513 PyThreadState* __tstate = wxPyBeginAllowThreads();
26514 result = (long)wxGetCurrentTime();
26515
26516 wxPyEndAllowThreads(__tstate);
26517 if (PyErr_Occurred()) SWIG_fail;
26518 }
26519 {
26520 resultobj = SWIG_From_long((long)(result));
26521 }
26522 return resultobj;
26523 fail:
26524 return NULL;
26525 }
26526
26527
26528 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26529 PyObject *resultobj;
26530 wxLongLong result;
26531 char *kwnames[] = {
26532 NULL
26533 };
26534
26535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26536 {
26537 PyThreadState* __tstate = wxPyBeginAllowThreads();
26538 result = wxGetLocalTimeMillis();
26539
26540 wxPyEndAllowThreads(__tstate);
26541 if (PyErr_Occurred()) SWIG_fail;
26542 }
26543 {
26544 PyObject *hi, *lo, *shifter, *shifted;
26545 hi = PyLong_FromLong( (&result)->GetHi() );
26546 lo = PyLong_FromLong( (&result)->GetLo() );
26547 shifter = PyLong_FromLong(32);
26548 shifted = PyNumber_Lshift(hi, shifter);
26549 resultobj = PyNumber_Or(shifted, lo);
26550 Py_DECREF(hi);
26551 Py_DECREF(lo);
26552 Py_DECREF(shifter);
26553 Py_DECREF(shifted);
26554 }
26555 return resultobj;
26556 fail:
26557 return NULL;
26558 }
26559
26560
26561 static int _wrap_DefaultDateTime_set(PyObject *) {
26562 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26563 return 1;
26564 }
26565
26566
26567 static PyObject *_wrap_DefaultDateTime_get(void) {
26568 PyObject *pyobj;
26569
26570 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26571 return pyobj;
26572 }
26573
26574
26575 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj;
26577 wxDataFormatId arg1 ;
26578 wxDataFormat *result;
26579 PyObject * obj0 = 0 ;
26580 char *kwnames[] = {
26581 (char *) "type", NULL
26582 };
26583
26584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26585 {
26586 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26587 if (SWIG_arg_fail(1)) SWIG_fail;
26588 }
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26592
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26604 PyObject *resultobj;
26605 wxString *arg1 = 0 ;
26606 wxDataFormat *result;
26607 bool temp1 = false ;
26608 PyObject * obj0 = 0 ;
26609 char *kwnames[] = {
26610 (char *) "format", NULL
26611 };
26612
26613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26614 {
26615 arg1 = wxString_in_helper(obj0);
26616 if (arg1 == NULL) SWIG_fail;
26617 temp1 = true;
26618 }
26619 {
26620 PyThreadState* __tstate = wxPyBeginAllowThreads();
26621 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26622
26623 wxPyEndAllowThreads(__tstate);
26624 if (PyErr_Occurred()) SWIG_fail;
26625 }
26626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26627 {
26628 if (temp1)
26629 delete arg1;
26630 }
26631 return resultobj;
26632 fail:
26633 {
26634 if (temp1)
26635 delete arg1;
26636 }
26637 return NULL;
26638 }
26639
26640
26641 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26642 PyObject *resultobj;
26643 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26644 PyObject * obj0 = 0 ;
26645 char *kwnames[] = {
26646 (char *) "self", NULL
26647 };
26648
26649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26651 if (SWIG_arg_fail(1)) SWIG_fail;
26652 {
26653 PyThreadState* __tstate = wxPyBeginAllowThreads();
26654 delete arg1;
26655
26656 wxPyEndAllowThreads(__tstate);
26657 if (PyErr_Occurred()) SWIG_fail;
26658 }
26659 Py_INCREF(Py_None); resultobj = Py_None;
26660 return resultobj;
26661 fail:
26662 return NULL;
26663 }
26664
26665
26666 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26667 PyObject *resultobj;
26668 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26669 wxDataFormatId arg2 ;
26670 bool result;
26671 PyObject * obj0 = 0 ;
26672 PyObject * obj1 = 0 ;
26673
26674 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26676 if (SWIG_arg_fail(1)) SWIG_fail;
26677 {
26678 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26679 if (SWIG_arg_fail(2)) SWIG_fail;
26680 }
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26684
26685 wxPyEndAllowThreads(__tstate);
26686 if (PyErr_Occurred()) SWIG_fail;
26687 }
26688 {
26689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26690 }
26691 return resultobj;
26692 fail:
26693 return NULL;
26694 }
26695
26696
26697 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26698 PyObject *resultobj;
26699 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26700 wxDataFormatId arg2 ;
26701 bool result;
26702 PyObject * obj0 = 0 ;
26703 PyObject * obj1 = 0 ;
26704
26705 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26707 if (SWIG_arg_fail(1)) SWIG_fail;
26708 {
26709 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26710 if (SWIG_arg_fail(2)) SWIG_fail;
26711 }
26712 {
26713 PyThreadState* __tstate = wxPyBeginAllowThreads();
26714 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26715
26716 wxPyEndAllowThreads(__tstate);
26717 if (PyErr_Occurred()) SWIG_fail;
26718 }
26719 {
26720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26721 }
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26729 PyObject *resultobj;
26730 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26731 wxDataFormat *arg2 = 0 ;
26732 bool result;
26733 PyObject * obj0 = 0 ;
26734 PyObject * obj1 = 0 ;
26735
26736 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26738 if (SWIG_arg_fail(1)) SWIG_fail;
26739 {
26740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26741 if (SWIG_arg_fail(2)) SWIG_fail;
26742 if (arg2 == NULL) {
26743 SWIG_null_ref("wxDataFormat");
26744 }
26745 if (SWIG_arg_fail(2)) SWIG_fail;
26746 }
26747 {
26748 PyThreadState* __tstate = wxPyBeginAllowThreads();
26749 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26750
26751 wxPyEndAllowThreads(__tstate);
26752 if (PyErr_Occurred()) SWIG_fail;
26753 }
26754 {
26755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26756 }
26757 return resultobj;
26758 fail:
26759 return NULL;
26760 }
26761
26762
26763 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26764 int argc;
26765 PyObject *argv[3];
26766 int ii;
26767
26768 argc = PyObject_Length(args);
26769 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26770 argv[ii] = PyTuple_GetItem(args,ii);
26771 }
26772 if (argc == 2) {
26773 int _v;
26774 {
26775 void *ptr;
26776 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26777 _v = 0;
26778 PyErr_Clear();
26779 } else {
26780 _v = 1;
26781 }
26782 }
26783 if (_v) {
26784 {
26785 void *ptr = 0;
26786 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26787 _v = 0;
26788 PyErr_Clear();
26789 } else {
26790 _v = (ptr != 0);
26791 }
26792 }
26793 if (_v) {
26794 return _wrap_DataFormat___eq____SWIG_1(self,args);
26795 }
26796 }
26797 }
26798 if (argc == 2) {
26799 int _v;
26800 {
26801 void *ptr;
26802 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26803 _v = 0;
26804 PyErr_Clear();
26805 } else {
26806 _v = 1;
26807 }
26808 }
26809 if (_v) {
26810 _v = SWIG_Check_int(argv[1]);
26811 if (_v) {
26812 return _wrap_DataFormat___eq____SWIG_0(self,args);
26813 }
26814 }
26815 }
26816
26817 Py_INCREF(Py_NotImplemented);
26818 return Py_NotImplemented;
26819 }
26820
26821
26822 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26823 PyObject *resultobj;
26824 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26825 wxDataFormat *arg2 = 0 ;
26826 bool result;
26827 PyObject * obj0 = 0 ;
26828 PyObject * obj1 = 0 ;
26829
26830 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26832 if (SWIG_arg_fail(1)) SWIG_fail;
26833 {
26834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26835 if (SWIG_arg_fail(2)) SWIG_fail;
26836 if (arg2 == NULL) {
26837 SWIG_null_ref("wxDataFormat");
26838 }
26839 if (SWIG_arg_fail(2)) SWIG_fail;
26840 }
26841 {
26842 PyThreadState* __tstate = wxPyBeginAllowThreads();
26843 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26844
26845 wxPyEndAllowThreads(__tstate);
26846 if (PyErr_Occurred()) SWIG_fail;
26847 }
26848 {
26849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26850 }
26851 return resultobj;
26852 fail:
26853 return NULL;
26854 }
26855
26856
26857 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26858 int argc;
26859 PyObject *argv[3];
26860 int ii;
26861
26862 argc = PyObject_Length(args);
26863 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26864 argv[ii] = PyTuple_GetItem(args,ii);
26865 }
26866 if (argc == 2) {
26867 int _v;
26868 {
26869 void *ptr;
26870 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26871 _v = 0;
26872 PyErr_Clear();
26873 } else {
26874 _v = 1;
26875 }
26876 }
26877 if (_v) {
26878 {
26879 void *ptr = 0;
26880 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26881 _v = 0;
26882 PyErr_Clear();
26883 } else {
26884 _v = (ptr != 0);
26885 }
26886 }
26887 if (_v) {
26888 return _wrap_DataFormat___ne____SWIG_1(self,args);
26889 }
26890 }
26891 }
26892 if (argc == 2) {
26893 int _v;
26894 {
26895 void *ptr;
26896 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26897 _v = 0;
26898 PyErr_Clear();
26899 } else {
26900 _v = 1;
26901 }
26902 }
26903 if (_v) {
26904 _v = SWIG_Check_int(argv[1]);
26905 if (_v) {
26906 return _wrap_DataFormat___ne____SWIG_0(self,args);
26907 }
26908 }
26909 }
26910
26911 Py_INCREF(Py_NotImplemented);
26912 return Py_NotImplemented;
26913 }
26914
26915
26916 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26917 PyObject *resultobj;
26918 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26919 wxDataFormatId arg2 ;
26920 PyObject * obj0 = 0 ;
26921 PyObject * obj1 = 0 ;
26922 char *kwnames[] = {
26923 (char *) "self",(char *) "format", NULL
26924 };
26925
26926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26928 if (SWIG_arg_fail(1)) SWIG_fail;
26929 {
26930 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26931 if (SWIG_arg_fail(2)) SWIG_fail;
26932 }
26933 {
26934 PyThreadState* __tstate = wxPyBeginAllowThreads();
26935 (arg1)->SetType((wxDataFormatId )arg2);
26936
26937 wxPyEndAllowThreads(__tstate);
26938 if (PyErr_Occurred()) SWIG_fail;
26939 }
26940 Py_INCREF(Py_None); resultobj = Py_None;
26941 return resultobj;
26942 fail:
26943 return NULL;
26944 }
26945
26946
26947 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26948 PyObject *resultobj;
26949 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26950 wxDataFormatId result;
26951 PyObject * obj0 = 0 ;
26952 char *kwnames[] = {
26953 (char *) "self", NULL
26954 };
26955
26956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26962
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 resultobj = SWIG_From_int((result));
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26974 PyObject *resultobj;
26975 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26976 wxString result;
26977 PyObject * obj0 = 0 ;
26978 char *kwnames[] = {
26979 (char *) "self", NULL
26980 };
26981
26982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26984 if (SWIG_arg_fail(1)) SWIG_fail;
26985 {
26986 PyThreadState* __tstate = wxPyBeginAllowThreads();
26987 result = ((wxDataFormat const *)arg1)->GetId();
26988
26989 wxPyEndAllowThreads(__tstate);
26990 if (PyErr_Occurred()) SWIG_fail;
26991 }
26992 {
26993 #if wxUSE_UNICODE
26994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26995 #else
26996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26997 #endif
26998 }
26999 return resultobj;
27000 fail:
27001 return NULL;
27002 }
27003
27004
27005 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27006 PyObject *resultobj;
27007 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27008 wxString *arg2 = 0 ;
27009 bool temp2 = false ;
27010 PyObject * obj0 = 0 ;
27011 PyObject * obj1 = 0 ;
27012 char *kwnames[] = {
27013 (char *) "self",(char *) "format", NULL
27014 };
27015
27016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27018 if (SWIG_arg_fail(1)) SWIG_fail;
27019 {
27020 arg2 = wxString_in_helper(obj1);
27021 if (arg2 == NULL) SWIG_fail;
27022 temp2 = true;
27023 }
27024 {
27025 PyThreadState* __tstate = wxPyBeginAllowThreads();
27026 (arg1)->SetId((wxString const &)*arg2);
27027
27028 wxPyEndAllowThreads(__tstate);
27029 if (PyErr_Occurred()) SWIG_fail;
27030 }
27031 Py_INCREF(Py_None); resultobj = Py_None;
27032 {
27033 if (temp2)
27034 delete arg2;
27035 }
27036 return resultobj;
27037 fail:
27038 {
27039 if (temp2)
27040 delete arg2;
27041 }
27042 return NULL;
27043 }
27044
27045
27046 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27047 PyObject *obj;
27048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27049 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27050 Py_INCREF(obj);
27051 return Py_BuildValue((char *)"");
27052 }
27053 static int _wrap_FormatInvalid_set(PyObject *) {
27054 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27055 return 1;
27056 }
27057
27058
27059 static PyObject *_wrap_FormatInvalid_get(void) {
27060 PyObject *pyobj;
27061
27062 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27063 return pyobj;
27064 }
27065
27066
27067 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27068 PyObject *resultobj;
27069 wxDataObject *arg1 = (wxDataObject *) 0 ;
27070 PyObject * obj0 = 0 ;
27071 char *kwnames[] = {
27072 (char *) "self", NULL
27073 };
27074
27075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27077 if (SWIG_arg_fail(1)) SWIG_fail;
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 delete arg1;
27081
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 Py_INCREF(Py_None); resultobj = Py_None;
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj;
27094 wxDataObject *arg1 = (wxDataObject *) 0 ;
27095 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27096 SwigValueWrapper<wxDataFormat > result;
27097 PyObject * obj0 = 0 ;
27098 PyObject * obj1 = 0 ;
27099 char *kwnames[] = {
27100 (char *) "self",(char *) "dir", NULL
27101 };
27102
27103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27105 if (SWIG_arg_fail(1)) SWIG_fail;
27106 if (obj1) {
27107 {
27108 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27109 if (SWIG_arg_fail(2)) SWIG_fail;
27110 }
27111 }
27112 {
27113 PyThreadState* __tstate = wxPyBeginAllowThreads();
27114 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27115
27116 wxPyEndAllowThreads(__tstate);
27117 if (PyErr_Occurred()) SWIG_fail;
27118 }
27119 {
27120 wxDataFormat * resultptr;
27121 resultptr = new wxDataFormat((wxDataFormat &)(result));
27122 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27123 }
27124 return resultobj;
27125 fail:
27126 return NULL;
27127 }
27128
27129
27130 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27131 PyObject *resultobj;
27132 wxDataObject *arg1 = (wxDataObject *) 0 ;
27133 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27134 size_t result;
27135 PyObject * obj0 = 0 ;
27136 PyObject * obj1 = 0 ;
27137 char *kwnames[] = {
27138 (char *) "self",(char *) "dir", NULL
27139 };
27140
27141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27143 if (SWIG_arg_fail(1)) SWIG_fail;
27144 if (obj1) {
27145 {
27146 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27147 if (SWIG_arg_fail(2)) SWIG_fail;
27148 }
27149 }
27150 {
27151 PyThreadState* __tstate = wxPyBeginAllowThreads();
27152 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27153
27154 wxPyEndAllowThreads(__tstate);
27155 if (PyErr_Occurred()) SWIG_fail;
27156 }
27157 {
27158 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27159 }
27160 return resultobj;
27161 fail:
27162 return NULL;
27163 }
27164
27165
27166 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27167 PyObject *resultobj;
27168 wxDataObject *arg1 = (wxDataObject *) 0 ;
27169 wxDataFormat *arg2 = 0 ;
27170 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27171 bool result;
27172 PyObject * obj0 = 0 ;
27173 PyObject * obj1 = 0 ;
27174 PyObject * obj2 = 0 ;
27175 char *kwnames[] = {
27176 (char *) "self",(char *) "format",(char *) "dir", NULL
27177 };
27178
27179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27181 if (SWIG_arg_fail(1)) SWIG_fail;
27182 {
27183 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27184 if (SWIG_arg_fail(2)) SWIG_fail;
27185 if (arg2 == NULL) {
27186 SWIG_null_ref("wxDataFormat");
27187 }
27188 if (SWIG_arg_fail(2)) SWIG_fail;
27189 }
27190 if (obj2) {
27191 {
27192 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27193 if (SWIG_arg_fail(3)) SWIG_fail;
27194 }
27195 }
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27199
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 {
27204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27205 }
27206 return resultobj;
27207 fail:
27208 return NULL;
27209 }
27210
27211
27212 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27213 PyObject *resultobj;
27214 wxDataObject *arg1 = (wxDataObject *) 0 ;
27215 wxDataFormat *arg2 = 0 ;
27216 size_t result;
27217 PyObject * obj0 = 0 ;
27218 PyObject * obj1 = 0 ;
27219 char *kwnames[] = {
27220 (char *) "self",(char *) "format", NULL
27221 };
27222
27223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27225 if (SWIG_arg_fail(1)) SWIG_fail;
27226 {
27227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27228 if (SWIG_arg_fail(2)) SWIG_fail;
27229 if (arg2 == NULL) {
27230 SWIG_null_ref("wxDataFormat");
27231 }
27232 if (SWIG_arg_fail(2)) SWIG_fail;
27233 }
27234 {
27235 PyThreadState* __tstate = wxPyBeginAllowThreads();
27236 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27237
27238 wxPyEndAllowThreads(__tstate);
27239 if (PyErr_Occurred()) SWIG_fail;
27240 }
27241 {
27242 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27243 }
27244 return resultobj;
27245 fail:
27246 return NULL;
27247 }
27248
27249
27250 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27251 PyObject *resultobj;
27252 wxDataObject *arg1 = (wxDataObject *) 0 ;
27253 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27254 PyObject *result;
27255 PyObject * obj0 = 0 ;
27256 PyObject * obj1 = 0 ;
27257 char *kwnames[] = {
27258 (char *) "self",(char *) "dir", NULL
27259 };
27260
27261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27263 if (SWIG_arg_fail(1)) SWIG_fail;
27264 if (obj1) {
27265 {
27266 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27267 if (SWIG_arg_fail(2)) SWIG_fail;
27268 }
27269 }
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27273
27274 wxPyEndAllowThreads(__tstate);
27275 if (PyErr_Occurred()) SWIG_fail;
27276 }
27277 resultobj = result;
27278 return resultobj;
27279 fail:
27280 return NULL;
27281 }
27282
27283
27284 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27285 PyObject *resultobj;
27286 wxDataObject *arg1 = (wxDataObject *) 0 ;
27287 wxDataFormat *arg2 = 0 ;
27288 PyObject *result;
27289 PyObject * obj0 = 0 ;
27290 PyObject * obj1 = 0 ;
27291 char *kwnames[] = {
27292 (char *) "self",(char *) "format", NULL
27293 };
27294
27295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27297 if (SWIG_arg_fail(1)) SWIG_fail;
27298 {
27299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27300 if (SWIG_arg_fail(2)) SWIG_fail;
27301 if (arg2 == NULL) {
27302 SWIG_null_ref("wxDataFormat");
27303 }
27304 if (SWIG_arg_fail(2)) SWIG_fail;
27305 }
27306 {
27307 PyThreadState* __tstate = wxPyBeginAllowThreads();
27308 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27309
27310 wxPyEndAllowThreads(__tstate);
27311 if (PyErr_Occurred()) SWIG_fail;
27312 }
27313 resultobj = result;
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27321 PyObject *resultobj;
27322 wxDataObject *arg1 = (wxDataObject *) 0 ;
27323 wxDataFormat *arg2 = 0 ;
27324 PyObject *arg3 = (PyObject *) 0 ;
27325 bool result;
27326 PyObject * obj0 = 0 ;
27327 PyObject * obj1 = 0 ;
27328 PyObject * obj2 = 0 ;
27329 char *kwnames[] = {
27330 (char *) "self",(char *) "format",(char *) "data", NULL
27331 };
27332
27333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27335 if (SWIG_arg_fail(1)) SWIG_fail;
27336 {
27337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27338 if (SWIG_arg_fail(2)) SWIG_fail;
27339 if (arg2 == NULL) {
27340 SWIG_null_ref("wxDataFormat");
27341 }
27342 if (SWIG_arg_fail(2)) SWIG_fail;
27343 }
27344 arg3 = obj2;
27345 {
27346 PyThreadState* __tstate = wxPyBeginAllowThreads();
27347 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27348
27349 wxPyEndAllowThreads(__tstate);
27350 if (PyErr_Occurred()) SWIG_fail;
27351 }
27352 {
27353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27354 }
27355 return resultobj;
27356 fail:
27357 return NULL;
27358 }
27359
27360
27361 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27362 PyObject *obj;
27363 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27364 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27365 Py_INCREF(obj);
27366 return Py_BuildValue((char *)"");
27367 }
27368 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27369 PyObject *resultobj;
27370 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27371 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27372 wxDataObjectSimple *result;
27373 PyObject * obj0 = 0 ;
27374 char *kwnames[] = {
27375 (char *) "format", NULL
27376 };
27377
27378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27379 if (obj0) {
27380 {
27381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27382 if (SWIG_arg_fail(1)) SWIG_fail;
27383 if (arg1 == NULL) {
27384 SWIG_null_ref("wxDataFormat");
27385 }
27386 if (SWIG_arg_fail(1)) SWIG_fail;
27387 }
27388 }
27389 {
27390 PyThreadState* __tstate = wxPyBeginAllowThreads();
27391 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27392
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27404 PyObject *resultobj;
27405 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27406 wxDataFormat *result;
27407 PyObject * obj0 = 0 ;
27408 char *kwnames[] = {
27409 (char *) "self", NULL
27410 };
27411
27412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27414 if (SWIG_arg_fail(1)) SWIG_fail;
27415 {
27416 PyThreadState* __tstate = wxPyBeginAllowThreads();
27417 {
27418 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27419 result = (wxDataFormat *) &_result_ref;
27420 }
27421
27422 wxPyEndAllowThreads(__tstate);
27423 if (PyErr_Occurred()) SWIG_fail;
27424 }
27425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27426 return resultobj;
27427 fail:
27428 return NULL;
27429 }
27430
27431
27432 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27433 PyObject *resultobj;
27434 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27435 wxDataFormat *arg2 = 0 ;
27436 PyObject * obj0 = 0 ;
27437 PyObject * obj1 = 0 ;
27438 char *kwnames[] = {
27439 (char *) "self",(char *) "format", NULL
27440 };
27441
27442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27444 if (SWIG_arg_fail(1)) SWIG_fail;
27445 {
27446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27447 if (SWIG_arg_fail(2)) SWIG_fail;
27448 if (arg2 == NULL) {
27449 SWIG_null_ref("wxDataFormat");
27450 }
27451 if (SWIG_arg_fail(2)) SWIG_fail;
27452 }
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27456
27457 wxPyEndAllowThreads(__tstate);
27458 if (PyErr_Occurred()) SWIG_fail;
27459 }
27460 Py_INCREF(Py_None); resultobj = Py_None;
27461 return resultobj;
27462 fail:
27463 return NULL;
27464 }
27465
27466
27467 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27468 PyObject *resultobj;
27469 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27470 size_t result;
27471 PyObject * obj0 = 0 ;
27472 char *kwnames[] = {
27473 (char *) "self", NULL
27474 };
27475
27476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27478 if (SWIG_arg_fail(1)) SWIG_fail;
27479 {
27480 PyThreadState* __tstate = wxPyBeginAllowThreads();
27481 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27482
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 {
27487 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27488 }
27489 return resultobj;
27490 fail:
27491 return NULL;
27492 }
27493
27494
27495 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27496 PyObject *resultobj;
27497 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27498 PyObject *result;
27499 PyObject * obj0 = 0 ;
27500 char *kwnames[] = {
27501 (char *) "self", NULL
27502 };
27503
27504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27506 if (SWIG_arg_fail(1)) SWIG_fail;
27507 {
27508 PyThreadState* __tstate = wxPyBeginAllowThreads();
27509 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27510
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 resultobj = result;
27515 return resultobj;
27516 fail:
27517 return NULL;
27518 }
27519
27520
27521 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27522 PyObject *resultobj;
27523 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27524 PyObject *arg2 = (PyObject *) 0 ;
27525 bool result;
27526 PyObject * obj0 = 0 ;
27527 PyObject * obj1 = 0 ;
27528 char *kwnames[] = {
27529 (char *) "self",(char *) "data", NULL
27530 };
27531
27532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27534 if (SWIG_arg_fail(1)) SWIG_fail;
27535 arg2 = obj1;
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27539
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 {
27544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27545 }
27546 return resultobj;
27547 fail:
27548 return NULL;
27549 }
27550
27551
27552 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27553 PyObject *obj;
27554 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27555 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27556 Py_INCREF(obj);
27557 return Py_BuildValue((char *)"");
27558 }
27559 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27560 PyObject *resultobj;
27561 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27562 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27563 wxPyDataObjectSimple *result;
27564 PyObject * obj0 = 0 ;
27565 char *kwnames[] = {
27566 (char *) "format", NULL
27567 };
27568
27569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27570 if (obj0) {
27571 {
27572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27573 if (SWIG_arg_fail(1)) SWIG_fail;
27574 if (arg1 == NULL) {
27575 SWIG_null_ref("wxDataFormat");
27576 }
27577 if (SWIG_arg_fail(1)) SWIG_fail;
27578 }
27579 }
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27583
27584 wxPyEndAllowThreads(__tstate);
27585 if (PyErr_Occurred()) SWIG_fail;
27586 }
27587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27588 return resultobj;
27589 fail:
27590 return NULL;
27591 }
27592
27593
27594 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27595 PyObject *resultobj;
27596 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27597 PyObject *arg2 = (PyObject *) 0 ;
27598 PyObject *arg3 = (PyObject *) 0 ;
27599 PyObject * obj0 = 0 ;
27600 PyObject * obj1 = 0 ;
27601 PyObject * obj2 = 0 ;
27602 char *kwnames[] = {
27603 (char *) "self",(char *) "self",(char *) "_class", NULL
27604 };
27605
27606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27608 if (SWIG_arg_fail(1)) SWIG_fail;
27609 arg2 = obj1;
27610 arg3 = obj2;
27611 {
27612 PyThreadState* __tstate = wxPyBeginAllowThreads();
27613 (arg1)->_setCallbackInfo(arg2,arg3);
27614
27615 wxPyEndAllowThreads(__tstate);
27616 if (PyErr_Occurred()) SWIG_fail;
27617 }
27618 Py_INCREF(Py_None); resultobj = Py_None;
27619 return resultobj;
27620 fail:
27621 return NULL;
27622 }
27623
27624
27625 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27626 PyObject *obj;
27627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27628 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27629 Py_INCREF(obj);
27630 return Py_BuildValue((char *)"");
27631 }
27632 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27633 PyObject *resultobj;
27634 wxDataObjectComposite *result;
27635 char *kwnames[] = {
27636 NULL
27637 };
27638
27639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27643
27644 wxPyEndAllowThreads(__tstate);
27645 if (PyErr_Occurred()) SWIG_fail;
27646 }
27647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27655 PyObject *resultobj;
27656 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27657 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27658 bool arg3 = (bool) false ;
27659 PyObject * obj0 = 0 ;
27660 PyObject * obj1 = 0 ;
27661 PyObject * obj2 = 0 ;
27662 char *kwnames[] = {
27663 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27664 };
27665
27666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27668 if (SWIG_arg_fail(1)) SWIG_fail;
27669 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27670 if (SWIG_arg_fail(2)) SWIG_fail;
27671 if (obj2) {
27672 {
27673 arg3 = (bool)(SWIG_As_bool(obj2));
27674 if (SWIG_arg_fail(3)) SWIG_fail;
27675 }
27676 }
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 (arg1)->Add(arg2,arg3);
27680
27681 wxPyEndAllowThreads(__tstate);
27682 if (PyErr_Occurred()) SWIG_fail;
27683 }
27684 Py_INCREF(Py_None); resultobj = Py_None;
27685 return resultobj;
27686 fail:
27687 return NULL;
27688 }
27689
27690
27691 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27692 PyObject *obj;
27693 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27694 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27695 Py_INCREF(obj);
27696 return Py_BuildValue((char *)"");
27697 }
27698 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27699 PyObject *resultobj;
27700 wxString const &arg1_defvalue = wxPyEmptyString ;
27701 wxString *arg1 = (wxString *) &arg1_defvalue ;
27702 wxTextDataObject *result;
27703 bool temp1 = false ;
27704 PyObject * obj0 = 0 ;
27705 char *kwnames[] = {
27706 (char *) "text", NULL
27707 };
27708
27709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27710 if (obj0) {
27711 {
27712 arg1 = wxString_in_helper(obj0);
27713 if (arg1 == NULL) SWIG_fail;
27714 temp1 = true;
27715 }
27716 }
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27720
27721 wxPyEndAllowThreads(__tstate);
27722 if (PyErr_Occurred()) SWIG_fail;
27723 }
27724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27725 {
27726 if (temp1)
27727 delete arg1;
27728 }
27729 return resultobj;
27730 fail:
27731 {
27732 if (temp1)
27733 delete arg1;
27734 }
27735 return NULL;
27736 }
27737
27738
27739 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27740 PyObject *resultobj;
27741 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27742 size_t result;
27743 PyObject * obj0 = 0 ;
27744 char *kwnames[] = {
27745 (char *) "self", NULL
27746 };
27747
27748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27750 if (SWIG_arg_fail(1)) SWIG_fail;
27751 {
27752 PyThreadState* __tstate = wxPyBeginAllowThreads();
27753 result = (size_t)(arg1)->GetTextLength();
27754
27755 wxPyEndAllowThreads(__tstate);
27756 if (PyErr_Occurred()) SWIG_fail;
27757 }
27758 {
27759 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27760 }
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27768 PyObject *resultobj;
27769 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27770 wxString result;
27771 PyObject * obj0 = 0 ;
27772 char *kwnames[] = {
27773 (char *) "self", NULL
27774 };
27775
27776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27778 if (SWIG_arg_fail(1)) SWIG_fail;
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = (arg1)->GetText();
27782
27783 wxPyEndAllowThreads(__tstate);
27784 if (PyErr_Occurred()) SWIG_fail;
27785 }
27786 {
27787 #if wxUSE_UNICODE
27788 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27789 #else
27790 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27791 #endif
27792 }
27793 return resultobj;
27794 fail:
27795 return NULL;
27796 }
27797
27798
27799 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27800 PyObject *resultobj;
27801 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27802 wxString *arg2 = 0 ;
27803 bool temp2 = false ;
27804 PyObject * obj0 = 0 ;
27805 PyObject * obj1 = 0 ;
27806 char *kwnames[] = {
27807 (char *) "self",(char *) "text", NULL
27808 };
27809
27810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27812 if (SWIG_arg_fail(1)) SWIG_fail;
27813 {
27814 arg2 = wxString_in_helper(obj1);
27815 if (arg2 == NULL) SWIG_fail;
27816 temp2 = true;
27817 }
27818 {
27819 PyThreadState* __tstate = wxPyBeginAllowThreads();
27820 (arg1)->SetText((wxString const &)*arg2);
27821
27822 wxPyEndAllowThreads(__tstate);
27823 if (PyErr_Occurred()) SWIG_fail;
27824 }
27825 Py_INCREF(Py_None); resultobj = Py_None;
27826 {
27827 if (temp2)
27828 delete arg2;
27829 }
27830 return resultobj;
27831 fail:
27832 {
27833 if (temp2)
27834 delete arg2;
27835 }
27836 return NULL;
27837 }
27838
27839
27840 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27841 PyObject *obj;
27842 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27843 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27844 Py_INCREF(obj);
27845 return Py_BuildValue((char *)"");
27846 }
27847 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27848 PyObject *resultobj;
27849 wxString const &arg1_defvalue = wxPyEmptyString ;
27850 wxString *arg1 = (wxString *) &arg1_defvalue ;
27851 wxPyTextDataObject *result;
27852 bool temp1 = false ;
27853 PyObject * obj0 = 0 ;
27854 char *kwnames[] = {
27855 (char *) "text", NULL
27856 };
27857
27858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27859 if (obj0) {
27860 {
27861 arg1 = wxString_in_helper(obj0);
27862 if (arg1 == NULL) SWIG_fail;
27863 temp1 = true;
27864 }
27865 }
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27869
27870 wxPyEndAllowThreads(__tstate);
27871 if (PyErr_Occurred()) SWIG_fail;
27872 }
27873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27874 {
27875 if (temp1)
27876 delete arg1;
27877 }
27878 return resultobj;
27879 fail:
27880 {
27881 if (temp1)
27882 delete arg1;
27883 }
27884 return NULL;
27885 }
27886
27887
27888 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj;
27890 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27891 PyObject *arg2 = (PyObject *) 0 ;
27892 PyObject *arg3 = (PyObject *) 0 ;
27893 PyObject * obj0 = 0 ;
27894 PyObject * obj1 = 0 ;
27895 PyObject * obj2 = 0 ;
27896 char *kwnames[] = {
27897 (char *) "self",(char *) "self",(char *) "_class", NULL
27898 };
27899
27900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27902 if (SWIG_arg_fail(1)) SWIG_fail;
27903 arg2 = obj1;
27904 arg3 = obj2;
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 (arg1)->_setCallbackInfo(arg2,arg3);
27908
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 Py_INCREF(Py_None); resultobj = Py_None;
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27920 PyObject *obj;
27921 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27922 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27923 Py_INCREF(obj);
27924 return Py_BuildValue((char *)"");
27925 }
27926 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27927 PyObject *resultobj;
27928 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27929 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27930 wxBitmapDataObject *result;
27931 PyObject * obj0 = 0 ;
27932 char *kwnames[] = {
27933 (char *) "bitmap", NULL
27934 };
27935
27936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27937 if (obj0) {
27938 {
27939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27940 if (SWIG_arg_fail(1)) SWIG_fail;
27941 if (arg1 == NULL) {
27942 SWIG_null_ref("wxBitmap");
27943 }
27944 if (SWIG_arg_fail(1)) SWIG_fail;
27945 }
27946 }
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27950
27951 wxPyEndAllowThreads(__tstate);
27952 if (PyErr_Occurred()) SWIG_fail;
27953 }
27954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj;
27963 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27964 wxBitmap result;
27965 PyObject * obj0 = 0 ;
27966 char *kwnames[] = {
27967 (char *) "self", NULL
27968 };
27969
27970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27972 if (SWIG_arg_fail(1)) SWIG_fail;
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27976
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 {
27981 wxBitmap * resultptr;
27982 resultptr = new wxBitmap((wxBitmap &)(result));
27983 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27984 }
27985 return resultobj;
27986 fail:
27987 return NULL;
27988 }
27989
27990
27991 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27992 PyObject *resultobj;
27993 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27994 wxBitmap *arg2 = 0 ;
27995 PyObject * obj0 = 0 ;
27996 PyObject * obj1 = 0 ;
27997 char *kwnames[] = {
27998 (char *) "self",(char *) "bitmap", NULL
27999 };
28000
28001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28003 if (SWIG_arg_fail(1)) SWIG_fail;
28004 {
28005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28006 if (SWIG_arg_fail(2)) SWIG_fail;
28007 if (arg2 == NULL) {
28008 SWIG_null_ref("wxBitmap");
28009 }
28010 if (SWIG_arg_fail(2)) SWIG_fail;
28011 }
28012 {
28013 PyThreadState* __tstate = wxPyBeginAllowThreads();
28014 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28015
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 Py_INCREF(Py_None); resultobj = Py_None;
28020 return resultobj;
28021 fail:
28022 return NULL;
28023 }
28024
28025
28026 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28027 PyObject *obj;
28028 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28029 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28030 Py_INCREF(obj);
28031 return Py_BuildValue((char *)"");
28032 }
28033 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28034 PyObject *resultobj;
28035 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28036 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28037 wxPyBitmapDataObject *result;
28038 PyObject * obj0 = 0 ;
28039 char *kwnames[] = {
28040 (char *) "bitmap", NULL
28041 };
28042
28043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28044 if (obj0) {
28045 {
28046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28047 if (SWIG_arg_fail(1)) SWIG_fail;
28048 if (arg1 == NULL) {
28049 SWIG_null_ref("wxBitmap");
28050 }
28051 if (SWIG_arg_fail(1)) SWIG_fail;
28052 }
28053 }
28054 {
28055 PyThreadState* __tstate = wxPyBeginAllowThreads();
28056 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28057
28058 wxPyEndAllowThreads(__tstate);
28059 if (PyErr_Occurred()) SWIG_fail;
28060 }
28061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28062 return resultobj;
28063 fail:
28064 return NULL;
28065 }
28066
28067
28068 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28069 PyObject *resultobj;
28070 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28071 PyObject *arg2 = (PyObject *) 0 ;
28072 PyObject *arg3 = (PyObject *) 0 ;
28073 PyObject * obj0 = 0 ;
28074 PyObject * obj1 = 0 ;
28075 PyObject * obj2 = 0 ;
28076 char *kwnames[] = {
28077 (char *) "self",(char *) "self",(char *) "_class", NULL
28078 };
28079
28080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28082 if (SWIG_arg_fail(1)) SWIG_fail;
28083 arg2 = obj1;
28084 arg3 = obj2;
28085 {
28086 PyThreadState* __tstate = wxPyBeginAllowThreads();
28087 (arg1)->_setCallbackInfo(arg2,arg3);
28088
28089 wxPyEndAllowThreads(__tstate);
28090 if (PyErr_Occurred()) SWIG_fail;
28091 }
28092 Py_INCREF(Py_None); resultobj = Py_None;
28093 return resultobj;
28094 fail:
28095 return NULL;
28096 }
28097
28098
28099 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28100 PyObject *obj;
28101 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28102 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28103 Py_INCREF(obj);
28104 return Py_BuildValue((char *)"");
28105 }
28106 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28107 PyObject *resultobj;
28108 wxFileDataObject *result;
28109 char *kwnames[] = {
28110 NULL
28111 };
28112
28113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28114 {
28115 PyThreadState* __tstate = wxPyBeginAllowThreads();
28116 result = (wxFileDataObject *)new wxFileDataObject();
28117
28118 wxPyEndAllowThreads(__tstate);
28119 if (PyErr_Occurred()) SWIG_fail;
28120 }
28121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28122 return resultobj;
28123 fail:
28124 return NULL;
28125 }
28126
28127
28128 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28129 PyObject *resultobj;
28130 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28131 wxArrayString *result;
28132 PyObject * obj0 = 0 ;
28133 char *kwnames[] = {
28134 (char *) "self", NULL
28135 };
28136
28137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28139 if (SWIG_arg_fail(1)) SWIG_fail;
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 {
28143 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28144 result = (wxArrayString *) &_result_ref;
28145 }
28146
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 {
28151 resultobj = wxArrayString2PyList_helper(*result);
28152 }
28153 return resultobj;
28154 fail:
28155 return NULL;
28156 }
28157
28158
28159 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28160 PyObject *resultobj;
28161 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28162 wxString *arg2 = 0 ;
28163 bool temp2 = false ;
28164 PyObject * obj0 = 0 ;
28165 PyObject * obj1 = 0 ;
28166 char *kwnames[] = {
28167 (char *) "self",(char *) "filename", NULL
28168 };
28169
28170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28172 if (SWIG_arg_fail(1)) SWIG_fail;
28173 {
28174 arg2 = wxString_in_helper(obj1);
28175 if (arg2 == NULL) SWIG_fail;
28176 temp2 = true;
28177 }
28178 {
28179 PyThreadState* __tstate = wxPyBeginAllowThreads();
28180 (arg1)->AddFile((wxString const &)*arg2);
28181
28182 wxPyEndAllowThreads(__tstate);
28183 if (PyErr_Occurred()) SWIG_fail;
28184 }
28185 Py_INCREF(Py_None); resultobj = Py_None;
28186 {
28187 if (temp2)
28188 delete arg2;
28189 }
28190 return resultobj;
28191 fail:
28192 {
28193 if (temp2)
28194 delete arg2;
28195 }
28196 return NULL;
28197 }
28198
28199
28200 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28201 PyObject *obj;
28202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28203 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28204 Py_INCREF(obj);
28205 return Py_BuildValue((char *)"");
28206 }
28207 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28208 PyObject *resultobj;
28209 wxDataFormat *arg1 = 0 ;
28210 wxCustomDataObject *result;
28211 PyObject * obj0 = 0 ;
28212
28213 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28214 {
28215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28216 if (SWIG_arg_fail(1)) SWIG_fail;
28217 if (arg1 == NULL) {
28218 SWIG_null_ref("wxDataFormat");
28219 }
28220 if (SWIG_arg_fail(1)) SWIG_fail;
28221 }
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28225
28226 wxPyEndAllowThreads(__tstate);
28227 if (PyErr_Occurred()) SWIG_fail;
28228 }
28229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28230 return resultobj;
28231 fail:
28232 return NULL;
28233 }
28234
28235
28236 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28237 PyObject *resultobj;
28238 wxString *arg1 = 0 ;
28239 wxCustomDataObject *result;
28240 bool temp1 = false ;
28241 PyObject * obj0 = 0 ;
28242
28243 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28244 {
28245 arg1 = wxString_in_helper(obj0);
28246 if (arg1 == NULL) SWIG_fail;
28247 temp1 = true;
28248 }
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28252
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28257 {
28258 if (temp1)
28259 delete arg1;
28260 }
28261 return resultobj;
28262 fail:
28263 {
28264 if (temp1)
28265 delete arg1;
28266 }
28267 return NULL;
28268 }
28269
28270
28271 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28272 PyObject *resultobj;
28273 wxCustomDataObject *result;
28274
28275 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28276 {
28277 PyThreadState* __tstate = wxPyBeginAllowThreads();
28278 result = (wxCustomDataObject *)new wxCustomDataObject();
28279
28280 wxPyEndAllowThreads(__tstate);
28281 if (PyErr_Occurred()) SWIG_fail;
28282 }
28283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28284 return resultobj;
28285 fail:
28286 return NULL;
28287 }
28288
28289
28290 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28291 int argc;
28292 PyObject *argv[2];
28293 int ii;
28294
28295 argc = PyObject_Length(args);
28296 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28297 argv[ii] = PyTuple_GetItem(args,ii);
28298 }
28299 if (argc == 0) {
28300 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28301 }
28302 if (argc == 1) {
28303 int _v;
28304 {
28305 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28306 }
28307 if (_v) {
28308 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28309 }
28310 }
28311 if (argc == 1) {
28312 int _v;
28313 {
28314 void *ptr = 0;
28315 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28316 _v = 0;
28317 PyErr_Clear();
28318 } else {
28319 _v = (ptr != 0);
28320 }
28321 }
28322 if (_v) {
28323 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28324 }
28325 }
28326
28327 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28328 return NULL;
28329 }
28330
28331
28332 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj;
28334 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28335 PyObject *arg2 = (PyObject *) 0 ;
28336 bool result;
28337 PyObject * obj0 = 0 ;
28338 PyObject * obj1 = 0 ;
28339 char *kwnames[] = {
28340 (char *) "self",(char *) "data", NULL
28341 };
28342
28343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28345 if (SWIG_arg_fail(1)) SWIG_fail;
28346 arg2 = obj1;
28347 {
28348 PyThreadState* __tstate = wxPyBeginAllowThreads();
28349 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28350
28351 wxPyEndAllowThreads(__tstate);
28352 if (PyErr_Occurred()) SWIG_fail;
28353 }
28354 {
28355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28356 }
28357 return resultobj;
28358 fail:
28359 return NULL;
28360 }
28361
28362
28363 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28364 PyObject *resultobj;
28365 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28366 size_t result;
28367 PyObject * obj0 = 0 ;
28368 char *kwnames[] = {
28369 (char *) "self", NULL
28370 };
28371
28372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28374 if (SWIG_arg_fail(1)) SWIG_fail;
28375 {
28376 PyThreadState* __tstate = wxPyBeginAllowThreads();
28377 result = (size_t)(arg1)->GetSize();
28378
28379 wxPyEndAllowThreads(__tstate);
28380 if (PyErr_Occurred()) SWIG_fail;
28381 }
28382 {
28383 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28384 }
28385 return resultobj;
28386 fail:
28387 return NULL;
28388 }
28389
28390
28391 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28392 PyObject *resultobj;
28393 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28394 PyObject *result;
28395 PyObject * obj0 = 0 ;
28396 char *kwnames[] = {
28397 (char *) "self", NULL
28398 };
28399
28400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28402 if (SWIG_arg_fail(1)) SWIG_fail;
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28406
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 resultobj = result;
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28418 PyObject *obj;
28419 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28420 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28421 Py_INCREF(obj);
28422 return Py_BuildValue((char *)"");
28423 }
28424 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28425 PyObject *resultobj;
28426 wxURLDataObject *result;
28427 char *kwnames[] = {
28428 NULL
28429 };
28430
28431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28432 {
28433 PyThreadState* __tstate = wxPyBeginAllowThreads();
28434 result = (wxURLDataObject *)new wxURLDataObject();
28435
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj;
28448 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28449 wxString result;
28450 PyObject * obj0 = 0 ;
28451 char *kwnames[] = {
28452 (char *) "self", NULL
28453 };
28454
28455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28457 if (SWIG_arg_fail(1)) SWIG_fail;
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 result = (arg1)->GetURL();
28461
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 {
28466 #if wxUSE_UNICODE
28467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28468 #else
28469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28470 #endif
28471 }
28472 return resultobj;
28473 fail:
28474 return NULL;
28475 }
28476
28477
28478 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28479 PyObject *resultobj;
28480 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28481 wxString *arg2 = 0 ;
28482 bool temp2 = false ;
28483 PyObject * obj0 = 0 ;
28484 PyObject * obj1 = 0 ;
28485 char *kwnames[] = {
28486 (char *) "self",(char *) "url", NULL
28487 };
28488
28489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(1)) SWIG_fail;
28492 {
28493 arg2 = wxString_in_helper(obj1);
28494 if (arg2 == NULL) SWIG_fail;
28495 temp2 = true;
28496 }
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 (arg1)->SetURL((wxString const &)*arg2);
28500
28501 wxPyEndAllowThreads(__tstate);
28502 if (PyErr_Occurred()) SWIG_fail;
28503 }
28504 Py_INCREF(Py_None); resultobj = Py_None;
28505 {
28506 if (temp2)
28507 delete arg2;
28508 }
28509 return resultobj;
28510 fail:
28511 {
28512 if (temp2)
28513 delete arg2;
28514 }
28515 return NULL;
28516 }
28517
28518
28519 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28520 PyObject *obj;
28521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28522 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28523 Py_INCREF(obj);
28524 return Py_BuildValue((char *)"");
28525 }
28526 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28527 PyObject *resultobj;
28528 wxMetafileDataObject *result;
28529 char *kwnames[] = {
28530 NULL
28531 };
28532
28533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28534 {
28535 PyThreadState* __tstate = wxPyBeginAllowThreads();
28536 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28537
28538 wxPyEndAllowThreads(__tstate);
28539 if (PyErr_Occurred()) SWIG_fail;
28540 }
28541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28542 return resultobj;
28543 fail:
28544 return NULL;
28545 }
28546
28547
28548 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28549 PyObject *resultobj;
28550 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28551 wxMetafile *arg2 = 0 ;
28552 PyObject * obj0 = 0 ;
28553 PyObject * obj1 = 0 ;
28554 char *kwnames[] = {
28555 (char *) "self",(char *) "metafile", NULL
28556 };
28557
28558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28560 if (SWIG_arg_fail(1)) SWIG_fail;
28561 {
28562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28563 if (SWIG_arg_fail(2)) SWIG_fail;
28564 if (arg2 == NULL) {
28565 SWIG_null_ref("wxMetafile");
28566 }
28567 if (SWIG_arg_fail(2)) SWIG_fail;
28568 }
28569 {
28570 PyThreadState* __tstate = wxPyBeginAllowThreads();
28571 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28572
28573 wxPyEndAllowThreads(__tstate);
28574 if (PyErr_Occurred()) SWIG_fail;
28575 }
28576 Py_INCREF(Py_None); resultobj = Py_None;
28577 return resultobj;
28578 fail:
28579 return NULL;
28580 }
28581
28582
28583 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28584 PyObject *resultobj;
28585 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28586 wxMetafile result;
28587 PyObject * obj0 = 0 ;
28588 char *kwnames[] = {
28589 (char *) "self", NULL
28590 };
28591
28592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28594 if (SWIG_arg_fail(1)) SWIG_fail;
28595 {
28596 PyThreadState* __tstate = wxPyBeginAllowThreads();
28597 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28598
28599 wxPyEndAllowThreads(__tstate);
28600 if (PyErr_Occurred()) SWIG_fail;
28601 }
28602 {
28603 wxMetafile * resultptr;
28604 resultptr = new wxMetafile((wxMetafile &)(result));
28605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28606 }
28607 return resultobj;
28608 fail:
28609 return NULL;
28610 }
28611
28612
28613 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28614 PyObject *obj;
28615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28616 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28617 Py_INCREF(obj);
28618 return Py_BuildValue((char *)"");
28619 }
28620 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28621 PyObject *resultobj;
28622 wxDragResult arg1 ;
28623 bool result;
28624 PyObject * obj0 = 0 ;
28625 char *kwnames[] = {
28626 (char *) "res", NULL
28627 };
28628
28629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28630 {
28631 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28632 if (SWIG_arg_fail(1)) SWIG_fail;
28633 }
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28637
28638 wxPyEndAllowThreads(__tstate);
28639 if (PyErr_Occurred()) SWIG_fail;
28640 }
28641 {
28642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28643 }
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28651 PyObject *resultobj;
28652 wxWindow *arg1 = (wxWindow *) 0 ;
28653 wxCursor const &arg2_defvalue = wxNullCursor ;
28654 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28655 wxCursor const &arg3_defvalue = wxNullCursor ;
28656 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28657 wxCursor const &arg4_defvalue = wxNullCursor ;
28658 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28659 wxPyDropSource *result;
28660 PyObject * obj0 = 0 ;
28661 PyObject * obj1 = 0 ;
28662 PyObject * obj2 = 0 ;
28663 PyObject * obj3 = 0 ;
28664 char *kwnames[] = {
28665 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28666 };
28667
28668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28670 if (SWIG_arg_fail(1)) SWIG_fail;
28671 if (obj1) {
28672 {
28673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28674 if (SWIG_arg_fail(2)) SWIG_fail;
28675 if (arg2 == NULL) {
28676 SWIG_null_ref("wxCursor");
28677 }
28678 if (SWIG_arg_fail(2)) SWIG_fail;
28679 }
28680 }
28681 if (obj2) {
28682 {
28683 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28684 if (SWIG_arg_fail(3)) SWIG_fail;
28685 if (arg3 == NULL) {
28686 SWIG_null_ref("wxCursor");
28687 }
28688 if (SWIG_arg_fail(3)) SWIG_fail;
28689 }
28690 }
28691 if (obj3) {
28692 {
28693 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28694 if (SWIG_arg_fail(4)) SWIG_fail;
28695 if (arg4 == NULL) {
28696 SWIG_null_ref("wxCursor");
28697 }
28698 if (SWIG_arg_fail(4)) SWIG_fail;
28699 }
28700 }
28701 {
28702 PyThreadState* __tstate = wxPyBeginAllowThreads();
28703 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28704
28705 wxPyEndAllowThreads(__tstate);
28706 if (PyErr_Occurred()) SWIG_fail;
28707 }
28708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28709 return resultobj;
28710 fail:
28711 return NULL;
28712 }
28713
28714
28715 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28716 PyObject *resultobj;
28717 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28718 PyObject *arg2 = (PyObject *) 0 ;
28719 PyObject *arg3 = (PyObject *) 0 ;
28720 int arg4 ;
28721 PyObject * obj0 = 0 ;
28722 PyObject * obj1 = 0 ;
28723 PyObject * obj2 = 0 ;
28724 PyObject * obj3 = 0 ;
28725 char *kwnames[] = {
28726 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28727 };
28728
28729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28731 if (SWIG_arg_fail(1)) SWIG_fail;
28732 arg2 = obj1;
28733 arg3 = obj2;
28734 {
28735 arg4 = (int)(SWIG_As_int(obj3));
28736 if (SWIG_arg_fail(4)) SWIG_fail;
28737 }
28738 {
28739 PyThreadState* __tstate = wxPyBeginAllowThreads();
28740 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28741
28742 wxPyEndAllowThreads(__tstate);
28743 if (PyErr_Occurred()) SWIG_fail;
28744 }
28745 Py_INCREF(Py_None); resultobj = Py_None;
28746 return resultobj;
28747 fail:
28748 return NULL;
28749 }
28750
28751
28752 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28753 PyObject *resultobj;
28754 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28755 PyObject * obj0 = 0 ;
28756 char *kwnames[] = {
28757 (char *) "self", NULL
28758 };
28759
28760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28762 if (SWIG_arg_fail(1)) SWIG_fail;
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 delete arg1;
28766
28767 wxPyEndAllowThreads(__tstate);
28768 if (PyErr_Occurred()) SWIG_fail;
28769 }
28770 Py_INCREF(Py_None); resultobj = Py_None;
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28778 PyObject *resultobj;
28779 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28780 wxDataObject *arg2 = 0 ;
28781 PyObject * obj0 = 0 ;
28782 PyObject * obj1 = 0 ;
28783 char *kwnames[] = {
28784 (char *) "self",(char *) "data", NULL
28785 };
28786
28787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28789 if (SWIG_arg_fail(1)) SWIG_fail;
28790 {
28791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28792 if (SWIG_arg_fail(2)) SWIG_fail;
28793 if (arg2 == NULL) {
28794 SWIG_null_ref("wxDataObject");
28795 }
28796 if (SWIG_arg_fail(2)) SWIG_fail;
28797 }
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 (arg1)->SetData(*arg2);
28801
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 Py_INCREF(Py_None); resultobj = Py_None;
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28813 PyObject *resultobj;
28814 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28815 wxDataObject *result;
28816 PyObject * obj0 = 0 ;
28817 char *kwnames[] = {
28818 (char *) "self", NULL
28819 };
28820
28821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28823 if (SWIG_arg_fail(1)) SWIG_fail;
28824 {
28825 PyThreadState* __tstate = wxPyBeginAllowThreads();
28826 result = (wxDataObject *)(arg1)->GetDataObject();
28827
28828 wxPyEndAllowThreads(__tstate);
28829 if (PyErr_Occurred()) SWIG_fail;
28830 }
28831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28832 return resultobj;
28833 fail:
28834 return NULL;
28835 }
28836
28837
28838 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28839 PyObject *resultobj;
28840 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28841 wxDragResult arg2 ;
28842 wxCursor *arg3 = 0 ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 PyObject * obj2 = 0 ;
28846 char *kwnames[] = {
28847 (char *) "self",(char *) "res",(char *) "cursor", NULL
28848 };
28849
28850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28852 if (SWIG_arg_fail(1)) SWIG_fail;
28853 {
28854 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28855 if (SWIG_arg_fail(2)) SWIG_fail;
28856 }
28857 {
28858 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28859 if (SWIG_arg_fail(3)) SWIG_fail;
28860 if (arg3 == NULL) {
28861 SWIG_null_ref("wxCursor");
28862 }
28863 if (SWIG_arg_fail(3)) SWIG_fail;
28864 }
28865 {
28866 PyThreadState* __tstate = wxPyBeginAllowThreads();
28867 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28868
28869 wxPyEndAllowThreads(__tstate);
28870 if (PyErr_Occurred()) SWIG_fail;
28871 }
28872 Py_INCREF(Py_None); resultobj = Py_None;
28873 return resultobj;
28874 fail:
28875 return NULL;
28876 }
28877
28878
28879 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28880 PyObject *resultobj;
28881 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28882 int arg2 = (int) wxDrag_CopyOnly ;
28883 wxDragResult result;
28884 PyObject * obj0 = 0 ;
28885 PyObject * obj1 = 0 ;
28886 char *kwnames[] = {
28887 (char *) "self",(char *) "flags", NULL
28888 };
28889
28890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28892 if (SWIG_arg_fail(1)) SWIG_fail;
28893 if (obj1) {
28894 {
28895 arg2 = (int)(SWIG_As_int(obj1));
28896 if (SWIG_arg_fail(2)) SWIG_fail;
28897 }
28898 }
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28902
28903 wxPyEndAllowThreads(__tstate);
28904 if (PyErr_Occurred()) SWIG_fail;
28905 }
28906 resultobj = SWIG_From_int((result));
28907 return resultobj;
28908 fail:
28909 return NULL;
28910 }
28911
28912
28913 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28914 PyObject *resultobj;
28915 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28916 wxDragResult arg2 ;
28917 bool result;
28918 PyObject * obj0 = 0 ;
28919 PyObject * obj1 = 0 ;
28920 char *kwnames[] = {
28921 (char *) "self",(char *) "effect", NULL
28922 };
28923
28924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28926 if (SWIG_arg_fail(1)) SWIG_fail;
28927 {
28928 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28929 if (SWIG_arg_fail(2)) SWIG_fail;
28930 }
28931 {
28932 PyThreadState* __tstate = wxPyBeginAllowThreads();
28933 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28934
28935 wxPyEndAllowThreads(__tstate);
28936 if (PyErr_Occurred()) SWIG_fail;
28937 }
28938 {
28939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28940 }
28941 return resultobj;
28942 fail:
28943 return NULL;
28944 }
28945
28946
28947 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28948 PyObject *obj;
28949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28950 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28951 Py_INCREF(obj);
28952 return Py_BuildValue((char *)"");
28953 }
28954 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28955 PyObject *resultobj;
28956 wxDataObject *arg1 = (wxDataObject *) NULL ;
28957 wxPyDropTarget *result;
28958 PyObject * obj0 = 0 ;
28959 char *kwnames[] = {
28960 (char *) "dataObject", NULL
28961 };
28962
28963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28964 if (obj0) {
28965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28966 if (SWIG_arg_fail(1)) SWIG_fail;
28967 }
28968 {
28969 PyThreadState* __tstate = wxPyBeginAllowThreads();
28970 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28971
28972 wxPyEndAllowThreads(__tstate);
28973 if (PyErr_Occurred()) SWIG_fail;
28974 }
28975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28976 return resultobj;
28977 fail:
28978 return NULL;
28979 }
28980
28981
28982 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28983 PyObject *resultobj;
28984 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28985 PyObject *arg2 = (PyObject *) 0 ;
28986 PyObject *arg3 = (PyObject *) 0 ;
28987 PyObject * obj0 = 0 ;
28988 PyObject * obj1 = 0 ;
28989 PyObject * obj2 = 0 ;
28990 char *kwnames[] = {
28991 (char *) "self",(char *) "self",(char *) "_class", NULL
28992 };
28993
28994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28996 if (SWIG_arg_fail(1)) SWIG_fail;
28997 arg2 = obj1;
28998 arg3 = obj2;
28999 {
29000 PyThreadState* __tstate = wxPyBeginAllowThreads();
29001 (arg1)->_setCallbackInfo(arg2,arg3);
29002
29003 wxPyEndAllowThreads(__tstate);
29004 if (PyErr_Occurred()) SWIG_fail;
29005 }
29006 Py_INCREF(Py_None); resultobj = Py_None;
29007 return resultobj;
29008 fail:
29009 return NULL;
29010 }
29011
29012
29013 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29014 PyObject *resultobj;
29015 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29016 PyObject * obj0 = 0 ;
29017 char *kwnames[] = {
29018 (char *) "self", NULL
29019 };
29020
29021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
29022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29023 if (SWIG_arg_fail(1)) SWIG_fail;
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 delete arg1;
29027
29028 wxPyEndAllowThreads(__tstate);
29029 if (PyErr_Occurred()) SWIG_fail;
29030 }
29031 Py_INCREF(Py_None); resultobj = Py_None;
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29039 PyObject *resultobj;
29040 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29041 wxDataObject *result;
29042 PyObject * obj0 = 0 ;
29043 char *kwnames[] = {
29044 (char *) "self", NULL
29045 };
29046
29047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29049 if (SWIG_arg_fail(1)) SWIG_fail;
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = (wxDataObject *)(arg1)->GetDataObject();
29053
29054 wxPyEndAllowThreads(__tstate);
29055 if (PyErr_Occurred()) SWIG_fail;
29056 }
29057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29058 return resultobj;
29059 fail:
29060 return NULL;
29061 }
29062
29063
29064 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj;
29066 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29067 wxDataObject *arg2 = (wxDataObject *) 0 ;
29068 PyObject * obj0 = 0 ;
29069 PyObject * obj1 = 0 ;
29070 char *kwnames[] = {
29071 (char *) "self",(char *) "dataObject", NULL
29072 };
29073
29074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29076 if (SWIG_arg_fail(1)) SWIG_fail;
29077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29078 if (SWIG_arg_fail(2)) SWIG_fail;
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 (arg1)->SetDataObject(arg2);
29082
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 Py_INCREF(Py_None); resultobj = Py_None;
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29094 PyObject *resultobj;
29095 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29096 int arg2 ;
29097 int arg3 ;
29098 wxDragResult arg4 ;
29099 wxDragResult result;
29100 PyObject * obj0 = 0 ;
29101 PyObject * obj1 = 0 ;
29102 PyObject * obj2 = 0 ;
29103 PyObject * obj3 = 0 ;
29104 char *kwnames[] = {
29105 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29106 };
29107
29108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29110 if (SWIG_arg_fail(1)) SWIG_fail;
29111 {
29112 arg2 = (int)(SWIG_As_int(obj1));
29113 if (SWIG_arg_fail(2)) SWIG_fail;
29114 }
29115 {
29116 arg3 = (int)(SWIG_As_int(obj2));
29117 if (SWIG_arg_fail(3)) SWIG_fail;
29118 }
29119 {
29120 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29121 if (SWIG_arg_fail(4)) SWIG_fail;
29122 }
29123 {
29124 PyThreadState* __tstate = wxPyBeginAllowThreads();
29125 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29126
29127 wxPyEndAllowThreads(__tstate);
29128 if (PyErr_Occurred()) SWIG_fail;
29129 }
29130 resultobj = SWIG_From_int((result));
29131 return resultobj;
29132 fail:
29133 return NULL;
29134 }
29135
29136
29137 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj;
29139 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29140 int arg2 ;
29141 int arg3 ;
29142 wxDragResult arg4 ;
29143 wxDragResult result;
29144 PyObject * obj0 = 0 ;
29145 PyObject * obj1 = 0 ;
29146 PyObject * obj2 = 0 ;
29147 PyObject * obj3 = 0 ;
29148 char *kwnames[] = {
29149 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29150 };
29151
29152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29154 if (SWIG_arg_fail(1)) SWIG_fail;
29155 {
29156 arg2 = (int)(SWIG_As_int(obj1));
29157 if (SWIG_arg_fail(2)) SWIG_fail;
29158 }
29159 {
29160 arg3 = (int)(SWIG_As_int(obj2));
29161 if (SWIG_arg_fail(3)) SWIG_fail;
29162 }
29163 {
29164 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29165 if (SWIG_arg_fail(4)) SWIG_fail;
29166 }
29167 {
29168 PyThreadState* __tstate = wxPyBeginAllowThreads();
29169 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29170
29171 wxPyEndAllowThreads(__tstate);
29172 if (PyErr_Occurred()) SWIG_fail;
29173 }
29174 resultobj = SWIG_From_int((result));
29175 return resultobj;
29176 fail:
29177 return NULL;
29178 }
29179
29180
29181 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29182 PyObject *resultobj;
29183 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29184 PyObject * obj0 = 0 ;
29185 char *kwnames[] = {
29186 (char *) "self", NULL
29187 };
29188
29189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29191 if (SWIG_arg_fail(1)) SWIG_fail;
29192 {
29193 PyThreadState* __tstate = wxPyBeginAllowThreads();
29194 (arg1)->base_OnLeave();
29195
29196 wxPyEndAllowThreads(__tstate);
29197 if (PyErr_Occurred()) SWIG_fail;
29198 }
29199 Py_INCREF(Py_None); resultobj = Py_None;
29200 return resultobj;
29201 fail:
29202 return NULL;
29203 }
29204
29205
29206 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29207 PyObject *resultobj;
29208 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29209 int arg2 ;
29210 int arg3 ;
29211 bool result;
29212 PyObject * obj0 = 0 ;
29213 PyObject * obj1 = 0 ;
29214 PyObject * obj2 = 0 ;
29215 char *kwnames[] = {
29216 (char *) "self",(char *) "x",(char *) "y", NULL
29217 };
29218
29219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29221 if (SWIG_arg_fail(1)) SWIG_fail;
29222 {
29223 arg2 = (int)(SWIG_As_int(obj1));
29224 if (SWIG_arg_fail(2)) SWIG_fail;
29225 }
29226 {
29227 arg3 = (int)(SWIG_As_int(obj2));
29228 if (SWIG_arg_fail(3)) SWIG_fail;
29229 }
29230 {
29231 PyThreadState* __tstate = wxPyBeginAllowThreads();
29232 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29233
29234 wxPyEndAllowThreads(__tstate);
29235 if (PyErr_Occurred()) SWIG_fail;
29236 }
29237 {
29238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29239 }
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29249 bool result;
29250 PyObject * obj0 = 0 ;
29251 char *kwnames[] = {
29252 (char *) "self", NULL
29253 };
29254
29255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29257 if (SWIG_arg_fail(1)) SWIG_fail;
29258 {
29259 PyThreadState* __tstate = wxPyBeginAllowThreads();
29260 result = (bool)(arg1)->GetData();
29261
29262 wxPyEndAllowThreads(__tstate);
29263 if (PyErr_Occurred()) SWIG_fail;
29264 }
29265 {
29266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29267 }
29268 return resultobj;
29269 fail:
29270 return NULL;
29271 }
29272
29273
29274 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29275 PyObject *resultobj;
29276 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29277 wxDragResult arg2 ;
29278 PyObject * obj0 = 0 ;
29279 PyObject * obj1 = 0 ;
29280 char *kwnames[] = {
29281 (char *) "self",(char *) "action", NULL
29282 };
29283
29284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29286 if (SWIG_arg_fail(1)) SWIG_fail;
29287 {
29288 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29289 if (SWIG_arg_fail(2)) SWIG_fail;
29290 }
29291 {
29292 PyThreadState* __tstate = wxPyBeginAllowThreads();
29293 (arg1)->SetDefaultAction((wxDragResult )arg2);
29294
29295 wxPyEndAllowThreads(__tstate);
29296 if (PyErr_Occurred()) SWIG_fail;
29297 }
29298 Py_INCREF(Py_None); resultobj = Py_None;
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29306 PyObject *resultobj;
29307 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29308 wxDragResult result;
29309 PyObject * obj0 = 0 ;
29310 char *kwnames[] = {
29311 (char *) "self", NULL
29312 };
29313
29314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29316 if (SWIG_arg_fail(1)) SWIG_fail;
29317 {
29318 PyThreadState* __tstate = wxPyBeginAllowThreads();
29319 result = (wxDragResult)(arg1)->GetDefaultAction();
29320
29321 wxPyEndAllowThreads(__tstate);
29322 if (PyErr_Occurred()) SWIG_fail;
29323 }
29324 resultobj = SWIG_From_int((result));
29325 return resultobj;
29326 fail:
29327 return NULL;
29328 }
29329
29330
29331 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29332 PyObject *obj;
29333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29334 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29335 Py_INCREF(obj);
29336 return Py_BuildValue((char *)"");
29337 }
29338 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29339 PyObject *resultobj;
29340 wxPyTextDropTarget *result;
29341 char *kwnames[] = {
29342 NULL
29343 };
29344
29345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29349
29350 wxPyEndAllowThreads(__tstate);
29351 if (PyErr_Occurred()) SWIG_fail;
29352 }
29353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29354 return resultobj;
29355 fail:
29356 return NULL;
29357 }
29358
29359
29360 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29361 PyObject *resultobj;
29362 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29363 PyObject *arg2 = (PyObject *) 0 ;
29364 PyObject *arg3 = (PyObject *) 0 ;
29365 PyObject * obj0 = 0 ;
29366 PyObject * obj1 = 0 ;
29367 PyObject * obj2 = 0 ;
29368 char *kwnames[] = {
29369 (char *) "self",(char *) "self",(char *) "_class", NULL
29370 };
29371
29372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29374 if (SWIG_arg_fail(1)) SWIG_fail;
29375 arg2 = obj1;
29376 arg3 = obj2;
29377 {
29378 PyThreadState* __tstate = wxPyBeginAllowThreads();
29379 (arg1)->_setCallbackInfo(arg2,arg3);
29380
29381 wxPyEndAllowThreads(__tstate);
29382 if (PyErr_Occurred()) SWIG_fail;
29383 }
29384 Py_INCREF(Py_None); resultobj = Py_None;
29385 return resultobj;
29386 fail:
29387 return NULL;
29388 }
29389
29390
29391 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29392 PyObject *resultobj;
29393 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29394 int arg2 ;
29395 int arg3 ;
29396 wxDragResult arg4 ;
29397 wxDragResult result;
29398 PyObject * obj0 = 0 ;
29399 PyObject * obj1 = 0 ;
29400 PyObject * obj2 = 0 ;
29401 PyObject * obj3 = 0 ;
29402 char *kwnames[] = {
29403 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29404 };
29405
29406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29408 if (SWIG_arg_fail(1)) SWIG_fail;
29409 {
29410 arg2 = (int)(SWIG_As_int(obj1));
29411 if (SWIG_arg_fail(2)) SWIG_fail;
29412 }
29413 {
29414 arg3 = (int)(SWIG_As_int(obj2));
29415 if (SWIG_arg_fail(3)) SWIG_fail;
29416 }
29417 {
29418 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29419 if (SWIG_arg_fail(4)) SWIG_fail;
29420 }
29421 {
29422 PyThreadState* __tstate = wxPyBeginAllowThreads();
29423 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29424
29425 wxPyEndAllowThreads(__tstate);
29426 if (PyErr_Occurred()) SWIG_fail;
29427 }
29428 resultobj = SWIG_From_int((result));
29429 return resultobj;
29430 fail:
29431 return NULL;
29432 }
29433
29434
29435 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29436 PyObject *resultobj;
29437 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29438 int arg2 ;
29439 int arg3 ;
29440 wxDragResult arg4 ;
29441 wxDragResult result;
29442 PyObject * obj0 = 0 ;
29443 PyObject * obj1 = 0 ;
29444 PyObject * obj2 = 0 ;
29445 PyObject * obj3 = 0 ;
29446 char *kwnames[] = {
29447 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29448 };
29449
29450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29452 if (SWIG_arg_fail(1)) SWIG_fail;
29453 {
29454 arg2 = (int)(SWIG_As_int(obj1));
29455 if (SWIG_arg_fail(2)) SWIG_fail;
29456 }
29457 {
29458 arg3 = (int)(SWIG_As_int(obj2));
29459 if (SWIG_arg_fail(3)) SWIG_fail;
29460 }
29461 {
29462 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29463 if (SWIG_arg_fail(4)) SWIG_fail;
29464 }
29465 {
29466 PyThreadState* __tstate = wxPyBeginAllowThreads();
29467 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29468
29469 wxPyEndAllowThreads(__tstate);
29470 if (PyErr_Occurred()) SWIG_fail;
29471 }
29472 resultobj = SWIG_From_int((result));
29473 return resultobj;
29474 fail:
29475 return NULL;
29476 }
29477
29478
29479 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29480 PyObject *resultobj;
29481 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29482 PyObject * obj0 = 0 ;
29483 char *kwnames[] = {
29484 (char *) "self", NULL
29485 };
29486
29487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29489 if (SWIG_arg_fail(1)) SWIG_fail;
29490 {
29491 PyThreadState* __tstate = wxPyBeginAllowThreads();
29492 (arg1)->base_OnLeave();
29493
29494 wxPyEndAllowThreads(__tstate);
29495 if (PyErr_Occurred()) SWIG_fail;
29496 }
29497 Py_INCREF(Py_None); resultobj = Py_None;
29498 return resultobj;
29499 fail:
29500 return NULL;
29501 }
29502
29503
29504 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29505 PyObject *resultobj;
29506 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29507 int arg2 ;
29508 int arg3 ;
29509 bool result;
29510 PyObject * obj0 = 0 ;
29511 PyObject * obj1 = 0 ;
29512 PyObject * obj2 = 0 ;
29513 char *kwnames[] = {
29514 (char *) "self",(char *) "x",(char *) "y", NULL
29515 };
29516
29517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29519 if (SWIG_arg_fail(1)) SWIG_fail;
29520 {
29521 arg2 = (int)(SWIG_As_int(obj1));
29522 if (SWIG_arg_fail(2)) SWIG_fail;
29523 }
29524 {
29525 arg3 = (int)(SWIG_As_int(obj2));
29526 if (SWIG_arg_fail(3)) SWIG_fail;
29527 }
29528 {
29529 PyThreadState* __tstate = wxPyBeginAllowThreads();
29530 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29531
29532 wxPyEndAllowThreads(__tstate);
29533 if (PyErr_Occurred()) SWIG_fail;
29534 }
29535 {
29536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29537 }
29538 return resultobj;
29539 fail:
29540 return NULL;
29541 }
29542
29543
29544 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29545 PyObject *resultobj;
29546 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29547 int arg2 ;
29548 int arg3 ;
29549 wxDragResult arg4 ;
29550 wxDragResult result;
29551 PyObject * obj0 = 0 ;
29552 PyObject * obj1 = 0 ;
29553 PyObject * obj2 = 0 ;
29554 PyObject * obj3 = 0 ;
29555 char *kwnames[] = {
29556 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29557 };
29558
29559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29561 if (SWIG_arg_fail(1)) SWIG_fail;
29562 {
29563 arg2 = (int)(SWIG_As_int(obj1));
29564 if (SWIG_arg_fail(2)) SWIG_fail;
29565 }
29566 {
29567 arg3 = (int)(SWIG_As_int(obj2));
29568 if (SWIG_arg_fail(3)) SWIG_fail;
29569 }
29570 {
29571 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29572 if (SWIG_arg_fail(4)) SWIG_fail;
29573 }
29574 {
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29577
29578 wxPyEndAllowThreads(__tstate);
29579 if (PyErr_Occurred()) SWIG_fail;
29580 }
29581 resultobj = SWIG_From_int((result));
29582 return resultobj;
29583 fail:
29584 return NULL;
29585 }
29586
29587
29588 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29589 PyObject *obj;
29590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29591 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29592 Py_INCREF(obj);
29593 return Py_BuildValue((char *)"");
29594 }
29595 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29596 PyObject *resultobj;
29597 wxPyFileDropTarget *result;
29598 char *kwnames[] = {
29599 NULL
29600 };
29601
29602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29603 {
29604 PyThreadState* __tstate = wxPyBeginAllowThreads();
29605 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29606
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29611 return resultobj;
29612 fail:
29613 return NULL;
29614 }
29615
29616
29617 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29618 PyObject *resultobj;
29619 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29620 PyObject *arg2 = (PyObject *) 0 ;
29621 PyObject *arg3 = (PyObject *) 0 ;
29622 PyObject * obj0 = 0 ;
29623 PyObject * obj1 = 0 ;
29624 PyObject * obj2 = 0 ;
29625 char *kwnames[] = {
29626 (char *) "self",(char *) "self",(char *) "_class", NULL
29627 };
29628
29629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29631 if (SWIG_arg_fail(1)) SWIG_fail;
29632 arg2 = obj1;
29633 arg3 = obj2;
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 (arg1)->_setCallbackInfo(arg2,arg3);
29637
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 Py_INCREF(Py_None); resultobj = Py_None;
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29649 PyObject *resultobj;
29650 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29651 int arg2 ;
29652 int arg3 ;
29653 wxDragResult arg4 ;
29654 wxDragResult result;
29655 PyObject * obj0 = 0 ;
29656 PyObject * obj1 = 0 ;
29657 PyObject * obj2 = 0 ;
29658 PyObject * obj3 = 0 ;
29659 char *kwnames[] = {
29660 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29661 };
29662
29663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29665 if (SWIG_arg_fail(1)) SWIG_fail;
29666 {
29667 arg2 = (int)(SWIG_As_int(obj1));
29668 if (SWIG_arg_fail(2)) SWIG_fail;
29669 }
29670 {
29671 arg3 = (int)(SWIG_As_int(obj2));
29672 if (SWIG_arg_fail(3)) SWIG_fail;
29673 }
29674 {
29675 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29676 if (SWIG_arg_fail(4)) SWIG_fail;
29677 }
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 resultobj = SWIG_From_int((result));
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29693 PyObject *resultobj;
29694 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29695 int arg2 ;
29696 int arg3 ;
29697 wxDragResult arg4 ;
29698 wxDragResult result;
29699 PyObject * obj0 = 0 ;
29700 PyObject * obj1 = 0 ;
29701 PyObject * obj2 = 0 ;
29702 PyObject * obj3 = 0 ;
29703 char *kwnames[] = {
29704 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29705 };
29706
29707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29709 if (SWIG_arg_fail(1)) SWIG_fail;
29710 {
29711 arg2 = (int)(SWIG_As_int(obj1));
29712 if (SWIG_arg_fail(2)) SWIG_fail;
29713 }
29714 {
29715 arg3 = (int)(SWIG_As_int(obj2));
29716 if (SWIG_arg_fail(3)) SWIG_fail;
29717 }
29718 {
29719 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29720 if (SWIG_arg_fail(4)) SWIG_fail;
29721 }
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29725
29726 wxPyEndAllowThreads(__tstate);
29727 if (PyErr_Occurred()) SWIG_fail;
29728 }
29729 resultobj = SWIG_From_int((result));
29730 return resultobj;
29731 fail:
29732 return NULL;
29733 }
29734
29735
29736 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29737 PyObject *resultobj;
29738 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29739 PyObject * obj0 = 0 ;
29740 char *kwnames[] = {
29741 (char *) "self", NULL
29742 };
29743
29744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29746 if (SWIG_arg_fail(1)) SWIG_fail;
29747 {
29748 PyThreadState* __tstate = wxPyBeginAllowThreads();
29749 (arg1)->base_OnLeave();
29750
29751 wxPyEndAllowThreads(__tstate);
29752 if (PyErr_Occurred()) SWIG_fail;
29753 }
29754 Py_INCREF(Py_None); resultobj = Py_None;
29755 return resultobj;
29756 fail:
29757 return NULL;
29758 }
29759
29760
29761 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29762 PyObject *resultobj;
29763 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29764 int arg2 ;
29765 int arg3 ;
29766 bool result;
29767 PyObject * obj0 = 0 ;
29768 PyObject * obj1 = 0 ;
29769 PyObject * obj2 = 0 ;
29770 char *kwnames[] = {
29771 (char *) "self",(char *) "x",(char *) "y", NULL
29772 };
29773
29774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29776 if (SWIG_arg_fail(1)) SWIG_fail;
29777 {
29778 arg2 = (int)(SWIG_As_int(obj1));
29779 if (SWIG_arg_fail(2)) SWIG_fail;
29780 }
29781 {
29782 arg3 = (int)(SWIG_As_int(obj2));
29783 if (SWIG_arg_fail(3)) SWIG_fail;
29784 }
29785 {
29786 PyThreadState* __tstate = wxPyBeginAllowThreads();
29787 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29788
29789 wxPyEndAllowThreads(__tstate);
29790 if (PyErr_Occurred()) SWIG_fail;
29791 }
29792 {
29793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29794 }
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29802 PyObject *resultobj;
29803 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29804 int arg2 ;
29805 int arg3 ;
29806 wxDragResult arg4 ;
29807 wxDragResult result;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 PyObject * obj2 = 0 ;
29811 PyObject * obj3 = 0 ;
29812 char *kwnames[] = {
29813 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29814 };
29815
29816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29818 if (SWIG_arg_fail(1)) SWIG_fail;
29819 {
29820 arg2 = (int)(SWIG_As_int(obj1));
29821 if (SWIG_arg_fail(2)) SWIG_fail;
29822 }
29823 {
29824 arg3 = (int)(SWIG_As_int(obj2));
29825 if (SWIG_arg_fail(3)) SWIG_fail;
29826 }
29827 {
29828 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29829 if (SWIG_arg_fail(4)) SWIG_fail;
29830 }
29831 {
29832 PyThreadState* __tstate = wxPyBeginAllowThreads();
29833 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29834
29835 wxPyEndAllowThreads(__tstate);
29836 if (PyErr_Occurred()) SWIG_fail;
29837 }
29838 resultobj = SWIG_From_int((result));
29839 return resultobj;
29840 fail:
29841 return NULL;
29842 }
29843
29844
29845 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29846 PyObject *obj;
29847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29848 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29849 Py_INCREF(obj);
29850 return Py_BuildValue((char *)"");
29851 }
29852 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29853 PyObject *resultobj;
29854 wxClipboard *result;
29855 char *kwnames[] = {
29856 NULL
29857 };
29858
29859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29860 {
29861 PyThreadState* __tstate = wxPyBeginAllowThreads();
29862 result = (wxClipboard *)new wxClipboard();
29863
29864 wxPyEndAllowThreads(__tstate);
29865 if (PyErr_Occurred()) SWIG_fail;
29866 }
29867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29868 return resultobj;
29869 fail:
29870 return NULL;
29871 }
29872
29873
29874 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29875 PyObject *resultobj;
29876 wxClipboard *arg1 = (wxClipboard *) 0 ;
29877 PyObject * obj0 = 0 ;
29878 char *kwnames[] = {
29879 (char *) "self", NULL
29880 };
29881
29882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29884 if (SWIG_arg_fail(1)) SWIG_fail;
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 delete arg1;
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_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29900 PyObject *resultobj;
29901 wxClipboard *arg1 = (wxClipboard *) 0 ;
29902 bool result;
29903 PyObject * obj0 = 0 ;
29904 char *kwnames[] = {
29905 (char *) "self", NULL
29906 };
29907
29908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29910 if (SWIG_arg_fail(1)) SWIG_fail;
29911 {
29912 PyThreadState* __tstate = wxPyBeginAllowThreads();
29913 result = (bool)(arg1)->Open();
29914
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 {
29919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29920 }
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29928 PyObject *resultobj;
29929 wxClipboard *arg1 = (wxClipboard *) 0 ;
29930 PyObject * obj0 = 0 ;
29931 char *kwnames[] = {
29932 (char *) "self", NULL
29933 };
29934
29935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29937 if (SWIG_arg_fail(1)) SWIG_fail;
29938 {
29939 PyThreadState* __tstate = wxPyBeginAllowThreads();
29940 (arg1)->Close();
29941
29942 wxPyEndAllowThreads(__tstate);
29943 if (PyErr_Occurred()) SWIG_fail;
29944 }
29945 Py_INCREF(Py_None); resultobj = Py_None;
29946 return resultobj;
29947 fail:
29948 return NULL;
29949 }
29950
29951
29952 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29953 PyObject *resultobj;
29954 wxClipboard *arg1 = (wxClipboard *) 0 ;
29955 bool result;
29956 PyObject * obj0 = 0 ;
29957 char *kwnames[] = {
29958 (char *) "self", NULL
29959 };
29960
29961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29963 if (SWIG_arg_fail(1)) SWIG_fail;
29964 {
29965 PyThreadState* __tstate = wxPyBeginAllowThreads();
29966 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29967
29968 wxPyEndAllowThreads(__tstate);
29969 if (PyErr_Occurred()) SWIG_fail;
29970 }
29971 {
29972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29973 }
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29981 PyObject *resultobj;
29982 wxClipboard *arg1 = (wxClipboard *) 0 ;
29983 wxDataObject *arg2 = (wxDataObject *) 0 ;
29984 bool result;
29985 PyObject * obj0 = 0 ;
29986 PyObject * obj1 = 0 ;
29987 char *kwnames[] = {
29988 (char *) "self",(char *) "data", NULL
29989 };
29990
29991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29993 if (SWIG_arg_fail(1)) SWIG_fail;
29994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29995 if (SWIG_arg_fail(2)) SWIG_fail;
29996 {
29997 PyThreadState* __tstate = wxPyBeginAllowThreads();
29998 result = (bool)(arg1)->AddData(arg2);
29999
30000 wxPyEndAllowThreads(__tstate);
30001 if (PyErr_Occurred()) SWIG_fail;
30002 }
30003 {
30004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30005 }
30006 return resultobj;
30007 fail:
30008 return NULL;
30009 }
30010
30011
30012 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
30013 PyObject *resultobj;
30014 wxClipboard *arg1 = (wxClipboard *) 0 ;
30015 wxDataObject *arg2 = (wxDataObject *) 0 ;
30016 bool result;
30017 PyObject * obj0 = 0 ;
30018 PyObject * obj1 = 0 ;
30019 char *kwnames[] = {
30020 (char *) "self",(char *) "data", NULL
30021 };
30022
30023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
30024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30025 if (SWIG_arg_fail(1)) SWIG_fail;
30026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30027 if (SWIG_arg_fail(2)) SWIG_fail;
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 result = (bool)(arg1)->SetData(arg2);
30031
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 {
30036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30037 }
30038 return resultobj;
30039 fail:
30040 return NULL;
30041 }
30042
30043
30044 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30045 PyObject *resultobj;
30046 wxClipboard *arg1 = (wxClipboard *) 0 ;
30047 wxDataFormat *arg2 = 0 ;
30048 bool result;
30049 PyObject * obj0 = 0 ;
30050 PyObject * obj1 = 0 ;
30051 char *kwnames[] = {
30052 (char *) "self",(char *) "format", NULL
30053 };
30054
30055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30057 if (SWIG_arg_fail(1)) SWIG_fail;
30058 {
30059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30060 if (SWIG_arg_fail(2)) SWIG_fail;
30061 if (arg2 == NULL) {
30062 SWIG_null_ref("wxDataFormat");
30063 }
30064 if (SWIG_arg_fail(2)) SWIG_fail;
30065 }
30066 {
30067 PyThreadState* __tstate = wxPyBeginAllowThreads();
30068 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30069
30070 wxPyEndAllowThreads(__tstate);
30071 if (PyErr_Occurred()) SWIG_fail;
30072 }
30073 {
30074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30075 }
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30083 PyObject *resultobj;
30084 wxClipboard *arg1 = (wxClipboard *) 0 ;
30085 wxDataObject *arg2 = 0 ;
30086 bool result;
30087 PyObject * obj0 = 0 ;
30088 PyObject * obj1 = 0 ;
30089 char *kwnames[] = {
30090 (char *) "self",(char *) "data", NULL
30091 };
30092
30093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30095 if (SWIG_arg_fail(1)) SWIG_fail;
30096 {
30097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30098 if (SWIG_arg_fail(2)) SWIG_fail;
30099 if (arg2 == NULL) {
30100 SWIG_null_ref("wxDataObject");
30101 }
30102 if (SWIG_arg_fail(2)) SWIG_fail;
30103 }
30104 {
30105 PyThreadState* __tstate = wxPyBeginAllowThreads();
30106 result = (bool)(arg1)->GetData(*arg2);
30107
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 {
30112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30113 }
30114 return resultobj;
30115 fail:
30116 return NULL;
30117 }
30118
30119
30120 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30121 PyObject *resultobj;
30122 wxClipboard *arg1 = (wxClipboard *) 0 ;
30123 PyObject * obj0 = 0 ;
30124 char *kwnames[] = {
30125 (char *) "self", NULL
30126 };
30127
30128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30130 if (SWIG_arg_fail(1)) SWIG_fail;
30131 {
30132 PyThreadState* __tstate = wxPyBeginAllowThreads();
30133 (arg1)->Clear();
30134
30135 wxPyEndAllowThreads(__tstate);
30136 if (PyErr_Occurred()) SWIG_fail;
30137 }
30138 Py_INCREF(Py_None); resultobj = Py_None;
30139 return resultobj;
30140 fail:
30141 return NULL;
30142 }
30143
30144
30145 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30146 PyObject *resultobj;
30147 wxClipboard *arg1 = (wxClipboard *) 0 ;
30148 bool result;
30149 PyObject * obj0 = 0 ;
30150 char *kwnames[] = {
30151 (char *) "self", NULL
30152 };
30153
30154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30156 if (SWIG_arg_fail(1)) SWIG_fail;
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 result = (bool)(arg1)->Flush();
30160
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 {
30165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30166 }
30167 return resultobj;
30168 fail:
30169 return NULL;
30170 }
30171
30172
30173 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30174 PyObject *resultobj;
30175 wxClipboard *arg1 = (wxClipboard *) 0 ;
30176 bool arg2 = (bool) true ;
30177 PyObject * obj0 = 0 ;
30178 PyObject * obj1 = 0 ;
30179 char *kwnames[] = {
30180 (char *) "self",(char *) "primary", NULL
30181 };
30182
30183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30185 if (SWIG_arg_fail(1)) SWIG_fail;
30186 if (obj1) {
30187 {
30188 arg2 = (bool)(SWIG_As_bool(obj1));
30189 if (SWIG_arg_fail(2)) SWIG_fail;
30190 }
30191 }
30192 {
30193 PyThreadState* __tstate = wxPyBeginAllowThreads();
30194 (arg1)->UsePrimarySelection(arg2);
30195
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 Py_INCREF(Py_None); resultobj = Py_None;
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30207 PyObject *resultobj;
30208 wxClipboard *result;
30209 char *kwnames[] = {
30210 NULL
30211 };
30212
30213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30214 {
30215 PyThreadState* __tstate = wxPyBeginAllowThreads();
30216 result = (wxClipboard *)wxClipboard::Get();
30217
30218 wxPyEndAllowThreads(__tstate);
30219 if (PyErr_Occurred()) SWIG_fail;
30220 }
30221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30222 return resultobj;
30223 fail:
30224 return NULL;
30225 }
30226
30227
30228 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30229 PyObject *obj;
30230 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30231 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30232 Py_INCREF(obj);
30233 return Py_BuildValue((char *)"");
30234 }
30235 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj;
30237 wxClipboard *arg1 = (wxClipboard *) NULL ;
30238 wxClipboardLocker *result;
30239 PyObject * obj0 = 0 ;
30240 char *kwnames[] = {
30241 (char *) "clipboard", NULL
30242 };
30243
30244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30245 if (obj0) {
30246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30247 if (SWIG_arg_fail(1)) SWIG_fail;
30248 }
30249 {
30250 PyThreadState* __tstate = wxPyBeginAllowThreads();
30251 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30252
30253 wxPyEndAllowThreads(__tstate);
30254 if (PyErr_Occurred()) SWIG_fail;
30255 }
30256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30264 PyObject *resultobj;
30265 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30266 PyObject * obj0 = 0 ;
30267 char *kwnames[] = {
30268 (char *) "self", NULL
30269 };
30270
30271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30273 if (SWIG_arg_fail(1)) SWIG_fail;
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 delete arg1;
30277
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 Py_INCREF(Py_None); resultobj = Py_None;
30282 return resultobj;
30283 fail:
30284 return NULL;
30285 }
30286
30287
30288 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30289 PyObject *resultobj;
30290 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30291 bool result;
30292 PyObject * obj0 = 0 ;
30293 char *kwnames[] = {
30294 (char *) "self", NULL
30295 };
30296
30297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30299 if (SWIG_arg_fail(1)) SWIG_fail;
30300 {
30301 PyThreadState* __tstate = wxPyBeginAllowThreads();
30302 result = (bool)wxClipboardLocker___nonzero__(arg1);
30303
30304 wxPyEndAllowThreads(__tstate);
30305 if (PyErr_Occurred()) SWIG_fail;
30306 }
30307 {
30308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30309 }
30310 return resultobj;
30311 fail:
30312 return NULL;
30313 }
30314
30315
30316 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30317 PyObject *obj;
30318 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30319 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30320 Py_INCREF(obj);
30321 return Py_BuildValue((char *)"");
30322 }
30323 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30324 PyObject *resultobj;
30325 int arg1 = (int) 0 ;
30326 int arg2 = (int) 0 ;
30327 int arg3 = (int) 0 ;
30328 int arg4 = (int) 0 ;
30329 wxVideoMode *result;
30330 PyObject * obj0 = 0 ;
30331 PyObject * obj1 = 0 ;
30332 PyObject * obj2 = 0 ;
30333 PyObject * obj3 = 0 ;
30334 char *kwnames[] = {
30335 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30336 };
30337
30338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30339 if (obj0) {
30340 {
30341 arg1 = (int)(SWIG_As_int(obj0));
30342 if (SWIG_arg_fail(1)) SWIG_fail;
30343 }
30344 }
30345 if (obj1) {
30346 {
30347 arg2 = (int)(SWIG_As_int(obj1));
30348 if (SWIG_arg_fail(2)) SWIG_fail;
30349 }
30350 }
30351 if (obj2) {
30352 {
30353 arg3 = (int)(SWIG_As_int(obj2));
30354 if (SWIG_arg_fail(3)) SWIG_fail;
30355 }
30356 }
30357 if (obj3) {
30358 {
30359 arg4 = (int)(SWIG_As_int(obj3));
30360 if (SWIG_arg_fail(4)) SWIG_fail;
30361 }
30362 }
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30366
30367 wxPyEndAllowThreads(__tstate);
30368 if (PyErr_Occurred()) SWIG_fail;
30369 }
30370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30371 return resultobj;
30372 fail:
30373 return NULL;
30374 }
30375
30376
30377 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30378 PyObject *resultobj;
30379 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30380 PyObject * obj0 = 0 ;
30381 char *kwnames[] = {
30382 (char *) "self", NULL
30383 };
30384
30385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30387 if (SWIG_arg_fail(1)) SWIG_fail;
30388 {
30389 PyThreadState* __tstate = wxPyBeginAllowThreads();
30390 delete arg1;
30391
30392 wxPyEndAllowThreads(__tstate);
30393 if (PyErr_Occurred()) SWIG_fail;
30394 }
30395 Py_INCREF(Py_None); resultobj = Py_None;
30396 return resultobj;
30397 fail:
30398 return NULL;
30399 }
30400
30401
30402 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30403 PyObject *resultobj;
30404 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30405 wxVideoMode *arg2 = 0 ;
30406 bool result;
30407 PyObject * obj0 = 0 ;
30408 PyObject * obj1 = 0 ;
30409 char *kwnames[] = {
30410 (char *) "self",(char *) "other", NULL
30411 };
30412
30413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30415 if (SWIG_arg_fail(1)) SWIG_fail;
30416 {
30417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30418 if (SWIG_arg_fail(2)) SWIG_fail;
30419 if (arg2 == NULL) {
30420 SWIG_null_ref("wxVideoMode");
30421 }
30422 if (SWIG_arg_fail(2)) SWIG_fail;
30423 }
30424 {
30425 PyThreadState* __tstate = wxPyBeginAllowThreads();
30426 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30427
30428 wxPyEndAllowThreads(__tstate);
30429 if (PyErr_Occurred()) SWIG_fail;
30430 }
30431 {
30432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30433 }
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj;
30442 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30443 int result;
30444 PyObject * obj0 = 0 ;
30445 char *kwnames[] = {
30446 (char *) "self", NULL
30447 };
30448
30449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30451 if (SWIG_arg_fail(1)) SWIG_fail;
30452 {
30453 PyThreadState* __tstate = wxPyBeginAllowThreads();
30454 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30455
30456 wxPyEndAllowThreads(__tstate);
30457 if (PyErr_Occurred()) SWIG_fail;
30458 }
30459 {
30460 resultobj = SWIG_From_int((int)(result));
30461 }
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30469 PyObject *resultobj;
30470 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30471 int result;
30472 PyObject * obj0 = 0 ;
30473 char *kwnames[] = {
30474 (char *) "self", NULL
30475 };
30476
30477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30479 if (SWIG_arg_fail(1)) SWIG_fail;
30480 {
30481 PyThreadState* __tstate = wxPyBeginAllowThreads();
30482 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30483
30484 wxPyEndAllowThreads(__tstate);
30485 if (PyErr_Occurred()) SWIG_fail;
30486 }
30487 {
30488 resultobj = SWIG_From_int((int)(result));
30489 }
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30497 PyObject *resultobj;
30498 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30499 int result;
30500 PyObject * obj0 = 0 ;
30501 char *kwnames[] = {
30502 (char *) "self", NULL
30503 };
30504
30505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30507 if (SWIG_arg_fail(1)) SWIG_fail;
30508 {
30509 PyThreadState* __tstate = wxPyBeginAllowThreads();
30510 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30511
30512 wxPyEndAllowThreads(__tstate);
30513 if (PyErr_Occurred()) SWIG_fail;
30514 }
30515 {
30516 resultobj = SWIG_From_int((int)(result));
30517 }
30518 return resultobj;
30519 fail:
30520 return NULL;
30521 }
30522
30523
30524 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30525 PyObject *resultobj;
30526 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30527 bool result;
30528 PyObject * obj0 = 0 ;
30529 char *kwnames[] = {
30530 (char *) "self", NULL
30531 };
30532
30533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30535 if (SWIG_arg_fail(1)) SWIG_fail;
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30539
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 {
30544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30545 }
30546 return resultobj;
30547 fail:
30548 return NULL;
30549 }
30550
30551
30552 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30553 PyObject *resultobj;
30554 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30555 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30556 bool result;
30557 PyObject * obj0 = 0 ;
30558 PyObject * obj1 = 0 ;
30559 char *kwnames[] = {
30560 (char *) "self",(char *) "other", NULL
30561 };
30562
30563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30565 if (SWIG_arg_fail(1)) SWIG_fail;
30566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30567 if (SWIG_arg_fail(2)) SWIG_fail;
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30571
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 {
30576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30577 }
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30585 PyObject *resultobj;
30586 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30587 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30588 bool result;
30589 PyObject * obj0 = 0 ;
30590 PyObject * obj1 = 0 ;
30591 char *kwnames[] = {
30592 (char *) "self",(char *) "other", NULL
30593 };
30594
30595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30597 if (SWIG_arg_fail(1)) SWIG_fail;
30598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30599 if (SWIG_arg_fail(2)) SWIG_fail;
30600 {
30601 PyThreadState* __tstate = wxPyBeginAllowThreads();
30602 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30603
30604 wxPyEndAllowThreads(__tstate);
30605 if (PyErr_Occurred()) SWIG_fail;
30606 }
30607 {
30608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30609 }
30610 return resultobj;
30611 fail:
30612 return NULL;
30613 }
30614
30615
30616 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30617 PyObject *resultobj;
30618 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30619 int arg2 ;
30620 PyObject * obj0 = 0 ;
30621 PyObject * obj1 = 0 ;
30622 char *kwnames[] = {
30623 (char *) "self",(char *) "w", NULL
30624 };
30625
30626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30628 if (SWIG_arg_fail(1)) SWIG_fail;
30629 {
30630 arg2 = (int)(SWIG_As_int(obj1));
30631 if (SWIG_arg_fail(2)) SWIG_fail;
30632 }
30633 if (arg1) (arg1)->w = arg2;
30634
30635 Py_INCREF(Py_None); resultobj = Py_None;
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30643 PyObject *resultobj;
30644 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30645 int result;
30646 PyObject * obj0 = 0 ;
30647 char *kwnames[] = {
30648 (char *) "self", NULL
30649 };
30650
30651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30653 if (SWIG_arg_fail(1)) SWIG_fail;
30654 result = (int) ((arg1)->w);
30655
30656 {
30657 resultobj = SWIG_From_int((int)(result));
30658 }
30659 return resultobj;
30660 fail:
30661 return NULL;
30662 }
30663
30664
30665 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30666 PyObject *resultobj;
30667 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30668 int arg2 ;
30669 PyObject * obj0 = 0 ;
30670 PyObject * obj1 = 0 ;
30671 char *kwnames[] = {
30672 (char *) "self",(char *) "h", NULL
30673 };
30674
30675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30677 if (SWIG_arg_fail(1)) SWIG_fail;
30678 {
30679 arg2 = (int)(SWIG_As_int(obj1));
30680 if (SWIG_arg_fail(2)) SWIG_fail;
30681 }
30682 if (arg1) (arg1)->h = arg2;
30683
30684 Py_INCREF(Py_None); resultobj = Py_None;
30685 return resultobj;
30686 fail:
30687 return NULL;
30688 }
30689
30690
30691 static PyObject *_wrap_VideoMode_h_get(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_h_get",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 result = (int) ((arg1)->h);
30704
30705 {
30706 resultobj = SWIG_From_int((int)(result));
30707 }
30708 return resultobj;
30709 fail:
30710 return NULL;
30711 }
30712
30713
30714 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30715 PyObject *resultobj;
30716 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30717 int arg2 ;
30718 PyObject * obj0 = 0 ;
30719 PyObject * obj1 = 0 ;
30720 char *kwnames[] = {
30721 (char *) "self",(char *) "bpp", NULL
30722 };
30723
30724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30726 if (SWIG_arg_fail(1)) SWIG_fail;
30727 {
30728 arg2 = (int)(SWIG_As_int(obj1));
30729 if (SWIG_arg_fail(2)) SWIG_fail;
30730 }
30731 if (arg1) (arg1)->bpp = arg2;
30732
30733 Py_INCREF(Py_None); resultobj = Py_None;
30734 return resultobj;
30735 fail:
30736 return NULL;
30737 }
30738
30739
30740 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30741 PyObject *resultobj;
30742 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30743 int result;
30744 PyObject * obj0 = 0 ;
30745 char *kwnames[] = {
30746 (char *) "self", NULL
30747 };
30748
30749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30751 if (SWIG_arg_fail(1)) SWIG_fail;
30752 result = (int) ((arg1)->bpp);
30753
30754 {
30755 resultobj = SWIG_From_int((int)(result));
30756 }
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30764 PyObject *resultobj;
30765 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30766 int arg2 ;
30767 PyObject * obj0 = 0 ;
30768 PyObject * obj1 = 0 ;
30769 char *kwnames[] = {
30770 (char *) "self",(char *) "refresh", NULL
30771 };
30772
30773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30775 if (SWIG_arg_fail(1)) SWIG_fail;
30776 {
30777 arg2 = (int)(SWIG_As_int(obj1));
30778 if (SWIG_arg_fail(2)) SWIG_fail;
30779 }
30780 if (arg1) (arg1)->refresh = arg2;
30781
30782 Py_INCREF(Py_None); resultobj = Py_None;
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30790 PyObject *resultobj;
30791 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30792 int result;
30793 PyObject * obj0 = 0 ;
30794 char *kwnames[] = {
30795 (char *) "self", NULL
30796 };
30797
30798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30800 if (SWIG_arg_fail(1)) SWIG_fail;
30801 result = (int) ((arg1)->refresh);
30802
30803 {
30804 resultobj = SWIG_From_int((int)(result));
30805 }
30806 return resultobj;
30807 fail:
30808 return NULL;
30809 }
30810
30811
30812 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30813 PyObject *obj;
30814 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30815 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30816 Py_INCREF(obj);
30817 return Py_BuildValue((char *)"");
30818 }
30819 static int _wrap_DefaultVideoMode_set(PyObject *) {
30820 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30821 return 1;
30822 }
30823
30824
30825 static PyObject *_wrap_DefaultVideoMode_get(void) {
30826 PyObject *pyobj;
30827
30828 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30829 return pyobj;
30830 }
30831
30832
30833 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30834 PyObject *resultobj;
30835 size_t arg1 = (size_t) 0 ;
30836 wxDisplay *result;
30837 PyObject * obj0 = 0 ;
30838 char *kwnames[] = {
30839 (char *) "index", NULL
30840 };
30841
30842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30843 if (obj0) {
30844 {
30845 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30846 if (SWIG_arg_fail(1)) SWIG_fail;
30847 }
30848 }
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = (wxDisplay *)new wxDisplay(arg1);
30852
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30864 PyObject *resultobj;
30865 wxDisplay *arg1 = (wxDisplay *) 0 ;
30866 PyObject * obj0 = 0 ;
30867 char *kwnames[] = {
30868 (char *) "self", NULL
30869 };
30870
30871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30873 if (SWIG_arg_fail(1)) SWIG_fail;
30874 {
30875 PyThreadState* __tstate = wxPyBeginAllowThreads();
30876 delete arg1;
30877
30878 wxPyEndAllowThreads(__tstate);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 }
30881 Py_INCREF(Py_None); resultobj = Py_None;
30882 return resultobj;
30883 fail:
30884 return NULL;
30885 }
30886
30887
30888 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30889 PyObject *resultobj;
30890 size_t result;
30891 char *kwnames[] = {
30892 NULL
30893 };
30894
30895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30896 {
30897 PyThreadState* __tstate = wxPyBeginAllowThreads();
30898 result = (size_t)wxDisplay::GetCount();
30899
30900 wxPyEndAllowThreads(__tstate);
30901 if (PyErr_Occurred()) SWIG_fail;
30902 }
30903 {
30904 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30905 }
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30913 PyObject *resultobj;
30914 wxPoint *arg1 = 0 ;
30915 int result;
30916 wxPoint temp1 ;
30917 PyObject * obj0 = 0 ;
30918 char *kwnames[] = {
30919 (char *) "pt", NULL
30920 };
30921
30922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30923 {
30924 arg1 = &temp1;
30925 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30926 }
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30930
30931 wxPyEndAllowThreads(__tstate);
30932 if (PyErr_Occurred()) SWIG_fail;
30933 }
30934 {
30935 resultobj = SWIG_From_int((int)(result));
30936 }
30937 return resultobj;
30938 fail:
30939 return NULL;
30940 }
30941
30942
30943 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30944 PyObject *resultobj;
30945 wxWindow *arg1 = (wxWindow *) 0 ;
30946 int result;
30947 PyObject * obj0 = 0 ;
30948 char *kwnames[] = {
30949 (char *) "window", NULL
30950 };
30951
30952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30954 if (SWIG_arg_fail(1)) SWIG_fail;
30955 {
30956 PyThreadState* __tstate = wxPyBeginAllowThreads();
30957 result = (int)wxDisplay::GetFromWindow(arg1);
30958
30959 wxPyEndAllowThreads(__tstate);
30960 if (PyErr_Occurred()) SWIG_fail;
30961 }
30962 {
30963 resultobj = SWIG_From_int((int)(result));
30964 }
30965 return resultobj;
30966 fail:
30967 return NULL;
30968 }
30969
30970
30971 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30972 PyObject *resultobj;
30973 wxDisplay *arg1 = (wxDisplay *) 0 ;
30974 bool result;
30975 PyObject * obj0 = 0 ;
30976 char *kwnames[] = {
30977 (char *) "self", NULL
30978 };
30979
30980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30982 if (SWIG_arg_fail(1)) SWIG_fail;
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 result = (bool)((wxDisplay const *)arg1)->IsOk();
30986
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 {
30991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30992 }
30993 return resultobj;
30994 fail:
30995 return NULL;
30996 }
30997
30998
30999 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
31000 PyObject *resultobj;
31001 wxDisplay *arg1 = (wxDisplay *) 0 ;
31002 wxRect result;
31003 PyObject * obj0 = 0 ;
31004 char *kwnames[] = {
31005 (char *) "self", NULL
31006 };
31007
31008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
31009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31010 if (SWIG_arg_fail(1)) SWIG_fail;
31011 {
31012 PyThreadState* __tstate = wxPyBeginAllowThreads();
31013 result = ((wxDisplay const *)arg1)->GetGeometry();
31014
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 {
31019 wxRect * resultptr;
31020 resultptr = new wxRect((wxRect &)(result));
31021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
31022 }
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
31030 PyObject *resultobj;
31031 wxDisplay *arg1 = (wxDisplay *) 0 ;
31032 wxString result;
31033 PyObject * obj0 = 0 ;
31034 char *kwnames[] = {
31035 (char *) "self", NULL
31036 };
31037
31038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31040 if (SWIG_arg_fail(1)) SWIG_fail;
31041 {
31042 PyThreadState* __tstate = wxPyBeginAllowThreads();
31043 result = ((wxDisplay const *)arg1)->GetName();
31044
31045 wxPyEndAllowThreads(__tstate);
31046 if (PyErr_Occurred()) SWIG_fail;
31047 }
31048 {
31049 #if wxUSE_UNICODE
31050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31051 #else
31052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31053 #endif
31054 }
31055 return resultobj;
31056 fail:
31057 return NULL;
31058 }
31059
31060
31061 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31062 PyObject *resultobj;
31063 wxDisplay *arg1 = (wxDisplay *) 0 ;
31064 bool result;
31065 PyObject * obj0 = 0 ;
31066 char *kwnames[] = {
31067 (char *) "self", NULL
31068 };
31069
31070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31072 if (SWIG_arg_fail(1)) SWIG_fail;
31073 {
31074 PyThreadState* __tstate = wxPyBeginAllowThreads();
31075 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31076
31077 wxPyEndAllowThreads(__tstate);
31078 if (PyErr_Occurred()) SWIG_fail;
31079 }
31080 {
31081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31082 }
31083 return resultobj;
31084 fail:
31085 return NULL;
31086 }
31087
31088
31089 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31090 PyObject *resultobj;
31091 wxDisplay *arg1 = (wxDisplay *) 0 ;
31092 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31093 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31094 PyObject *result;
31095 PyObject * obj0 = 0 ;
31096 PyObject * obj1 = 0 ;
31097 char *kwnames[] = {
31098 (char *) "self",(char *) "mode", NULL
31099 };
31100
31101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31103 if (SWIG_arg_fail(1)) SWIG_fail;
31104 if (obj1) {
31105 {
31106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31107 if (SWIG_arg_fail(2)) SWIG_fail;
31108 if (arg2 == NULL) {
31109 SWIG_null_ref("wxVideoMode");
31110 }
31111 if (SWIG_arg_fail(2)) SWIG_fail;
31112 }
31113 }
31114 {
31115 PyThreadState* __tstate = wxPyBeginAllowThreads();
31116 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31117
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 resultobj = result;
31122 return resultobj;
31123 fail:
31124 return NULL;
31125 }
31126
31127
31128 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31129 PyObject *resultobj;
31130 wxDisplay *arg1 = (wxDisplay *) 0 ;
31131 wxVideoMode result;
31132 PyObject * obj0 = 0 ;
31133 char *kwnames[] = {
31134 (char *) "self", NULL
31135 };
31136
31137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31139 if (SWIG_arg_fail(1)) SWIG_fail;
31140 {
31141 PyThreadState* __tstate = wxPyBeginAllowThreads();
31142 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31143
31144 wxPyEndAllowThreads(__tstate);
31145 if (PyErr_Occurred()) SWIG_fail;
31146 }
31147 {
31148 wxVideoMode * resultptr;
31149 resultptr = new wxVideoMode((wxVideoMode &)(result));
31150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31151 }
31152 return resultobj;
31153 fail:
31154 return NULL;
31155 }
31156
31157
31158 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31159 PyObject *resultobj;
31160 wxDisplay *arg1 = (wxDisplay *) 0 ;
31161 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31162 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31163 bool result;
31164 PyObject * obj0 = 0 ;
31165 PyObject * obj1 = 0 ;
31166 char *kwnames[] = {
31167 (char *) "self",(char *) "mode", NULL
31168 };
31169
31170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31172 if (SWIG_arg_fail(1)) SWIG_fail;
31173 if (obj1) {
31174 {
31175 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31176 if (SWIG_arg_fail(2)) SWIG_fail;
31177 if (arg2 == NULL) {
31178 SWIG_null_ref("wxVideoMode");
31179 }
31180 if (SWIG_arg_fail(2)) SWIG_fail;
31181 }
31182 }
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31186
31187 wxPyEndAllowThreads(__tstate);
31188 if (PyErr_Occurred()) SWIG_fail;
31189 }
31190 {
31191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31192 }
31193 return resultobj;
31194 fail:
31195 return NULL;
31196 }
31197
31198
31199 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31200 PyObject *resultobj;
31201 wxDisplay *arg1 = (wxDisplay *) 0 ;
31202 PyObject * obj0 = 0 ;
31203 char *kwnames[] = {
31204 (char *) "self", NULL
31205 };
31206
31207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31209 if (SWIG_arg_fail(1)) SWIG_fail;
31210 {
31211 PyThreadState* __tstate = wxPyBeginAllowThreads();
31212 (arg1)->ResetMode();
31213
31214 wxPyEndAllowThreads(__tstate);
31215 if (PyErr_Occurred()) SWIG_fail;
31216 }
31217 Py_INCREF(Py_None); resultobj = Py_None;
31218 return resultobj;
31219 fail:
31220 return NULL;
31221 }
31222
31223
31224 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31225 PyObject *obj;
31226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31227 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31228 Py_INCREF(obj);
31229 return Py_BuildValue((char *)"");
31230 }
31231 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31232 PyObject *resultobj;
31233 wxStandardPaths *result;
31234 char *kwnames[] = {
31235 NULL
31236 };
31237
31238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31239 {
31240 PyThreadState* __tstate = wxPyBeginAllowThreads();
31241 result = (wxStandardPaths *)StandardPaths_Get();
31242
31243 wxPyEndAllowThreads(__tstate);
31244 if (PyErr_Occurred()) SWIG_fail;
31245 }
31246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31247 return resultobj;
31248 fail:
31249 return NULL;
31250 }
31251
31252
31253 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31254 PyObject *resultobj;
31255 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31256 wxString result;
31257 PyObject * obj0 = 0 ;
31258 char *kwnames[] = {
31259 (char *) "self", NULL
31260 };
31261
31262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31264 if (SWIG_arg_fail(1)) SWIG_fail;
31265 {
31266 PyThreadState* __tstate = wxPyBeginAllowThreads();
31267 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31268
31269 wxPyEndAllowThreads(__tstate);
31270 if (PyErr_Occurred()) SWIG_fail;
31271 }
31272 {
31273 #if wxUSE_UNICODE
31274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31275 #else
31276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31277 #endif
31278 }
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj;
31287 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31288 wxString result;
31289 PyObject * obj0 = 0 ;
31290 char *kwnames[] = {
31291 (char *) "self", NULL
31292 };
31293
31294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31296 if (SWIG_arg_fail(1)) SWIG_fail;
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31300
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 {
31305 #if wxUSE_UNICODE
31306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31307 #else
31308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31309 #endif
31310 }
31311 return resultobj;
31312 fail:
31313 return NULL;
31314 }
31315
31316
31317 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31318 PyObject *resultobj;
31319 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31320 wxString result;
31321 PyObject * obj0 = 0 ;
31322 char *kwnames[] = {
31323 (char *) "self", NULL
31324 };
31325
31326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31328 if (SWIG_arg_fail(1)) SWIG_fail;
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31332
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 {
31337 #if wxUSE_UNICODE
31338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31339 #else
31340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31341 #endif
31342 }
31343 return resultobj;
31344 fail:
31345 return NULL;
31346 }
31347
31348
31349 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31350 PyObject *resultobj;
31351 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31352 wxString result;
31353 PyObject * obj0 = 0 ;
31354 char *kwnames[] = {
31355 (char *) "self", NULL
31356 };
31357
31358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31360 if (SWIG_arg_fail(1)) SWIG_fail;
31361 {
31362 PyThreadState* __tstate = wxPyBeginAllowThreads();
31363 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31364
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 {
31369 #if wxUSE_UNICODE
31370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31371 #else
31372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31373 #endif
31374 }
31375 return resultobj;
31376 fail:
31377 return NULL;
31378 }
31379
31380
31381 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31382 PyObject *resultobj;
31383 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31384 wxString result;
31385 PyObject * obj0 = 0 ;
31386 char *kwnames[] = {
31387 (char *) "self", NULL
31388 };
31389
31390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31392 if (SWIG_arg_fail(1)) SWIG_fail;
31393 {
31394 PyThreadState* __tstate = wxPyBeginAllowThreads();
31395 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31396
31397 wxPyEndAllowThreads(__tstate);
31398 if (PyErr_Occurred()) SWIG_fail;
31399 }
31400 {
31401 #if wxUSE_UNICODE
31402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31403 #else
31404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31405 #endif
31406 }
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31414 PyObject *resultobj;
31415 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31416 wxString result;
31417 PyObject * obj0 = 0 ;
31418 char *kwnames[] = {
31419 (char *) "self", NULL
31420 };
31421
31422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31424 if (SWIG_arg_fail(1)) SWIG_fail;
31425 {
31426 PyThreadState* __tstate = wxPyBeginAllowThreads();
31427 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31428
31429 wxPyEndAllowThreads(__tstate);
31430 if (PyErr_Occurred()) SWIG_fail;
31431 }
31432 {
31433 #if wxUSE_UNICODE
31434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31435 #else
31436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31437 #endif
31438 }
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31446 PyObject *resultobj;
31447 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31448 wxString result;
31449 PyObject * obj0 = 0 ;
31450 char *kwnames[] = {
31451 (char *) "self", NULL
31452 };
31453
31454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31456 if (SWIG_arg_fail(1)) SWIG_fail;
31457 {
31458 PyThreadState* __tstate = wxPyBeginAllowThreads();
31459 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31460
31461 wxPyEndAllowThreads(__tstate);
31462 if (PyErr_Occurred()) SWIG_fail;
31463 }
31464 {
31465 #if wxUSE_UNICODE
31466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31467 #else
31468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31469 #endif
31470 }
31471 return resultobj;
31472 fail:
31473 return NULL;
31474 }
31475
31476
31477 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31478 PyObject *resultobj;
31479 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31480 wxString *arg2 = 0 ;
31481 bool temp2 = false ;
31482 PyObject * obj0 = 0 ;
31483 PyObject * obj1 = 0 ;
31484 char *kwnames[] = {
31485 (char *) "self",(char *) "prefix", NULL
31486 };
31487
31488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31490 if (SWIG_arg_fail(1)) SWIG_fail;
31491 {
31492 arg2 = wxString_in_helper(obj1);
31493 if (arg2 == NULL) SWIG_fail;
31494 temp2 = true;
31495 }
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31499
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 Py_INCREF(Py_None); resultobj = Py_None;
31504 {
31505 if (temp2)
31506 delete arg2;
31507 }
31508 return resultobj;
31509 fail:
31510 {
31511 if (temp2)
31512 delete arg2;
31513 }
31514 return NULL;
31515 }
31516
31517
31518 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31519 PyObject *resultobj;
31520 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31521 wxString result;
31522 PyObject * obj0 = 0 ;
31523 char *kwnames[] = {
31524 (char *) "self", NULL
31525 };
31526
31527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31529 if (SWIG_arg_fail(1)) SWIG_fail;
31530 {
31531 PyThreadState* __tstate = wxPyBeginAllowThreads();
31532 result = wxStandardPaths_GetInstallPrefix(arg1);
31533
31534 wxPyEndAllowThreads(__tstate);
31535 if (PyErr_Occurred()) SWIG_fail;
31536 }
31537 {
31538 #if wxUSE_UNICODE
31539 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31540 #else
31541 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31542 #endif
31543 }
31544 return resultobj;
31545 fail:
31546 return NULL;
31547 }
31548
31549
31550 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31551 PyObject *obj;
31552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31553 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31554 Py_INCREF(obj);
31555 return Py_BuildValue((char *)"");
31556 }
31557 static PyMethodDef SwigMethods[] = {
31558 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31565 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31573 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31638 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31646 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31664 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31667 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31670 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31673 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31679 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31693 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31699 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31705 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31708 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31722 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31725 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31726 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31729 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31756 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31758 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31760 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31762 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31769 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31775 { (char *)"new_LogBuffer", (PyCFunction) _wrap_new_LogBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"LogBuffer_GetBuffer", (PyCFunction) _wrap_LogBuffer_GetBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"LogBuffer_Flush", (PyCFunction) _wrap_LogBuffer_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
31779 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31793 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31797 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31800 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31817 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31825 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31872 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31890 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31900 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31916 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31932 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31946 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31956 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31999 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
32002 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
32005 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
32009 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32102 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32103 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32104 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32105 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32122 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32167 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32201 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32209 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32210 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32215 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32224 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32231 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32234 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32237 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32242 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32245 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32249 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32252 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32256 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32257 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32261 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32265 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32269 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32279 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32292 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32300 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32308 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32322 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32326 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32330 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32333 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32334 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32335 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32336 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32337 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32338 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32339 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32340 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32341 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32342 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32343 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32344 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32345 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32346 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32347 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32348 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32349 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32350 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32351 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32352 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32353 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32354 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32355 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32356 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32357 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32358 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32359 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32360 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32361 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32362 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32363 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32364 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32365 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32366 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32367 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32368 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32369 { NULL, NULL, 0, NULL }
32370 };
32371
32372
32373 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32374
32375 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32376 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32377 }
32378 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32379 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32380 }
32381 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32382 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32383 }
32384 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32385 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32386 }
32387 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32388 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32389 }
32390 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32391 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32392 }
32393 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32394 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32395 }
32396 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32397 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32398 }
32399 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32400 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32401 }
32402 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32403 return (void *)((wxEvent *) ((wxPyEvent *) x));
32404 }
32405 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32406 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32407 }
32408 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32409 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32410 }
32411 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32412 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32413 }
32414 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32415 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32416 }
32417 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32418 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32419 }
32420 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32421 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32422 }
32423 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32424 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32425 }
32426 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32427 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32428 }
32429 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32430 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32431 }
32432 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32433 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32434 }
32435 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32436 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32437 }
32438 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32439 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32440 }
32441 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32442 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32443 }
32444 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32445 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32446 }
32447 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32448 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32449 }
32450 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32451 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32452 }
32453 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32454 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32455 }
32456 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32457 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32458 }
32459 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32460 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32461 }
32462 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32463 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32464 }
32465 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32466 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32467 }
32468 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32469 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32470 }
32471 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32472 return (void *)((wxEvent *) ((wxShowEvent *) x));
32473 }
32474 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32475 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32476 }
32477 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32478 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32479 }
32480 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32481 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32482 }
32483 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32484 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32485 }
32486 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32487 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32488 }
32489 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32490 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32491 }
32492 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32493 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32494 }
32495 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32496 return (void *)((wxConfigBase *) ((wxConfig *) x));
32497 }
32498 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32499 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32500 }
32501 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32502 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32503 }
32504 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32505 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32506 }
32507 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32508 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32509 }
32510 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32511 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32512 }
32513 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32514 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32515 }
32516 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32517 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32518 }
32519 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32520 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32521 }
32522 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32523 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32524 }
32525 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32526 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32527 }
32528 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32529 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32530 }
32531 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32532 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32533 }
32534 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32535 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32536 }
32537 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32538 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32539 }
32540 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32541 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32542 }
32543 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32544 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32545 }
32546 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32547 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32548 }
32549 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32550 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32551 }
32552 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32553 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32554 }
32555 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32556 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32557 }
32558 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32559 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32560 }
32561 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32562 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32563 }
32564 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32565 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32566 }
32567 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32568 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32569 }
32570 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32571 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32572 }
32573 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32574 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32575 }
32576 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32577 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32578 }
32579 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32580 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32581 }
32582 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32583 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32584 }
32585 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32586 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32587 }
32588 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32589 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32590 }
32591 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32592 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32593 }
32594 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32595 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32596 }
32597 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32598 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32599 }
32600 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32601 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32602 }
32603 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32604 return (void *)((wxObject *) ((wxSizerItem *) x));
32605 }
32606 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32607 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32608 }
32609 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32610 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32611 }
32612 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32613 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32614 }
32615 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32616 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32617 }
32618 static void *_p_wxSizerTo_p_wxObject(void *x) {
32619 return (void *)((wxObject *) ((wxSizer *) x));
32620 }
32621 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32622 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32623 }
32624 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32625 return (void *)((wxObject *) ((wxFileHistory *) x));
32626 }
32627 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32628 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32629 }
32630 static void *_p_wxEventTo_p_wxObject(void *x) {
32631 return (void *)((wxObject *) ((wxEvent *) x));
32632 }
32633 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32634 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32635 }
32636 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32637 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32638 }
32639 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32640 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32641 }
32642 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32643 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32644 }
32645 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32646 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32647 }
32648 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32649 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32650 }
32651 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32652 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32653 }
32654 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32655 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32656 }
32657 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32658 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32659 }
32660 static void *_p_wxControlTo_p_wxObject(void *x) {
32661 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32662 }
32663 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32664 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32665 }
32666 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32667 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32668 }
32669 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32670 return (void *)((wxObject *) ((wxFSFile *) x));
32671 }
32672 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32673 return (void *)((wxObject *) ((wxClipboard *) x));
32674 }
32675 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32676 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32677 }
32678 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32679 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32680 }
32681 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32682 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32683 }
32684 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32685 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32686 }
32687 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32688 return (void *)((wxObject *) ((wxToolTip *) x));
32689 }
32690 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32691 return (void *)((wxObject *) ((wxMenuItem *) x));
32692 }
32693 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32694 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32695 }
32696 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32697 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32698 }
32699 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32700 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32701 }
32702 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32703 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32704 }
32705 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32706 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32707 }
32708 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32709 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32710 }
32711 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32712 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32713 }
32714 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32715 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32716 }
32717 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32718 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32719 }
32720 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32721 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32722 }
32723 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32724 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32725 }
32726 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32727 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32728 }
32729 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32730 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32731 }
32732 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32733 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32734 }
32735 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32736 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32737 }
32738 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32739 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32740 }
32741 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32742 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32743 }
32744 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32745 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32746 }
32747 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32748 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32749 }
32750 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32751 return (void *)((wxObject *) ((wxImageHandler *) x));
32752 }
32753 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32754 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32755 }
32756 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32757 return (void *)((wxObject *) ((wxEvtHandler *) x));
32758 }
32759 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32760 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32761 }
32762 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32763 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32764 }
32765 static void *_p_wxImageTo_p_wxObject(void *x) {
32766 return (void *)((wxObject *) ((wxImage *) x));
32767 }
32768 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32769 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32770 }
32771 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32772 return (void *)((wxObject *) ((wxSystemOptions *) x));
32773 }
32774 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32775 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32776 }
32777 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32778 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32779 }
32780 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32781 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32782 }
32783 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32784 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32785 }
32786 static void *_p_wxWindowTo_p_wxObject(void *x) {
32787 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32788 }
32789 static void *_p_wxMenuTo_p_wxObject(void *x) {
32790 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32791 }
32792 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32793 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32794 }
32795 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32796 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32797 }
32798 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32799 return (void *)((wxObject *) ((wxFileSystem *) x));
32800 }
32801 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32802 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32803 }
32804 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32805 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32806 }
32807 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32808 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32809 }
32810 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32811 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32812 }
32813 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32814 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32815 }
32816 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32817 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32818 }
32819 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32820 return (void *)((wxObject *) ((wxBusyInfo *) x));
32821 }
32822 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32823 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32824 }
32825 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32826 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32827 }
32828 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32829 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32830 }
32831 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32832 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32833 }
32834 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32835 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32836 }
32837 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32838 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32839 }
32840 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32841 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32842 }
32843 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32844 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32845 }
32846 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32847 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32848 }
32849 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32850 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32851 }
32852 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
32853 return (void *)((wxLog *) ((wxLogBuffer *) x));
32854 }
32855 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32856 return (void *)((wxLog *) ((wxLogStderr *) x));
32857 }
32858 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32859 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32860 }
32861 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32862 return (void *)((wxLog *) ((wxLogWindow *) x));
32863 }
32864 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32865 return (void *)((wxLog *) ((wxLogChain *) x));
32866 }
32867 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32868 return (void *)((wxLog *) ((wxLogGui *) x));
32869 }
32870 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32871 return (void *)((wxLog *) ((wxPyLog *) x));
32872 }
32873 static void *_p_wxControlTo_p_wxWindow(void *x) {
32874 return (void *)((wxWindow *) ((wxControl *) x));
32875 }
32876 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32877 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32878 }
32879 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32880 return (void *)((wxWindow *) ((wxMenuBar *) x));
32881 }
32882 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32883 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32884 }
32885 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32886 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32887 }
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918 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}};
32919 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}};
32920 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}};
32921 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}};
32922 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}};
32923 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}};
32924 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}};
32925 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}};
32926 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}};
32927 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}};
32928 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}};
32929 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}};
32930 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}};
32931 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}};
32932 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}};
32933 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}};
32934 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}};
32935 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}};
32936 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}};
32937 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}};
32938 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}};
32939 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}};
32940 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}};
32941 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}};
32942 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}};
32943 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}};
32944 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}};
32945 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}};
32946 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}};
32947 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}};
32948 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}};
32949 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}};
32950 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}};
32951 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}};
32952 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}};
32953 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}};
32954 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}};
32955 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}};
32956 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}};
32957 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}};
32958 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}};
32959 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}};
32960 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}};
32961 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32962 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}};
32963 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}};
32964 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}};
32965 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}};
32966 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}};
32967 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}};
32968 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}};
32969 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}};
32970 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}};
32971 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}};
32972 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}};
32973 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}};
32974 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}};
32975 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}};
32976 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}};
32977 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}};
32978 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}};
32979 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}};
32980 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}};
32981 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}};
32982 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}};
32983 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}};
32984 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}};
32985 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}};
32986 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}};
32987 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}};
32988
32989 static swig_type_info *swig_types_initial[] = {
32990 _swigt__p_wxLogChain,
32991 _swigt__p_wxMutexGuiLocker,
32992 _swigt__p_wxMetafile,
32993 _swigt__p_wxFileHistory,
32994 _swigt__p_wxLog,
32995 _swigt__p_wxMenu,
32996 _swigt__p_wxEvent,
32997 _swigt__p_wxDateTime__TimeZone,
32998 _swigt__p_wxConfigBase,
32999 _swigt__p_wxDisplay,
33000 _swigt__p_wxFileType,
33001 _swigt__p_wxLogGui,
33002 _swigt__p_wxMemorySize,
33003 _swigt__p_wxFont,
33004 _swigt__p_wxDataFormat,
33005 _swigt__p_wxTimerEvent,
33006 _swigt__p_wxCaret,
33007 _swigt__ptrdiff_t,
33008 _swigt__std__ptrdiff_t,
33009 _swigt__p_void,
33010 _swigt__p_int,
33011 _swigt__p_wxSize,
33012 _swigt__p_wxClipboard,
33013 _swigt__p_wxStopWatch,
33014 _swigt__p_wxDC,
33015 _swigt__p_wxClipboardLocker,
33016 _swigt__p_wxIcon,
33017 _swigt__p_wxLogStderr,
33018 _swigt__p_wxLogTextCtrl,
33019 _swigt__p_wxTextCtrl,
33020 _swigt__p_wxBusyCursor,
33021 _swigt__p_wxBitmapDataObject,
33022 _swigt__p_wxTextDataObject,
33023 _swigt__p_wxDataObject,
33024 _swigt__p_wxPyTextDataObject,
33025 _swigt__p_wxPyBitmapDataObject,
33026 _swigt__p_wxFileDataObject,
33027 _swigt__p_wxCustomDataObject,
33028 _swigt__p_wxURLDataObject,
33029 _swigt__p_wxMetafileDataObject,
33030 _swigt__p_wxSound,
33031 _swigt__p_wxTimerRunner,
33032 _swigt__p_wxLogWindow,
33033 _swigt__p_wxTimeSpan,
33034 _swigt__p_wxArrayString,
33035 _swigt__p_wxWindowDisabler,
33036 _swigt__p_form_ops_t,
33037 _swigt__p_wxToolTip,
33038 _swigt__p_wxDataObjectComposite,
33039 _swigt__p_wxSystemSettings,
33040 _swigt__p_wxFileConfig,
33041 _swigt__p_wxVideoMode,
33042 _swigt__p_wxDataObjectSimple,
33043 _swigt__p_wxPyDataObjectSimple,
33044 _swigt__p_wxDuplexMode,
33045 _swigt__p_wxEvtHandler,
33046 _swigt__p_wxRect,
33047 _swigt__p_char,
33048 _swigt__p_wxSingleInstanceChecker,
33049 _swigt__p_wxStandardPaths,
33050 _swigt__p_wxFileTypeInfo,
33051 _swigt__p_wxFrame,
33052 _swigt__p_wxTimer,
33053 _swigt__p_wxPaperSize,
33054 _swigt__p_wxMimeTypesManager,
33055 _swigt__p_wxPyTipProvider,
33056 _swigt__p_wxTipProvider,
33057 _swigt__p_wxJoystick,
33058 _swigt__p_wxSystemOptions,
33059 _swigt__p_wxPyArtProvider,
33060 _swigt__p_wxPoint,
33061 _swigt__p_wxJoystickEvent,
33062 _swigt__p_wxCursor,
33063 _swigt__p_wxObject,
33064 _swigt__p_wxOutputStream,
33065 _swigt__p_wxDateTime,
33066 _swigt__p_wxPyDropSource,
33067 _swigt__p_unsigned_long,
33068 _swigt__p_wxLogBuffer,
33069 _swigt__p_wxKillError,
33070 _swigt__p_wxWindow,
33071 _swigt__p_wxString,
33072 _swigt__p_wxPyProcess,
33073 _swigt__p_wxBitmap,
33074 _swigt__unsigned_int,
33075 _swigt__p_unsigned_int,
33076 _swigt__p_wxConfig,
33077 _swigt__p_unsigned_char,
33078 _swigt__p_wxChar,
33079 _swigt__p_wxBusyInfo,
33080 _swigt__p_wxPyDropTarget,
33081 _swigt__p_wxPyTextDropTarget,
33082 _swigt__p_wxPyFileDropTarget,
33083 _swigt__p_wxProcessEvent,
33084 _swigt__p_wxPyLog,
33085 _swigt__p_wxLogNull,
33086 _swigt__p_wxColour,
33087 _swigt__p_wxPyTimer,
33088 _swigt__p_wxConfigPathChanger,
33089 _swigt__p_wxDateSpan,
33090 0
33091 };
33092
33093
33094 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33095
33096 static swig_const_info swig_const_table[] = {
33097 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33098 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33099 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33100 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33101 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33102 {0, 0, 0, 0.0, 0, 0}};
33103
33104 #ifdef __cplusplus
33105 }
33106 #endif
33107
33108
33109 #ifdef __cplusplus
33110 extern "C" {
33111 #endif
33112
33113 /* Python-specific SWIG API */
33114 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33115 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33116 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33117
33118 /* -----------------------------------------------------------------------------
33119 * global variable support code.
33120 * ----------------------------------------------------------------------------- */
33121
33122 typedef struct swig_globalvar {
33123 char *name; /* Name of global variable */
33124 PyObject *(*get_attr)(); /* Return the current value */
33125 int (*set_attr)(PyObject *); /* Set the value */
33126 struct swig_globalvar *next;
33127 } swig_globalvar;
33128
33129 typedef struct swig_varlinkobject {
33130 PyObject_HEAD
33131 swig_globalvar *vars;
33132 } swig_varlinkobject;
33133
33134 static PyObject *
33135 swig_varlink_repr(swig_varlinkobject *v) {
33136 v = v;
33137 return PyString_FromString("<Swig global variables>");
33138 }
33139
33140 static int
33141 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33142 swig_globalvar *var;
33143 flags = flags;
33144 fprintf(fp,"Swig global variables { ");
33145 for (var = v->vars; var; var=var->next) {
33146 fprintf(fp,"%s", var->name);
33147 if (var->next) fprintf(fp,", ");
33148 }
33149 fprintf(fp," }\n");
33150 return 0;
33151 }
33152
33153 static PyObject *
33154 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33155 swig_globalvar *var = v->vars;
33156 while (var) {
33157 if (strcmp(var->name,n) == 0) {
33158 return (*var->get_attr)();
33159 }
33160 var = var->next;
33161 }
33162 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33163 return NULL;
33164 }
33165
33166 static int
33167 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33168 swig_globalvar *var = v->vars;
33169 while (var) {
33170 if (strcmp(var->name,n) == 0) {
33171 return (*var->set_attr)(p);
33172 }
33173 var = var->next;
33174 }
33175 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33176 return 1;
33177 }
33178
33179 static PyTypeObject varlinktype = {
33180 PyObject_HEAD_INIT(0)
33181 0, /* Number of items in variable part (ob_size) */
33182 (char *)"swigvarlink", /* Type name (tp_name) */
33183 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33184 0, /* Itemsize (tp_itemsize) */
33185 0, /* Deallocator (tp_dealloc) */
33186 (printfunc) swig_varlink_print, /* Print (tp_print) */
33187 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33188 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33189 0, /* tp_compare */
33190 (reprfunc) swig_varlink_repr, /* tp_repr */
33191 0, /* tp_as_number */
33192 0, /* tp_as_sequence */
33193 0, /* tp_as_mapping */
33194 0, /* tp_hash */
33195 0, /* tp_call */
33196 0, /* tp_str */
33197 0, /* tp_getattro */
33198 0, /* tp_setattro */
33199 0, /* tp_as_buffer */
33200 0, /* tp_flags */
33201 0, /* tp_doc */
33202 #if PY_VERSION_HEX >= 0x02000000
33203 0, /* tp_traverse */
33204 0, /* tp_clear */
33205 #endif
33206 #if PY_VERSION_HEX >= 0x02010000
33207 0, /* tp_richcompare */
33208 0, /* tp_weaklistoffset */
33209 #endif
33210 #if PY_VERSION_HEX >= 0x02020000
33211 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33212 #endif
33213 #if PY_VERSION_HEX >= 0x02030000
33214 0, /* tp_del */
33215 #endif
33216 #ifdef COUNT_ALLOCS
33217 0,0,0,0 /* tp_alloc -> tp_next */
33218 #endif
33219 };
33220
33221 /* Create a variable linking object for use later */
33222 static PyObject *
33223 SWIG_Python_newvarlink(void) {
33224 swig_varlinkobject *result = 0;
33225 result = PyMem_NEW(swig_varlinkobject,1);
33226 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33227 result->ob_type = &varlinktype;
33228 result->vars = 0;
33229 result->ob_refcnt = 0;
33230 Py_XINCREF((PyObject *) result);
33231 return ((PyObject*) result);
33232 }
33233
33234 static void
33235 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33236 swig_varlinkobject *v;
33237 swig_globalvar *gv;
33238 v= (swig_varlinkobject *) p;
33239 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33240 gv->name = (char *) malloc(strlen(name)+1);
33241 strcpy(gv->name,name);
33242 gv->get_attr = get_attr;
33243 gv->set_attr = set_attr;
33244 gv->next = v->vars;
33245 v->vars = gv;
33246 }
33247
33248 /* -----------------------------------------------------------------------------
33249 * constants/methods manipulation
33250 * ----------------------------------------------------------------------------- */
33251
33252 /* Install Constants */
33253 static void
33254 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33255 PyObject *obj = 0;
33256 size_t i;
33257 for (i = 0; constants[i].type; i++) {
33258 switch(constants[i].type) {
33259 case SWIG_PY_INT:
33260 obj = PyInt_FromLong(constants[i].lvalue);
33261 break;
33262 case SWIG_PY_FLOAT:
33263 obj = PyFloat_FromDouble(constants[i].dvalue);
33264 break;
33265 case SWIG_PY_STRING:
33266 if (constants[i].pvalue) {
33267 obj = PyString_FromString((char *) constants[i].pvalue);
33268 } else {
33269 Py_INCREF(Py_None);
33270 obj = Py_None;
33271 }
33272 break;
33273 case SWIG_PY_POINTER:
33274 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33275 break;
33276 case SWIG_PY_BINARY:
33277 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33278 break;
33279 default:
33280 obj = 0;
33281 break;
33282 }
33283 if (obj) {
33284 PyDict_SetItemString(d,constants[i].name,obj);
33285 Py_DECREF(obj);
33286 }
33287 }
33288 }
33289
33290 /* -----------------------------------------------------------------------------*/
33291 /* Fix SwigMethods to carry the callback ptrs when needed */
33292 /* -----------------------------------------------------------------------------*/
33293
33294 static void
33295 SWIG_Python_FixMethods(PyMethodDef *methods,
33296 swig_const_info *const_table,
33297 swig_type_info **types,
33298 swig_type_info **types_initial) {
33299 size_t i;
33300 for (i = 0; methods[i].ml_name; ++i) {
33301 char *c = methods[i].ml_doc;
33302 if (c && (c = strstr(c, "swig_ptr: "))) {
33303 int j;
33304 swig_const_info *ci = 0;
33305 char *name = c + 10;
33306 for (j = 0; const_table[j].type; j++) {
33307 if (strncmp(const_table[j].name, name,
33308 strlen(const_table[j].name)) == 0) {
33309 ci = &(const_table[j]);
33310 break;
33311 }
33312 }
33313 if (ci) {
33314 size_t shift = (ci->ptype) - types;
33315 swig_type_info *ty = types_initial[shift];
33316 size_t ldoc = (c - methods[i].ml_doc);
33317 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33318 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33319 char *buff = ndoc;
33320 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33321 strncpy(buff, methods[i].ml_doc, ldoc);
33322 buff += ldoc;
33323 strncpy(buff, "swig_ptr: ", 10);
33324 buff += 10;
33325 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33326 methods[i].ml_doc = ndoc;
33327 }
33328 }
33329 }
33330 }
33331
33332 /* -----------------------------------------------------------------------------*
33333 * Initialize type list
33334 * -----------------------------------------------------------------------------*/
33335
33336 #if PY_MAJOR_VERSION < 2
33337 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33338 is copied out of Python/modsupport.c in python version 2.3.4 */
33339 static int
33340 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33341 {
33342 PyObject *dict;
33343 if (!PyModule_Check(m)) {
33344 PyErr_SetString(PyExc_TypeError,
33345 "PyModule_AddObject() needs module as first arg");
33346 return -1;
33347 }
33348 if (!o) {
33349 PyErr_SetString(PyExc_TypeError,
33350 "PyModule_AddObject() needs non-NULL value");
33351 return -1;
33352 }
33353
33354 dict = PyModule_GetDict(m);
33355 if (dict == NULL) {
33356 /* Internal error -- modules must have a dict! */
33357 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33358 PyModule_GetName(m));
33359 return -1;
33360 }
33361 if (PyDict_SetItemString(dict, name, o))
33362 return -1;
33363 Py_DECREF(o);
33364 return 0;
33365 }
33366 #endif
33367
33368 static swig_type_info **
33369 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33370 static PyMethodDef swig_empty_runtime_method_table[] = {
33371 {
33372 NULL, NULL, 0, NULL
33373 }
33374 };/* Sentinel */
33375
33376 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33377 swig_empty_runtime_method_table);
33378 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33379 if (pointer && module) {
33380 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33381 }
33382 return type_list_handle;
33383 }
33384
33385 static swig_type_info **
33386 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33387 swig_type_info **type_pointer;
33388
33389 /* first check if module already created */
33390 type_pointer = SWIG_Python_GetTypeListHandle();
33391 if (type_pointer) {
33392 return type_pointer;
33393 } else {
33394 /* create a new module and variable */
33395 return SWIG_Python_SetTypeListHandle(type_list_handle);
33396 }
33397 }
33398
33399 #ifdef __cplusplus
33400 }
33401 #endif
33402
33403 /* -----------------------------------------------------------------------------*
33404 * Partial Init method
33405 * -----------------------------------------------------------------------------*/
33406
33407 #ifdef SWIG_LINK_RUNTIME
33408 #ifdef __cplusplus
33409 extern "C"
33410 #endif
33411 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33412 #endif
33413
33414 #ifdef __cplusplus
33415 extern "C"
33416 #endif
33417 SWIGEXPORT(void) SWIG_init(void) {
33418 static PyObject *SWIG_globals = 0;
33419 static int typeinit = 0;
33420 PyObject *m, *d;
33421 int i;
33422 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33423
33424 /* Fix SwigMethods to carry the callback ptrs when needed */
33425 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33426
33427 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33428 d = PyModule_GetDict(m);
33429
33430 if (!typeinit) {
33431 #ifdef SWIG_LINK_RUNTIME
33432 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33433 #else
33434 # ifndef SWIG_STATIC_RUNTIME
33435 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33436 # endif
33437 #endif
33438 for (i = 0; swig_types_initial[i]; i++) {
33439 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33440 }
33441 typeinit = 1;
33442 }
33443 SWIG_InstallConstants(d,swig_const_table);
33444
33445 {
33446 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33447 }
33448 {
33449 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33450 }
33451 {
33452 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33453 }
33454 {
33455 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33492 }
33493 {
33494 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33495 }
33496 {
33497 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33498 }
33499 {
33500 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33546 }
33547 {
33548 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33630 }
33631 {
33632 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33633 }
33634 {
33635 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33636 }
33637 {
33638 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33717 }
33718 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33719 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33720 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33721 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33722 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33723 {
33724 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33734 }
33735 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33736
33737 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33738
33739 {
33740 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33759 }
33760 {
33761 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33762 }
33763 {
33764 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33765 }
33766 {
33767 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33768 }
33769 {
33770 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33771 }
33772 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33773 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33774 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33775 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33776 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33777 {
33778 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33869 }
33870 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33871 {
33872 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33885 }
33886
33887 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33888
33889 {
33890 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33909 }
33910 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33911 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33912 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33913 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33914 {
33915 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33937 }
33938 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33939 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33940 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33941 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33942 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33943 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33944 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33945 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33946 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33947 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33948 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33949 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33950 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33951 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33952 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33953 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33954 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33955 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33956 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33957 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33958 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33959 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33960 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33961 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33962 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33963 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33964 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33965 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33966 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33967 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33968 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33969 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33970 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33971 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33972 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33973 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33974 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33975 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33976 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33977 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33978 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33979 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33980 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33981 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33982 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33983 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33984 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33985 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33986 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33987 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33988 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33989 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
33990 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33991 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33992 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33993 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33994 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33995
33996 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33997
33998 {
33999 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
34024 }
34025 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
34026 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
34027 {
34028 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34266 }
34267 {
34268 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34284 }
34285 {
34286 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34287 }
34288 {
34289 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34290 }
34291 {
34292 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34293 }
34294 {
34295 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34296 }
34297 {
34298 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34299 }
34300 {
34301 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34302 }
34303 {
34304 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34305 }
34306 {
34307 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34308 }
34309 {
34310 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34326 }
34327 {
34328 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34329 }
34330 {
34331 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34332 }
34333 {
34334 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34335 }
34336 {
34337 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34338 }
34339 {
34340 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34341 }
34342 {
34343 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34344 }
34345 {
34346 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34347 }
34348 {
34349 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34350 }
34351 {
34352 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34353 }
34354 {
34355 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34356 }
34357 {
34358 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34359 }
34360 {
34361 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34362 }
34363 {
34364 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34365 }
34366 {
34367 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34368 }
34369 {
34370 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34371 }
34372 {
34373 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34374 }
34375 {
34376 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34377 }
34378 {
34379 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34380 }
34381 {
34382 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34383 }
34384 {
34385 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34386 }
34387 {
34388 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34389 }
34390 {
34391 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34392 }
34393 {
34394 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34395 }
34396 {
34397 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34398 }
34399 {
34400 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34401 }
34402 {
34403 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34404 }
34405 {
34406 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34407 }
34408 {
34409 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34410 }
34411 {
34412 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34413 }
34414 {
34415 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34416 }
34417 {
34418 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34419 }
34420 {
34421 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34422 }
34423 {
34424 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34425 }
34426 {
34427 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34428 }
34429 {
34430 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34431 }
34432 {
34433 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34434 }
34435 {
34436 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34437 }
34438 {
34439 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34440 }
34441 {
34442 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34443 }
34444 {
34445 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34446 }
34447 {
34448 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34449 }
34450 {
34451 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34452 }
34453 {
34454 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34455 }
34456 {
34457 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34458 }
34459 {
34460 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34461 }
34462 {
34463 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34464 }
34465 {
34466 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34467 }
34468 {
34469 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34470 }
34471 {
34472 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34473 }
34474 {
34475 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34476 }
34477 {
34478 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34479 }
34480 {
34481 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34482 }
34483 {
34484 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34485 }
34486 {
34487 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34488 }
34489 {
34490 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34491 }
34492 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34493 {
34494 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34495 }
34496 {
34497 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34498 }
34499 {
34500 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34501 }
34502 {
34503 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34504 }
34505 {
34506 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34507 }
34508 {
34509 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34510 }
34511 {
34512 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34513 }
34514 {
34515 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34516 }
34517 {
34518 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34519 }
34520 {
34521 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34522 }
34523 {
34524 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34525 }
34526 {
34527 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34528 }
34529 {
34530 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34531 }
34532 {
34533 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34534 }
34535 {
34536 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34537 }
34538 {
34539 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34540 }
34541 {
34542 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34543 }
34544 {
34545 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34546 }
34547 {
34548 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34549 }
34550 {
34551 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34552 }
34553 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34554 {
34555 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34556 }
34557 {
34558 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34559 }
34560 {
34561 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34562 }
34563 {
34564 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34565 }
34566 {
34567 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34568 }
34569 {
34570 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34571 }
34572 {
34573 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34574 }
34575 {
34576 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34577 }
34578 {
34579 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34580 }
34581 {
34582 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34583 }
34584 {
34585 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34586 }
34587 {
34588 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34589 }
34590
34591 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34592 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34593 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34594 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34595
34596 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34597 }
34598
wxWidgets (Impactor)