]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxCheckListBox doesn't require wxUSE_OWNER_DRAWN when using WXUNIVERSAL
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLogChain swig_types[0]
1343 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1344 #define SWIGTYPE_p_wxMetafile swig_types[2]
1345 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1346 #define SWIGTYPE_p_wxLog swig_types[4]
1347 #define SWIGTYPE_p_wxMenu swig_types[5]
1348 #define SWIGTYPE_p_wxEvent swig_types[6]
1349 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1350 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1351 #define SWIGTYPE_p_wxDisplay swig_types[9]
1352 #define SWIGTYPE_p_wxFileType swig_types[10]
1353 #define SWIGTYPE_p_wxLogGui swig_types[11]
1354 #define SWIGTYPE_p_wxFont swig_types[12]
1355 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1356 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1357 #define SWIGTYPE_p_wxCaret swig_types[15]
1358 #define SWIGTYPE_ptrdiff_t swig_types[16]
1359 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1360 #define SWIGTYPE_p_void swig_types[18]
1361 #define SWIGTYPE_p_int swig_types[19]
1362 #define SWIGTYPE_p_wxSize swig_types[20]
1363 #define SWIGTYPE_p_wxClipboard swig_types[21]
1364 #define SWIGTYPE_p_wxStopWatch swig_types[22]
1365 #define SWIGTYPE_p_wxDC swig_types[23]
1366 #define SWIGTYPE_p_wxClipboardLocker swig_types[24]
1367 #define SWIGTYPE_p_wxIcon swig_types[25]
1368 #define SWIGTYPE_p_wxLogStderr swig_types[26]
1369 #define SWIGTYPE_p_wxLogTextCtrl swig_types[27]
1370 #define SWIGTYPE_p_wxTextCtrl swig_types[28]
1371 #define SWIGTYPE_p_wxBusyCursor swig_types[29]
1372 #define SWIGTYPE_p_wxBitmapDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxTextDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxPyTextDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxFileDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxCustomDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxURLDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxMetafileDataObject swig_types[38]
1381 #define SWIGTYPE_p_wxSound swig_types[39]
1382 #define SWIGTYPE_p_wxTimerRunner swig_types[40]
1383 #define SWIGTYPE_p_wxLogWindow swig_types[41]
1384 #define SWIGTYPE_p_wxTimeSpan swig_types[42]
1385 #define SWIGTYPE_p_wxArrayString swig_types[43]
1386 #define SWIGTYPE_p_wxWindowDisabler swig_types[44]
1387 #define SWIGTYPE_p_form_ops_t swig_types[45]
1388 #define SWIGTYPE_p_wxToolTip swig_types[46]
1389 #define SWIGTYPE_p_wxDataObjectComposite swig_types[47]
1390 #define SWIGTYPE_p_wxSystemSettings swig_types[48]
1391 #define SWIGTYPE_p_wxFileConfig swig_types[49]
1392 #define SWIGTYPE_p_wxVideoMode swig_types[50]
1393 #define SWIGTYPE_p_wxDataObjectSimple swig_types[51]
1394 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[52]
1395 #define SWIGTYPE_p_wxDuplexMode swig_types[53]
1396 #define SWIGTYPE_p_wxEvtHandler swig_types[54]
1397 #define SWIGTYPE_p_wxRect swig_types[55]
1398 #define SWIGTYPE_p_char swig_types[56]
1399 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[57]
1400 #define SWIGTYPE_p_wxStandardPaths swig_types[58]
1401 #define SWIGTYPE_p_wxFileTypeInfo swig_types[59]
1402 #define SWIGTYPE_p_wxFrame swig_types[60]
1403 #define SWIGTYPE_p_wxTimer swig_types[61]
1404 #define SWIGTYPE_p_wxPaperSize swig_types[62]
1405 #define SWIGTYPE_p_wxMimeTypesManager swig_types[63]
1406 #define SWIGTYPE_p_wxPyArtProvider 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_wxPoint swig_types[69]
1412 #define SWIGTYPE_p_wxJoystickEvent swig_types[70]
1413 #define SWIGTYPE_p_wxCursor swig_types[71]
1414 #define SWIGTYPE_p_wxObject swig_types[72]
1415 #define SWIGTYPE_p_wxOutputStream swig_types[73]
1416 #define SWIGTYPE_p_wxDateTime swig_types[74]
1417 #define SWIGTYPE_p_wxPyDropSource swig_types[75]
1418 #define SWIGTYPE_p_unsigned_long swig_types[76]
1419 #define SWIGTYPE_p_wxKillError swig_types[77]
1420 #define SWIGTYPE_p_wxWindow swig_types[78]
1421 #define SWIGTYPE_p_wxString swig_types[79]
1422 #define SWIGTYPE_p_wxPyProcess swig_types[80]
1423 #define SWIGTYPE_p_wxBitmap swig_types[81]
1424 #define SWIGTYPE_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_unsigned_int swig_types[83]
1426 #define SWIGTYPE_p_wxConfig swig_types[84]
1427 #define SWIGTYPE_p_unsigned_char swig_types[85]
1428 #define SWIGTYPE_p_wxChar swig_types[86]
1429 #define SWIGTYPE_p_wxBusyInfo swig_types[87]
1430 #define SWIGTYPE_p_wxPyDropTarget swig_types[88]
1431 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[90]
1433 #define SWIGTYPE_p_wxProcessEvent swig_types[91]
1434 #define SWIGTYPE_p_wxPyLog swig_types[92]
1435 #define SWIGTYPE_p_wxLogNull swig_types[93]
1436 #define SWIGTYPE_p_wxColour swig_types[94]
1437 #define SWIGTYPE_p_wxPyTimer swig_types[95]
1438 #define SWIGTYPE_p_wxConfigPathChanger swig_types[96]
1439 #define SWIGTYPE_p_wxDateSpan swig_types[97]
1440 static swig_type_info *swig_types[99];
1441
1442 /* -------- TYPES TABLE (END) -------- */
1443
1444
1445 /*-----------------------------------------------
1446 @(target):= _misc_.so
1447 ------------------------------------------------*/
1448 #define SWIG_init init_misc_
1449
1450 #define SWIG_name "_misc_"
1451
1452 #include "wx/wxPython/wxPython.h"
1453 #include "wx/wxPython/pyclasses.h"
1454 #include "wx/wxPython/pyistream.h"
1455
1456 static const wxString wxPyEmptyString(wxEmptyString);
1457
1458
1459
1460 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1461 #define SWIG_From_int PyInt_FromLong
1462 /*@@*/
1463
1464
1465 #include <limits.h>
1466
1467
1468 SWIGINTERN int
1469 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1470 const char *errmsg)
1471 {
1472 if (value < min_value) {
1473 if (errmsg) {
1474 PyErr_Format(PyExc_OverflowError,
1475 "value %ld is less than '%s' minimum %ld",
1476 value, errmsg, min_value);
1477 }
1478 return 0;
1479 } else if (value > max_value) {
1480 if (errmsg) {
1481 PyErr_Format(PyExc_OverflowError,
1482 "value %ld is greater than '%s' maximum %ld",
1483 value, errmsg, max_value);
1484 }
1485 return 0;
1486 }
1487 return 1;
1488 }
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_long(PyObject* obj, long* val)
1493 {
1494 if (PyNumber_Check(obj)) {
1495 if (val) *val = PyInt_AsLong(obj);
1496 return 1;
1497 }
1498 else {
1499 SWIG_type_error("number", obj);
1500 }
1501 return 0;
1502 }
1503
1504
1505 #if INT_MAX != LONG_MAX
1506 SWIGINTERN int
1507 SWIG_AsVal_int(PyObject *obj, int *val)
1508 {
1509 const char* errmsg = val ? "int" : (char*)0;
1510 long v;
1511 if (SWIG_AsVal_long(obj, &v)) {
1512 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1513 if (val) *val = (int)(v);
1514 return 1;
1515 } else {
1516 return 0;
1517 }
1518 } else {
1519 PyErr_Clear();
1520 }
1521 if (val) {
1522 SWIG_type_error(errmsg, obj);
1523 }
1524 return 0;
1525 }
1526 #else
1527 SWIGINTERNSHORT int
1528 SWIG_AsVal_int(PyObject *obj, int *val)
1529 {
1530 return SWIG_AsVal_long(obj,(long*)val);
1531 }
1532 #endif
1533
1534
1535 SWIGINTERNSHORT int
1536 SWIG_As_int(PyObject* obj)
1537 {
1538 int v;
1539 if (!SWIG_AsVal_int(obj, &v)) {
1540 /*
1541 this is needed to make valgrind/purify happier.
1542 */
1543 memset((void*)&v, 0, sizeof(int));
1544 }
1545 return v;
1546 }
1547
1548
1549 SWIGINTERNSHORT int
1550 SWIG_Check_int(PyObject* obj)
1551 {
1552 return SWIG_AsVal_int(obj, (int*)0);
1553 }
1554
1555 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1556
1557 #include <wx/stockitem.h>
1558
1559 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1560 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1561 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1562
1563 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1564 #define SWIG_From_long PyInt_FromLong
1565 /*@@*/
1566
1567
1568 SWIGINTERNSHORT long
1569 SWIG_As_long(PyObject* obj)
1570 {
1571 long v;
1572 if (!SWIG_AsVal_long(obj, &v)) {
1573 /*
1574 this is needed to make valgrind/purify happier.
1575 */
1576 memset((void*)&v, 0, sizeof(long));
1577 }
1578 return v;
1579 }
1580
1581
1582 SWIGINTERNSHORT int
1583 SWIG_Check_long(PyObject* obj)
1584 {
1585 return SWIG_AsVal_long(obj, (long*)0);
1586 }
1587
1588
1589 SWIGINTERN int
1590 SWIG_AsVal_bool(PyObject *obj, bool *val)
1591 {
1592 if (obj == Py_True) {
1593 if (val) *val = true;
1594 return 1;
1595 }
1596 if (obj == Py_False) {
1597 if (val) *val = false;
1598 return 1;
1599 }
1600 int res = 0;
1601 if (SWIG_AsVal_int(obj, &res)) {
1602 if (val) *val = res ? true : false;
1603 return 1;
1604 } else {
1605 PyErr_Clear();
1606 }
1607 if (val) {
1608 SWIG_type_error("bool", obj);
1609 }
1610 return 0;
1611 }
1612
1613
1614 SWIGINTERNSHORT bool
1615 SWIG_As_bool(PyObject* obj)
1616 {
1617 bool v;
1618 if (!SWIG_AsVal_bool(obj, &v)) {
1619 /*
1620 this is needed to make valgrind/purify happier.
1621 */
1622 memset((void*)&v, 0, sizeof(bool));
1623 }
1624 return v;
1625 }
1626
1627
1628 SWIGINTERNSHORT int
1629 SWIG_Check_bool(PyObject* obj)
1630 {
1631 return SWIG_AsVal_bool(obj, (bool*)0);
1632 }
1633
1634
1635 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1636 PyObject* o2;
1637 PyObject* o3;
1638
1639 if (!target) {
1640 target = o;
1641 } else if (target == Py_None) {
1642 Py_DECREF(Py_None);
1643 target = o;
1644 } else {
1645 if (!PyTuple_Check(target)) {
1646 o2 = target;
1647 target = PyTuple_New(1);
1648 PyTuple_SetItem(target, 0, o2);
1649 }
1650 o3 = PyTuple_New(1);
1651 PyTuple_SetItem(o3, 0, o);
1652
1653 o2 = target;
1654 target = PySequence_Concat(o2, o3);
1655 Py_DECREF(o2);
1656 Py_DECREF(o3);
1657 }
1658 return target;
1659 }
1660
1661
1662
1663 SWIGINTERN int
1664 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1665 {
1666 long v = 0;
1667 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1668 SWIG_type_error("unsigned number", obj);
1669 }
1670 else if (val)
1671 *val = (unsigned long)v;
1672 return 1;
1673 }
1674
1675
1676 SWIGINTERNSHORT unsigned long
1677 SWIG_As_unsigned_SS_long(PyObject* obj)
1678 {
1679 unsigned long v;
1680 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1681 /*
1682 this is needed to make valgrind/purify happier.
1683 */
1684 memset((void*)&v, 0, sizeof(unsigned long));
1685 }
1686 return v;
1687 }
1688
1689
1690 SWIGINTERNSHORT int
1691 SWIG_Check_unsigned_SS_long(PyObject* obj)
1692 {
1693 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1694 }
1695
1696
1697 SWIGINTERNSHORT PyObject*
1698 SWIG_From_unsigned_SS_long(unsigned long value)
1699 {
1700 return (value > LONG_MAX) ?
1701 PyLong_FromUnsignedLong(value)
1702 : PyInt_FromLong((long)(value));
1703 }
1704
1705
1706 void* wxGetXDisplay()
1707 {
1708 #ifdef __WXGTK__
1709 return wxGetDisplay();
1710 #else
1711 return NULL;
1712 #endif
1713 }
1714
1715
1716 bool wxThread_IsMain() {
1717 #ifdef WXP_WITH_THREAD
1718 return wxThread::IsMain();
1719 #else
1720 return true;
1721 #endif
1722 }
1723
1724 static void wxCaret_Destroy(wxCaret *self){
1725 delete self;
1726 }
1727
1728 #include <wx/snglinst.h>
1729
1730
1731 #ifdef __WXMSW__
1732 #include <wx/msw/private.h>
1733 #include <wx/dynload.h>
1734 #endif
1735
1736
1737
1738 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1739 #if 0
1740 , int method
1741 #endif
1742 )
1743 {
1744 #ifdef __WXMSW__
1745 #if 0
1746 switch (method)
1747 {
1748 case 1:
1749 // This one only partially works. Appears to be an undocumented
1750 // "standard" convention that not all widgets adhear to. For
1751 // example, for some widgets backgrounds or non-client areas may
1752 // not be painted.
1753 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1754 break;
1755
1756 case 2:
1757 #endif
1758 // This one works much better, nearly all widgets and their
1759 // children are captured correctly[**]. Prior to the big
1760 // background erase changes that Vadim did in 2004-2005 this
1761 // method failed badly on XP with Themes activated, most native
1762 // widgets draw only partially, if at all. Without themes it
1763 // worked just like on Win2k. After those changes this method
1764 // works very well.
1765 //
1766 // ** For example the radio buttons in a wxRadioBox are not its
1767 // children by default, but you can capture it via the panel
1768 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1769 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1770 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1771 PRF_ERASEBKGND | PRF_OWNED );
1772 return true;
1773 #if 0
1774 break;
1775
1776 case 3:
1777 // This one is only defined in the latest SDK and is only
1778 // available on XP. MSDN says it is similar to sending WM_PRINT
1779 // so I expect that it will work similar to the above. Since it
1780 // is avaialble only on XP, it can't be compiled like this and
1781 // will have to be loaded dynamically.
1782 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1783
1784 // fall through
1785
1786 case 4:
1787 // Use PrintWindow if available, or fallback to WM_PRINT
1788 // otherwise. Unfortunately using PrintWindow is even worse than
1789 // WM_PRINT. For most native widgets nothing is drawn to the dc
1790 // at all, with or without Themes.
1791 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1792 static bool s_triedToLoad = false;
1793 static PrintWindow_t pfnPrintWindow = NULL;
1794 if ( !s_triedToLoad )
1795 {
1796
1797 s_triedToLoad = true;
1798 wxDynamicLibrary dllUser32(_T("user32.dll"));
1799 if ( dllUser32.IsLoaded() )
1800 {
1801 wxLogNull nolog; // Don't report errors here
1802 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1803 }
1804 }
1805 if (pfnPrintWindow)
1806 {
1807 //printf("Using PrintWindow\n");
1808 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1809 }
1810 else
1811 {
1812 //printf("Using WM_PRINT\n");
1813 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1814 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1815 PRF_ERASEBKGND | PRF_OWNED );
1816 }
1817 }
1818 #endif // 0
1819 #else
1820 return false;
1821 #endif // __WXMSW__
1822 }
1823
1824
1825
1826 #include <wx/tipdlg.h>
1827
1828
1829 class wxPyTipProvider : public wxTipProvider {
1830 public:
1831 wxPyTipProvider(size_t currentTip)
1832 : wxTipProvider(currentTip) {}
1833
1834 DEC_PYCALLBACK_STRING__pure(GetTip);
1835 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1836 PYPRIVATE;
1837 };
1838
1839 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1840 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1841
1842
1843 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1844
1845 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1846
1847 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1848 : wxTimer(owner, id)
1849 {
1850 if (owner == NULL) SetOwner(this);
1851 }
1852
1853
1854 void wxPyTimer::Notify() {
1855 bool found;
1856 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1857 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1858 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1859 wxPyEndBlockThreads(blocked);
1860 if (! found)
1861 wxTimer::Notify();
1862 }
1863 void wxPyTimer::base_Notify() {
1864 wxTimer::Notify();
1865 }
1866
1867
1868
1869 SWIGINTERN PyObject *
1870 SWIG_FromCharPtr(const char* cptr)
1871 {
1872 if (cptr) {
1873 size_t size = strlen(cptr);
1874 if (size > INT_MAX) {
1875 return SWIG_NewPointerObj((char*)(cptr),
1876 SWIG_TypeQuery("char *"), 0);
1877 } else {
1878 if (size != 0) {
1879 return PyString_FromStringAndSize(cptr, size);
1880 } else {
1881 return PyString_FromString(cptr);
1882 }
1883 }
1884 }
1885 Py_INCREF(Py_None);
1886 return Py_None;
1887 }
1888
1889
1890 SWIGINTERNSHORT int
1891 SWIG_CheckUnsignedLongInRange(unsigned long value,
1892 unsigned long max_value,
1893 const char *errmsg)
1894 {
1895 if (value > max_value) {
1896 if (errmsg) {
1897 PyErr_Format(PyExc_OverflowError,
1898 "value %lu is greater than '%s' minimum %lu",
1899 value, errmsg, max_value);
1900 }
1901 return 0;
1902 }
1903 return 1;
1904 }
1905
1906
1907 #if UINT_MAX != ULONG_MAX
1908 SWIGINTERN int
1909 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1910 {
1911 const char* errmsg = val ? "unsigned int" : (char*)0;
1912 unsigned long v;
1913 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1914 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1915 if (val) *val = (unsigned int)(v);
1916 return 1;
1917 }
1918 } else {
1919 PyErr_Clear();
1920 }
1921 if (val) {
1922 SWIG_type_error(errmsg, obj);
1923 }
1924 return 0;
1925 }
1926 #else
1927 SWIGINTERNSHORT unsigned int
1928 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1929 {
1930 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1931 }
1932 #endif
1933
1934
1935 SWIGINTERNSHORT unsigned int
1936 SWIG_As_unsigned_SS_int(PyObject* obj)
1937 {
1938 unsigned int v;
1939 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1940 /*
1941 this is needed to make valgrind/purify happier.
1942 */
1943 memset((void*)&v, 0, sizeof(unsigned int));
1944 }
1945 return v;
1946 }
1947
1948
1949 SWIGINTERNSHORT int
1950 SWIG_Check_unsigned_SS_int(PyObject* obj)
1951 {
1952 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1953 }
1954
1955 static wxString Log_TimeStamp(){
1956 wxString msg;
1957 wxLog::TimeStamp(&msg);
1958 return msg;
1959 }
1960 static void wxLog_Destroy(wxLog *self){ delete self; }
1961 // Make somce wrappers that double any % signs so they are 'escaped'
1962 void wxPyLogFatalError(const wxString& msg)
1963 {
1964 wxString m(msg);
1965 m.Replace(wxT("%"), wxT("%%"));
1966 wxLogFatalError(m);
1967 }
1968
1969 void wxPyLogError(const wxString& msg)
1970 {
1971 wxString m(msg);
1972 m.Replace(wxT("%"), wxT("%%"));
1973 wxLogError(m);
1974 }
1975
1976 void wxPyLogWarning(const wxString& msg)
1977 {
1978 wxString m(msg);
1979 m.Replace(wxT("%"), wxT("%%"));
1980 wxLogWarning(m);
1981 }
1982
1983 void wxPyLogMessage(const wxString& msg)
1984 {
1985 wxString m(msg);
1986 m.Replace(wxT("%"), wxT("%%"));
1987 wxLogMessage(m);
1988 }
1989
1990 void wxPyLogInfo(const wxString& msg)
1991 {
1992 wxString m(msg);
1993 m.Replace(wxT("%"), wxT("%%"));
1994 wxLogInfo(m);
1995 }
1996
1997 void wxPyLogDebug(const wxString& msg)
1998 {
1999 wxString m(msg);
2000 m.Replace(wxT("%"), wxT("%%"));
2001 wxLogDebug(m);
2002 }
2003
2004 void wxPyLogVerbose(const wxString& msg)
2005 {
2006 wxString m(msg);
2007 m.Replace(wxT("%"), wxT("%%"));
2008 wxLogVerbose(m);
2009 }
2010
2011 void wxPyLogStatus(const wxString& msg)
2012 {
2013 wxString m(msg);
2014 m.Replace(wxT("%"), wxT("%%"));
2015 wxLogStatus(m);
2016 }
2017
2018 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2019 {
2020 wxString m(msg);
2021 m.Replace(wxT("%"), wxT("%%"));
2022 wxLogStatus(pFrame, m);
2023 }
2024
2025 void wxPyLogSysError(const wxString& msg)
2026 {
2027 wxString m(msg);
2028 m.Replace(wxT("%"), wxT("%%"));
2029 wxLogSysError(m);
2030 }
2031
2032 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2033 {
2034 wxString m(msg);
2035 m.Replace(wxT("%"), wxT("%%"));
2036 wxLogGeneric(level, m);
2037 }
2038
2039 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2040 {
2041 wxString m(msg);
2042 m.Replace(wxT("%"), wxT("%%"));
2043 wxLogTrace(mask, m);
2044 }
2045
2046 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2047 {
2048 wxString m(msg);
2049 m.Replace(wxT("%"), wxT("%%"));
2050 wxLogTrace(mask, m);
2051 }
2052
2053
2054
2055 // A wxLog class that can be derived from in wxPython
2056 class wxPyLog : public wxLog {
2057 public:
2058 wxPyLog() : wxLog() {}
2059
2060 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2061 bool found;
2062 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2063 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2064 PyObject* s = wx2PyString(szString);
2065 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2066 Py_DECREF(s);
2067 }
2068 wxPyEndBlockThreads(blocked);
2069 if (! found)
2070 wxLog::DoLog(level, szString, t);
2071 }
2072
2073 virtual void DoLogString(const wxChar *szString, time_t t) {
2074 bool found;
2075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2076 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2077 PyObject* s = wx2PyString(szString);
2078 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2079 Py_DECREF(s);
2080 }
2081 wxPyEndBlockThreads(blocked);
2082 if (! found)
2083 wxLog::DoLogString(szString, t);
2084 }
2085
2086 PYPRIVATE;
2087 };
2088
2089
2090
2091
2092 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2093
2094
2095 #include <wx/joystick.h>
2096
2097
2098 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2099 // A C++ stub class for wxJoystick for platforms that don't have it.
2100 class wxJoystick : public wxObject {
2101 public:
2102 wxJoystick(int joystick = wxJOYSTICK1) {
2103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2104 PyErr_SetString(PyExc_NotImplementedError,
2105 "wxJoystick is not available on this platform.");
2106 wxPyEndBlockThreads(blocked);
2107 }
2108 wxPoint GetPosition() { return wxPoint(-1,-1); }
2109 int GetZPosition() { return -1; }
2110 int GetButtonState() { return -1; }
2111 int GetPOVPosition() { return -1; }
2112 int GetPOVCTSPosition() { return -1; }
2113 int GetRudderPosition() { return -1; }
2114 int GetUPosition() { return -1; }
2115 int GetVPosition() { return -1; }
2116 int GetMovementThreshold() { return -1; }
2117 void SetMovementThreshold(int threshold) {}
2118
2119 bool IsOk(void) { return false; }
2120 int GetNumberJoysticks() { return -1; }
2121 int GetManufacturerId() { return -1; }
2122 int GetProductId() { return -1; }
2123 wxString GetProductName() { return wxEmptyString; }
2124 int GetXMin() { return -1; }
2125 int GetYMin() { return -1; }
2126 int GetZMin() { return -1; }
2127 int GetXMax() { return -1; }
2128 int GetYMax() { return -1; }
2129 int GetZMax() { return -1; }
2130 int GetNumberButtons() { return -1; }
2131 int GetNumberAxes() { return -1; }
2132 int GetMaxButtons() { return -1; }
2133 int GetMaxAxes() { return -1; }
2134 int GetPollingMin() { return -1; }
2135 int GetPollingMax() { return -1; }
2136 int GetRudderMin() { return -1; }
2137 int GetRudderMax() { return -1; }
2138 int GetUMin() { return -1; }
2139 int GetUMax() { return -1; }
2140 int GetVMin() { return -1; }
2141 int GetVMax() { return -1; }
2142
2143 bool HasRudder() { return false; }
2144 bool HasZ() { return false; }
2145 bool HasU() { return false; }
2146 bool HasV() { return false; }
2147 bool HasPOV() { return false; }
2148 bool HasPOV4Dir() { return false; }
2149 bool HasPOVCTS() { return false; }
2150
2151 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2152 bool ReleaseCapture() { return false; }
2153 };
2154 #endif
2155
2156
2157 #include <wx/sound.h>
2158
2159
2160 #if !wxUSE_SOUND
2161 // A C++ stub class for wxWave for platforms that don't have it.
2162 class wxSound : public wxObject
2163 {
2164 public:
2165 wxSound() {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171 wxSound(const wxString&/*, bool*/) {
2172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177 wxSound(int, const wxByte*) {
2178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2179 PyErr_SetString(PyExc_NotImplementedError,
2180 "wxSound is not available on this platform.");
2181 wxPyEndBlockThreads(blocked);
2182 }
2183
2184 ~wxSound() {};
2185
2186 bool Create(const wxString&/*, bool*/) { return false; }
2187 bool Create(int, const wxByte*) { return false; };
2188 bool IsOk() { return false; };
2189 bool Play(unsigned) const { return false; }
2190 static bool Play(const wxString&, unsigned) { return false; }
2191 static void Stop() {}
2192 };
2193
2194 #endif
2195
2196 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2197 if (fileName.Length() == 0)
2198 return new wxSound;
2199 else
2200 return new wxSound(fileName);
2201 }
2202 static wxSound *new_wxSound(PyObject *data){
2203 unsigned char* buffer; int size;
2204 wxSound *sound = NULL;
2205
2206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2207 if (!PyArg_Parse(data, "t#", &buffer, &size))
2208 goto done;
2209 sound = new wxSound(size, buffer);
2210 done:
2211 wxPyEndBlockThreads(blocked);
2212 return sound;
2213 }
2214 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2215 #ifndef __WXMAC__
2216 unsigned char* buffer;
2217 int size;
2218 bool rv = false;
2219
2220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2221 if (!PyArg_Parse(data, "t#", &buffer, &size))
2222 goto done;
2223 rv = self->Create(size, buffer);
2224 done:
2225 wxPyEndBlockThreads(blocked);
2226 return rv;
2227 #else
2228 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2229 PyErr_SetString(PyExc_NotImplementedError,
2230 "Create from data is not available on this platform.");
2231 wxPyEndBlockThreads(blocked);
2232 return false;
2233 #endif
2234 }
2235
2236 #include <wx/mimetype.h>
2237
2238 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2239 wxString str;
2240 if (self->GetMimeType(&str))
2241 return wx2PyString(str);
2242 else
2243 RETURN_NONE();
2244 }
2245 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2246 wxArrayString arr;
2247 if (self->GetMimeTypes(arr))
2248 return wxArrayString2PyList_helper(arr);
2249 else
2250 RETURN_NONE();
2251 }
2252 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2253 wxArrayString arr;
2254 if (self->GetExtensions(arr))
2255 return wxArrayString2PyList_helper(arr);
2256 else
2257 RETURN_NONE();
2258 }
2259 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2260 wxIconLocation loc;
2261 if (self->GetIcon(&loc))
2262 return new wxIcon(loc);
2263 else
2264 return NULL;
2265 }
2266 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2267 wxIconLocation loc;
2268 if (self->GetIcon(&loc)) {
2269 wxString iconFile = loc.GetFileName();
2270 int iconIndex = -1;
2271
2272
2273
2274 // Make a tuple and put the values in it
2275 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2276 PyObject* tuple = PyTuple_New(3);
2277 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2278 wxT("wxIcon"), true));
2279 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2280 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2281 wxPyEndBlockThreads(blocked);
2282 return tuple;
2283 }
2284 else
2285 RETURN_NONE();
2286 }
2287 static PyObject *wxFileType_GetDescription(wxFileType *self){
2288 wxString str;
2289 if (self->GetDescription(&str))
2290 return wx2PyString(str);
2291 else
2292 RETURN_NONE();
2293 }
2294 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2295 wxString str;
2296 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2297 return wx2PyString(str);
2298 else
2299 RETURN_NONE();
2300 }
2301 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2302 wxString str;
2303 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2304 return wx2PyString(str);
2305 else
2306 RETURN_NONE();
2307 }
2308 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2309 wxArrayString verbs;
2310 wxArrayString commands;
2311 if (self->GetAllCommands(&verbs, &commands,
2312 wxFileType::MessageParameters(filename, mimetype))) {
2313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2314 PyObject* tuple = PyTuple_New(2);
2315 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2316 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2317 wxPyEndBlockThreads(blocked);
2318 return tuple;
2319 }
2320 else
2321 RETURN_NONE();
2322 }
2323 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2324 return wxFileType::ExpandCommand(command,
2325 wxFileType::MessageParameters(filename, mimetype));
2326 }
2327 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2328 wxArrayString arr;
2329 self->EnumAllFileTypes(arr);
2330 return wxArrayString2PyList_helper(arr);
2331 }
2332
2333 #include <wx/artprov.h>
2334
2335 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2336 static const wxString wxPyART_MENU(wxART_MENU);
2337 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2338 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2339 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2340 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2341 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2342 static const wxString wxPyART_OTHER(wxART_OTHER);
2343 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2344 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2345 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2346 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2347 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2348 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2349 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2350 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2351 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2352 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2353 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2354 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2355 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2356 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2357 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2358 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2359 static const wxString wxPyART_PRINT(wxART_PRINT);
2360 static const wxString wxPyART_HELP(wxART_HELP);
2361 static const wxString wxPyART_TIP(wxART_TIP);
2362 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2363 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2364 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2365 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2366 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2367 static const wxString wxPyART_CDROM(wxART_CDROM);
2368 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2369 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2370 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2371 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2372 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2373 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2374 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2375 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2376 static const wxString wxPyART_ERROR(wxART_ERROR);
2377 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2378 static const wxString wxPyART_WARNING(wxART_WARNING);
2379 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2380 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2381 static const wxString wxPyART_COPY(wxART_COPY);
2382 static const wxString wxPyART_CUT(wxART_CUT);
2383 static const wxString wxPyART_PASTE(wxART_PASTE);
2384 static const wxString wxPyART_DELETE(wxART_DELETE);
2385 static const wxString wxPyART_UNDO(wxART_UNDO);
2386 static const wxString wxPyART_REDO(wxART_REDO);
2387 static const wxString wxPyART_QUIT(wxART_QUIT);
2388 static const wxString wxPyART_FIND(wxART_FIND);
2389 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2390 // Python aware wxArtProvider
2391 class wxPyArtProvider : public wxArtProvider {
2392 public:
2393
2394 virtual wxBitmap CreateBitmap(const wxArtID& id,
2395 const wxArtClient& client,
2396 const wxSize& size) {
2397 wxBitmap rval = wxNullBitmap;
2398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2399 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2400 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2401 PyObject* ro;
2402 wxBitmap* ptr;
2403 PyObject* s1, *s2;
2404 s1 = wx2PyString(id);
2405 s2 = wx2PyString(client);
2406 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2407 Py_DECREF(so);
2408 Py_DECREF(s1);
2409 Py_DECREF(s2);
2410 if (ro) {
2411 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2412 rval = *ptr;
2413 Py_DECREF(ro);
2414 }
2415 }
2416 wxPyEndBlockThreads(blocked);
2417 return rval;
2418 }
2419
2420 PYPRIVATE;
2421 };
2422
2423 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2424
2425
2426
2427 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2428 PyObject* ret = PyTuple_New(3);
2429 if (ret) {
2430 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2431 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2432 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2433 }
2434 return ret;
2435 }
2436
2437 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2438 bool cont;
2439 long index = 0;
2440 wxString value;
2441
2442 cont = self->GetFirstGroup(value, index);
2443 return __EnumerationHelper(cont, value, index);
2444 }
2445 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2446 bool cont;
2447 wxString value;
2448
2449 cont = self->GetNextGroup(value, index);
2450 return __EnumerationHelper(cont, value, index);
2451 }
2452 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2453 bool cont;
2454 long index = 0;
2455 wxString value;
2456
2457 cont = self->GetFirstEntry(value, index);
2458 return __EnumerationHelper(cont, value, index);
2459 }
2460 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2461 bool cont;
2462 wxString value;
2463
2464 cont = self->GetNextEntry(value, index);
2465 return __EnumerationHelper(cont, value, index);
2466 }
2467 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2468 long rv;
2469 self->Read(key, &rv, defaultVal);
2470 return rv;
2471 }
2472
2473 SWIGINTERN int
2474 SWIG_AsVal_double(PyObject *obj, double* val)
2475 {
2476 if (PyNumber_Check(obj)) {
2477 if (val) *val = PyFloat_AsDouble(obj);
2478 return 1;
2479 }
2480 else {
2481 SWIG_type_error("number", obj);
2482 }
2483 return 0;
2484 }
2485
2486
2487 SWIGINTERNSHORT double
2488 SWIG_As_double(PyObject* obj)
2489 {
2490 double v;
2491 if (!SWIG_AsVal_double(obj, &v)) {
2492 /*
2493 this is needed to make valgrind/purify happier.
2494 */
2495 memset((void*)&v, 0, sizeof(double));
2496 }
2497 return v;
2498 }
2499
2500
2501 SWIGINTERNSHORT int
2502 SWIG_Check_double(PyObject* obj)
2503 {
2504 return SWIG_AsVal_double(obj, (double*)0);
2505 }
2506
2507 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2508 double rv;
2509 self->Read(key, &rv, defaultVal);
2510 return rv;
2511 }
2512
2513 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2514 #define SWIG_From_double PyFloat_FromDouble
2515 /*@@*/
2516
2517 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2518 bool rv;
2519 self->Read(key, &rv, defaultVal);
2520 return rv;
2521 }
2522
2523 #include <wx/datetime.h>
2524
2525 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2526 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2527
2528 #define LOCAL_TZ wxDateTime::Local
2529
2530 static PyObject *DateTime_GetAmPmStrings(){
2531 wxString am;
2532 wxString pm;
2533 wxDateTime::GetAmPmStrings(&am, &pm);
2534 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2535 PyObject* tup = PyTuple_New(2);
2536 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2537 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2538 wxPyEndBlockThreads(blocked);
2539 return tup;
2540 }
2541
2542 #if UINT_MAX < LONG_MAX
2543 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2544 #define SWIG_From_unsigned_SS_int SWIG_From_long
2545 /*@@*/
2546 #else
2547 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2548 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2549 /*@@*/
2550 #endif
2551
2552 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2553 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2554 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2555 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2556 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2557 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2558 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2559 return (*self < *other);
2560 }
2561 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2562 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2563 return (*self <= *other);
2564 }
2565 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2566 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2567 return (*self > *other);
2568 }
2569 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2570 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2571 return (*self >= *other);
2572 }
2573 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2574 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2575 return (*self == *other);
2576 }
2577 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2578 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2579 return (*self != *other);
2580 }
2581 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2582 const wxChar* rv;
2583 const wxChar* _date = date;
2584 rv = self->ParseRfc822Date(_date);
2585 if (rv == NULL) return -1;
2586 return rv - _date;
2587 }
2588 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2589 const wxChar* rv;
2590 const wxChar* _date = date;
2591 rv = self->ParseFormat(_date, format, dateDef);
2592 if (rv == NULL) return -1;
2593 return rv - _date;
2594 }
2595 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2596 const wxChar* rv;
2597 const wxChar* _datetime = datetime;
2598 rv = self->ParseDateTime(_datetime);
2599 if (rv == NULL) return -1;
2600 return rv - _datetime;
2601 }
2602 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2603 const wxChar* rv;
2604 const wxChar* _date = date;
2605 rv = self->ParseDate(_date);
2606 if (rv == NULL) return -1;
2607 return rv - _date;
2608 }
2609 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2610 const wxChar* rv;
2611 const wxChar* _time = time;
2612 rv = self->ParseTime(_time);
2613 if (rv == NULL) return -1;
2614 return rv - _time;
2615 }
2616 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2617 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2618 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2619 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2620 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2621 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2622 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2623 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2624 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2625 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2626 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2627 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2628 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2629 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2630 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2631 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2632
2633 #include <wx/dataobj.h>
2634
2635 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2636 size_t count = self->GetFormatCount(dir);
2637 wxDataFormat* formats = new wxDataFormat[count];
2638 self->GetAllFormats(formats, dir);
2639
2640 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2641 PyObject* list = PyList_New(count);
2642 for (size_t i=0; i<count; i++) {
2643 wxDataFormat* format = new wxDataFormat(formats[i]);
2644 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2645 PyList_Append(list, obj);
2646 Py_DECREF(obj);
2647 }
2648 wxPyEndBlockThreads(blocked);
2649 delete [] formats;
2650 return list;
2651 }
2652 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2653 PyObject* rval = NULL;
2654 size_t size = self->GetDataSize(format);
2655 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2656 if (size) {
2657 char* buf = new char[size];
2658 if (self->GetDataHere(format, buf))
2659 rval = PyString_FromStringAndSize(buf, size);
2660 delete [] buf;
2661 }
2662 if (! rval) {
2663 rval = Py_None;
2664 Py_INCREF(rval);
2665 }
2666 wxPyEndBlockThreads(blocked);
2667 return rval;
2668 }
2669 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2670 bool rval;
2671 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2672 if (PyString_Check(data)) {
2673 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2674 }
2675 else {
2676 // raise a TypeError if not a string
2677 PyErr_SetString(PyExc_TypeError, "String expected.");
2678 rval = false;
2679 }
2680 wxPyEndBlockThreads(blocked);
2681 return rval;
2682 }
2683 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2684 PyObject* rval = NULL;
2685 size_t size = self->GetDataSize();
2686 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2687 if (size) {
2688 char* buf = new char[size];
2689 if (self->GetDataHere(buf))
2690 rval = PyString_FromStringAndSize(buf, size);
2691 delete [] buf;
2692 }
2693 if (! rval) {
2694 rval = Py_None;
2695 Py_INCREF(rval);
2696 }
2697 wxPyEndBlockThreads(blocked);
2698 return rval;
2699 }
2700 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2701 bool rval;
2702 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2703 if (PyString_Check(data)) {
2704 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2705 }
2706 else {
2707 // raise a TypeError if not a string
2708 PyErr_SetString(PyExc_TypeError, "String expected.");
2709 rval = false;
2710 }
2711 wxPyEndBlockThreads(blocked);
2712 return rval;
2713 }
2714 // Create a new class for wxPython to use
2715 class wxPyDataObjectSimple : public wxDataObjectSimple {
2716 public:
2717 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2718 : wxDataObjectSimple(format) {}
2719
2720 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2721 bool GetDataHere(void *buf) const;
2722 bool SetData(size_t len, const void *buf) const;
2723 PYPRIVATE;
2724 };
2725
2726 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2727
2728 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2729 // We need to get the data for this object and write it to buf. I think
2730 // the best way to do this for wxPython is to have the Python method
2731 // return either a string or None and then act appropriately with the
2732 // C++ version.
2733
2734 bool rval = false;
2735 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2736 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2737 PyObject* ro;
2738 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2739 if (ro) {
2740 rval = (ro != Py_None && PyString_Check(ro));
2741 if (rval)
2742 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2743 Py_DECREF(ro);
2744 }
2745 }
2746 wxPyEndBlockThreads(blocked);
2747 return rval;
2748 }
2749
2750 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2751 // For this one we simply need to make a string from buf and len
2752 // and send it to the Python method.
2753 bool rval = false;
2754 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2755 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2756 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2757 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2758 Py_DECREF(data);
2759 }
2760 wxPyEndBlockThreads(blocked);
2761 return rval;
2762 }
2763
2764 // Create a new class for wxPython to use
2765 class wxPyTextDataObject : public wxTextDataObject {
2766 public:
2767 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2768 : wxTextDataObject(text) {}
2769
2770 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2771 DEC_PYCALLBACK_STRING__const(GetText);
2772 DEC_PYCALLBACK__STRING(SetText);
2773 PYPRIVATE;
2774 };
2775
2776 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2777 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2778 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2779
2780
2781 // Create a new class for wxPython to use
2782 class wxPyBitmapDataObject : public wxBitmapDataObject {
2783 public:
2784 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2785 : wxBitmapDataObject(bitmap) {}
2786
2787 wxBitmap GetBitmap() const;
2788 void SetBitmap(const wxBitmap& bitmap);
2789 PYPRIVATE;
2790 };
2791
2792 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2793 wxBitmap* rval = &wxNullBitmap;
2794 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2795 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2796 PyObject* ro;
2797 wxBitmap* ptr;
2798 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2799 if (ro) {
2800 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2801 rval = ptr;
2802 Py_DECREF(ro);
2803 }
2804 }
2805 wxPyEndBlockThreads(blocked);
2806 return *rval;
2807 }
2808
2809 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2810 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2811 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2812 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2813 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2814 Py_DECREF(bo);
2815 }
2816 wxPyEndBlockThreads(blocked);
2817 }
2818
2819 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2820 return new wxCustomDataObject(wxDataFormat(formatName));
2821 }
2822 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2823 bool rval;
2824 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2825 if (PyString_Check(data)) {
2826 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2827 }
2828 else {
2829 // raise a TypeError if not a string
2830 PyErr_SetString(PyExc_TypeError, "String expected.");
2831 rval = false;
2832 }
2833 wxPyEndBlockThreads(blocked);
2834 return rval;
2835 }
2836 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2837 PyObject* obj;
2838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2839 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2840 wxPyEndBlockThreads(blocked);
2841 return obj;
2842 }
2843
2844 #include <wx/metafile.h>
2845
2846
2847 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2848
2849
2850 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2851 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2852 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2853 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2854 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2855
2856
2857 class wxPyTextDropTarget : public wxTextDropTarget {
2858 public:
2859 wxPyTextDropTarget() {}
2860
2861 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2862
2863 DEC_PYCALLBACK__(OnLeave);
2864 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2865 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2866 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2867 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2868
2869 PYPRIVATE;
2870 };
2871
2872 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2873 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2874 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2875 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2876 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2877 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2878
2879
2880
2881 class wxPyFileDropTarget : public wxFileDropTarget {
2882 public:
2883 wxPyFileDropTarget() {}
2884
2885 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2886
2887 DEC_PYCALLBACK__(OnLeave);
2888 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2889 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2890 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2891 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2892
2893 PYPRIVATE;
2894 };
2895
2896 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2897 const wxArrayString& filenames) {
2898 bool rval = false;
2899 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2900 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2901 PyObject* list = wxArrayString2PyList_helper(filenames);
2902 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2903 Py_DECREF(list);
2904 }
2905 wxPyEndBlockThreads(blocked);
2906 return rval;
2907 }
2908
2909
2910
2911 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2912 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2913 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2914 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2915 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2916
2917
2918
2919
2920 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2921
2922 #include <wx/display.h>
2923
2924 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2925 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2926
2927 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2928 #if !wxUSE_DISPLAY
2929 #include <wx/dynarray.h>
2930 #include <wx/vidmode.h>
2931
2932 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2933 #include "wx/arrimpl.cpp"
2934 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2935 const wxVideoMode wxDefaultVideoMode;
2936
2937 class wxDisplay
2938 {
2939 public:
2940 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2941 ~wxDisplay() {}
2942
2943 static size_t GetCount()
2944 { wxPyRaiseNotImplemented(); return 0; }
2945
2946 static int GetFromPoint(const wxPoint& pt)
2947 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2948 static int GetFromWindow(wxWindow *window)
2949 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2950
2951 virtual bool IsOk() const { return false; }
2952 virtual wxRect GetGeometry() const { wxRect r; return r; }
2953 virtual wxString GetName() const { return wxEmptyString; }
2954 bool IsPrimary() const { return false; }
2955
2956 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2957 { wxArrayVideoModes a; return a; }
2958
2959 virtual wxVideoMode GetCurrentMode() const
2960 { return wxDefaultVideoMode; }
2961
2962 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2963 { return false; }
2964
2965 void ResetMode() {}
2966 };
2967 #endif
2968
2969 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2970 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2971 PyObject* pyList = NULL;
2972 wxArrayVideoModes arr = self->GetModes(mode);
2973 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2974 pyList = PyList_New(0);
2975 for (int i=0; i < arr.GetCount(); i++) {
2976 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2977 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2978 PyList_Append(pyList, pyObj);
2979 Py_DECREF(pyObj);
2980 }
2981 wxPyEndBlockThreads(blocked);
2982 return pyList;
2983 }
2984
2985 #include <wx/stdpaths.h>
2986
2987 static wxStandardPaths *StandardPaths_Get(){
2988 return (wxStandardPaths*) &wxStandardPaths::Get();
2989 }
2990 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2991 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2992 #ifdef __cplusplus
2993 extern "C" {
2994 #endif
2995 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2996 PyObject *resultobj;
2997 wxSystemColour arg1 ;
2998 wxColour result;
2999 PyObject * obj0 = 0 ;
3000 char *kwnames[] = {
3001 (char *) "index", NULL
3002 };
3003
3004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3005 {
3006 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3007 if (SWIG_arg_fail(1)) SWIG_fail;
3008 }
3009 {
3010 if (!wxPyCheckForApp()) SWIG_fail;
3011 PyThreadState* __tstate = wxPyBeginAllowThreads();
3012 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3013
3014 wxPyEndAllowThreads(__tstate);
3015 if (PyErr_Occurred()) SWIG_fail;
3016 }
3017 {
3018 wxColour * resultptr;
3019 resultptr = new wxColour((wxColour &)(result));
3020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3021 }
3022 return resultobj;
3023 fail:
3024 return NULL;
3025 }
3026
3027
3028 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3029 PyObject *resultobj;
3030 wxSystemFont arg1 ;
3031 wxFont result;
3032 PyObject * obj0 = 0 ;
3033 char *kwnames[] = {
3034 (char *) "index", NULL
3035 };
3036
3037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3038 {
3039 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3040 if (SWIG_arg_fail(1)) SWIG_fail;
3041 }
3042 {
3043 if (!wxPyCheckForApp()) SWIG_fail;
3044 PyThreadState* __tstate = wxPyBeginAllowThreads();
3045 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3046
3047 wxPyEndAllowThreads(__tstate);
3048 if (PyErr_Occurred()) SWIG_fail;
3049 }
3050 {
3051 wxFont * resultptr;
3052 resultptr = new wxFont((wxFont &)(result));
3053 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3054 }
3055 return resultobj;
3056 fail:
3057 return NULL;
3058 }
3059
3060
3061 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3062 PyObject *resultobj;
3063 wxSystemMetric arg1 ;
3064 wxWindow *arg2 = (wxWindow *) NULL ;
3065 int result;
3066 PyObject * obj0 = 0 ;
3067 PyObject * obj1 = 0 ;
3068 char *kwnames[] = {
3069 (char *) "index",(char *) "win", NULL
3070 };
3071
3072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3073 {
3074 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3075 if (SWIG_arg_fail(1)) SWIG_fail;
3076 }
3077 if (obj1) {
3078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3079 if (SWIG_arg_fail(2)) SWIG_fail;
3080 }
3081 {
3082 if (!wxPyCheckForApp()) SWIG_fail;
3083 PyThreadState* __tstate = wxPyBeginAllowThreads();
3084 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3085
3086 wxPyEndAllowThreads(__tstate);
3087 if (PyErr_Occurred()) SWIG_fail;
3088 }
3089 {
3090 resultobj = SWIG_From_int((int)(result));
3091 }
3092 return resultobj;
3093 fail:
3094 return NULL;
3095 }
3096
3097
3098 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3099 PyObject *resultobj;
3100 wxSystemFeature arg1 ;
3101 bool result;
3102 PyObject * obj0 = 0 ;
3103 char *kwnames[] = {
3104 (char *) "index", NULL
3105 };
3106
3107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3108 {
3109 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3110 if (SWIG_arg_fail(1)) SWIG_fail;
3111 }
3112 {
3113 if (!wxPyCheckForApp()) SWIG_fail;
3114 PyThreadState* __tstate = wxPyBeginAllowThreads();
3115 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3116
3117 wxPyEndAllowThreads(__tstate);
3118 if (PyErr_Occurred()) SWIG_fail;
3119 }
3120 {
3121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3122 }
3123 return resultobj;
3124 fail:
3125 return NULL;
3126 }
3127
3128
3129 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3130 PyObject *resultobj;
3131 wxSystemScreenType result;
3132 char *kwnames[] = {
3133 NULL
3134 };
3135
3136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3137 {
3138 if (!wxPyCheckForApp()) SWIG_fail;
3139 PyThreadState* __tstate = wxPyBeginAllowThreads();
3140 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3141
3142 wxPyEndAllowThreads(__tstate);
3143 if (PyErr_Occurred()) SWIG_fail;
3144 }
3145 resultobj = SWIG_From_int((result));
3146 return resultobj;
3147 fail:
3148 return NULL;
3149 }
3150
3151
3152 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3153 PyObject *resultobj;
3154 wxSystemScreenType arg1 ;
3155 PyObject * obj0 = 0 ;
3156 char *kwnames[] = {
3157 (char *) "screen", NULL
3158 };
3159
3160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3161 {
3162 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3163 if (SWIG_arg_fail(1)) SWIG_fail;
3164 }
3165 {
3166 if (!wxPyCheckForApp()) SWIG_fail;
3167 PyThreadState* __tstate = wxPyBeginAllowThreads();
3168 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3169
3170 wxPyEndAllowThreads(__tstate);
3171 if (PyErr_Occurred()) SWIG_fail;
3172 }
3173 Py_INCREF(Py_None); resultobj = Py_None;
3174 return resultobj;
3175 fail:
3176 return NULL;
3177 }
3178
3179
3180 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3181 PyObject *obj;
3182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3183 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3184 Py_INCREF(obj);
3185 return Py_BuildValue((char *)"");
3186 }
3187 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3188 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3189 return 1;
3190 }
3191
3192
3193 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3194 PyObject *pyobj;
3195
3196 {
3197 #if wxUSE_UNICODE
3198 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3199 #else
3200 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3201 #endif
3202 }
3203 return pyobj;
3204 }
3205
3206
3207 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3208 PyObject *resultobj;
3209 wxSystemOptions *result;
3210 char *kwnames[] = {
3211 NULL
3212 };
3213
3214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3215 {
3216 PyThreadState* __tstate = wxPyBeginAllowThreads();
3217 result = (wxSystemOptions *)new wxSystemOptions();
3218
3219 wxPyEndAllowThreads(__tstate);
3220 if (PyErr_Occurred()) SWIG_fail;
3221 }
3222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3223 return resultobj;
3224 fail:
3225 return NULL;
3226 }
3227
3228
3229 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3230 PyObject *resultobj;
3231 wxString *arg1 = 0 ;
3232 wxString *arg2 = 0 ;
3233 bool temp1 = false ;
3234 bool temp2 = false ;
3235 PyObject * obj0 = 0 ;
3236 PyObject * obj1 = 0 ;
3237 char *kwnames[] = {
3238 (char *) "name",(char *) "value", NULL
3239 };
3240
3241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3242 {
3243 arg1 = wxString_in_helper(obj0);
3244 if (arg1 == NULL) SWIG_fail;
3245 temp1 = true;
3246 }
3247 {
3248 arg2 = wxString_in_helper(obj1);
3249 if (arg2 == NULL) SWIG_fail;
3250 temp2 = true;
3251 }
3252 {
3253 PyThreadState* __tstate = wxPyBeginAllowThreads();
3254 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3255
3256 wxPyEndAllowThreads(__tstate);
3257 if (PyErr_Occurred()) SWIG_fail;
3258 }
3259 Py_INCREF(Py_None); resultobj = Py_None;
3260 {
3261 if (temp1)
3262 delete arg1;
3263 }
3264 {
3265 if (temp2)
3266 delete arg2;
3267 }
3268 return resultobj;
3269 fail:
3270 {
3271 if (temp1)
3272 delete arg1;
3273 }
3274 {
3275 if (temp2)
3276 delete arg2;
3277 }
3278 return NULL;
3279 }
3280
3281
3282 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3283 PyObject *resultobj;
3284 wxString *arg1 = 0 ;
3285 int arg2 ;
3286 bool temp1 = false ;
3287 PyObject * obj0 = 0 ;
3288 PyObject * obj1 = 0 ;
3289 char *kwnames[] = {
3290 (char *) "name",(char *) "value", NULL
3291 };
3292
3293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3294 {
3295 arg1 = wxString_in_helper(obj0);
3296 if (arg1 == NULL) SWIG_fail;
3297 temp1 = true;
3298 }
3299 {
3300 arg2 = (int)(SWIG_As_int(obj1));
3301 if (SWIG_arg_fail(2)) SWIG_fail;
3302 }
3303 {
3304 PyThreadState* __tstate = wxPyBeginAllowThreads();
3305 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3306
3307 wxPyEndAllowThreads(__tstate);
3308 if (PyErr_Occurred()) SWIG_fail;
3309 }
3310 Py_INCREF(Py_None); resultobj = Py_None;
3311 {
3312 if (temp1)
3313 delete arg1;
3314 }
3315 return resultobj;
3316 fail:
3317 {
3318 if (temp1)
3319 delete arg1;
3320 }
3321 return NULL;
3322 }
3323
3324
3325 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3326 PyObject *resultobj;
3327 wxString *arg1 = 0 ;
3328 wxString result;
3329 bool temp1 = false ;
3330 PyObject * obj0 = 0 ;
3331 char *kwnames[] = {
3332 (char *) "name", NULL
3333 };
3334
3335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3336 {
3337 arg1 = wxString_in_helper(obj0);
3338 if (arg1 == NULL) SWIG_fail;
3339 temp1 = true;
3340 }
3341 {
3342 PyThreadState* __tstate = wxPyBeginAllowThreads();
3343 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3344
3345 wxPyEndAllowThreads(__tstate);
3346 if (PyErr_Occurred()) SWIG_fail;
3347 }
3348 {
3349 #if wxUSE_UNICODE
3350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3351 #else
3352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3353 #endif
3354 }
3355 {
3356 if (temp1)
3357 delete arg1;
3358 }
3359 return resultobj;
3360 fail:
3361 {
3362 if (temp1)
3363 delete arg1;
3364 }
3365 return NULL;
3366 }
3367
3368
3369 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3370 PyObject *resultobj;
3371 wxString *arg1 = 0 ;
3372 int result;
3373 bool temp1 = false ;
3374 PyObject * obj0 = 0 ;
3375 char *kwnames[] = {
3376 (char *) "name", NULL
3377 };
3378
3379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3380 {
3381 arg1 = wxString_in_helper(obj0);
3382 if (arg1 == NULL) SWIG_fail;
3383 temp1 = true;
3384 }
3385 {
3386 PyThreadState* __tstate = wxPyBeginAllowThreads();
3387 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3388
3389 wxPyEndAllowThreads(__tstate);
3390 if (PyErr_Occurred()) SWIG_fail;
3391 }
3392 {
3393 resultobj = SWIG_From_int((int)(result));
3394 }
3395 {
3396 if (temp1)
3397 delete arg1;
3398 }
3399 return resultobj;
3400 fail:
3401 {
3402 if (temp1)
3403 delete arg1;
3404 }
3405 return NULL;
3406 }
3407
3408
3409 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3410 PyObject *resultobj;
3411 wxString *arg1 = 0 ;
3412 bool result;
3413 bool temp1 = false ;
3414 PyObject * obj0 = 0 ;
3415 char *kwnames[] = {
3416 (char *) "name", NULL
3417 };
3418
3419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3420 {
3421 arg1 = wxString_in_helper(obj0);
3422 if (arg1 == NULL) SWIG_fail;
3423 temp1 = true;
3424 }
3425 {
3426 PyThreadState* __tstate = wxPyBeginAllowThreads();
3427 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3428
3429 wxPyEndAllowThreads(__tstate);
3430 if (PyErr_Occurred()) SWIG_fail;
3431 }
3432 {
3433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3434 }
3435 {
3436 if (temp1)
3437 delete arg1;
3438 }
3439 return resultobj;
3440 fail:
3441 {
3442 if (temp1)
3443 delete arg1;
3444 }
3445 return NULL;
3446 }
3447
3448
3449 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3450 PyObject *resultobj;
3451 wxString *arg1 = 0 ;
3452 bool result;
3453 bool temp1 = false ;
3454 PyObject * obj0 = 0 ;
3455 char *kwnames[] = {
3456 (char *) "name", NULL
3457 };
3458
3459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3460 {
3461 arg1 = wxString_in_helper(obj0);
3462 if (arg1 == NULL) SWIG_fail;
3463 temp1 = true;
3464 }
3465 {
3466 PyThreadState* __tstate = wxPyBeginAllowThreads();
3467 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3468
3469 wxPyEndAllowThreads(__tstate);
3470 if (PyErr_Occurred()) SWIG_fail;
3471 }
3472 {
3473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3474 }
3475 {
3476 if (temp1)
3477 delete arg1;
3478 }
3479 return resultobj;
3480 fail:
3481 {
3482 if (temp1)
3483 delete arg1;
3484 }
3485 return NULL;
3486 }
3487
3488
3489 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3490 PyObject *obj;
3491 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3492 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3493 Py_INCREF(obj);
3494 return Py_BuildValue((char *)"");
3495 }
3496 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3497 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3498 return 1;
3499 }
3500
3501
3502 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3503 PyObject *pyobj;
3504
3505 {
3506 #if wxUSE_UNICODE
3507 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3508 #else
3509 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3510 #endif
3511 }
3512 return pyobj;
3513 }
3514
3515
3516 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3517 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3518 return 1;
3519 }
3520
3521
3522 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3523 PyObject *pyobj;
3524
3525 {
3526 #if wxUSE_UNICODE
3527 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3528 #else
3529 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3530 #endif
3531 }
3532 return pyobj;
3533 }
3534
3535
3536 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3537 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3538 return 1;
3539 }
3540
3541
3542 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3543 PyObject *pyobj;
3544
3545 {
3546 #if wxUSE_UNICODE
3547 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3548 #else
3549 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3550 #endif
3551 }
3552 return pyobj;
3553 }
3554
3555
3556 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3557 PyObject *resultobj;
3558 long result;
3559 char *kwnames[] = {
3560 NULL
3561 };
3562
3563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3564 {
3565 PyThreadState* __tstate = wxPyBeginAllowThreads();
3566 result = (long)wxNewId();
3567
3568 wxPyEndAllowThreads(__tstate);
3569 if (PyErr_Occurred()) SWIG_fail;
3570 }
3571 {
3572 resultobj = SWIG_From_long((long)(result));
3573 }
3574 return resultobj;
3575 fail:
3576 return NULL;
3577 }
3578
3579
3580 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3581 PyObject *resultobj;
3582 long arg1 ;
3583 PyObject * obj0 = 0 ;
3584 char *kwnames[] = {
3585 (char *) "id", NULL
3586 };
3587
3588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3589 {
3590 arg1 = (long)(SWIG_As_long(obj0));
3591 if (SWIG_arg_fail(1)) SWIG_fail;
3592 }
3593 {
3594 PyThreadState* __tstate = wxPyBeginAllowThreads();
3595 wxRegisterId(arg1);
3596
3597 wxPyEndAllowThreads(__tstate);
3598 if (PyErr_Occurred()) SWIG_fail;
3599 }
3600 Py_INCREF(Py_None); resultobj = Py_None;
3601 return resultobj;
3602 fail:
3603 return NULL;
3604 }
3605
3606
3607 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3608 PyObject *resultobj;
3609 long result;
3610 char *kwnames[] = {
3611 NULL
3612 };
3613
3614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3615 {
3616 PyThreadState* __tstate = wxPyBeginAllowThreads();
3617 result = (long)wxGetCurrentId();
3618
3619 wxPyEndAllowThreads(__tstate);
3620 if (PyErr_Occurred()) SWIG_fail;
3621 }
3622 {
3623 resultobj = SWIG_From_long((long)(result));
3624 }
3625 return resultobj;
3626 fail:
3627 return NULL;
3628 }
3629
3630
3631 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3632 PyObject *resultobj;
3633 int arg1 ;
3634 bool result;
3635 PyObject * obj0 = 0 ;
3636 char *kwnames[] = {
3637 (char *) "id", NULL
3638 };
3639
3640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3641 {
3642 arg1 = (int)(SWIG_As_int(obj0));
3643 if (SWIG_arg_fail(1)) SWIG_fail;
3644 }
3645 {
3646 PyThreadState* __tstate = wxPyBeginAllowThreads();
3647 result = (bool)wxIsStockID(arg1);
3648
3649 wxPyEndAllowThreads(__tstate);
3650 if (PyErr_Occurred()) SWIG_fail;
3651 }
3652 {
3653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3654 }
3655 return resultobj;
3656 fail:
3657 return NULL;
3658 }
3659
3660
3661 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3662 PyObject *resultobj;
3663 int arg1 ;
3664 wxString *arg2 = 0 ;
3665 bool result;
3666 bool temp2 = false ;
3667 PyObject * obj0 = 0 ;
3668 PyObject * obj1 = 0 ;
3669 char *kwnames[] = {
3670 (char *) "id",(char *) "label", NULL
3671 };
3672
3673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3674 {
3675 arg1 = (int)(SWIG_As_int(obj0));
3676 if (SWIG_arg_fail(1)) SWIG_fail;
3677 }
3678 {
3679 arg2 = wxString_in_helper(obj1);
3680 if (arg2 == NULL) SWIG_fail;
3681 temp2 = true;
3682 }
3683 {
3684 PyThreadState* __tstate = wxPyBeginAllowThreads();
3685 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3686
3687 wxPyEndAllowThreads(__tstate);
3688 if (PyErr_Occurred()) SWIG_fail;
3689 }
3690 {
3691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3692 }
3693 {
3694 if (temp2)
3695 delete arg2;
3696 }
3697 return resultobj;
3698 fail:
3699 {
3700 if (temp2)
3701 delete arg2;
3702 }
3703 return NULL;
3704 }
3705
3706
3707 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3708 PyObject *resultobj;
3709 int arg1 ;
3710 bool arg2 = (bool) true ;
3711 wxString arg3 = (wxString) wxPyEmptyString ;
3712 wxString result;
3713 PyObject * obj0 = 0 ;
3714 PyObject * obj1 = 0 ;
3715 PyObject * obj2 = 0 ;
3716 char *kwnames[] = {
3717 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3718 };
3719
3720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3721 {
3722 arg1 = (int)(SWIG_As_int(obj0));
3723 if (SWIG_arg_fail(1)) SWIG_fail;
3724 }
3725 if (obj1) {
3726 {
3727 arg2 = (bool)(SWIG_As_bool(obj1));
3728 if (SWIG_arg_fail(2)) SWIG_fail;
3729 }
3730 }
3731 if (obj2) {
3732 {
3733 wxString* sptr = wxString_in_helper(obj2);
3734 if (sptr == NULL) SWIG_fail;
3735 arg3 = *sptr;
3736 delete sptr;
3737 }
3738 }
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 result = wxGetStockLabel(arg1,arg2,arg3);
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 {
3747 #if wxUSE_UNICODE
3748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3749 #else
3750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3751 #endif
3752 }
3753 return resultobj;
3754 fail:
3755 return NULL;
3756 }
3757
3758
3759 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3760 PyObject *resultobj;
3761 char *kwnames[] = {
3762 NULL
3763 };
3764
3765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3766 {
3767 if (!wxPyCheckForApp()) SWIG_fail;
3768 PyThreadState* __tstate = wxPyBeginAllowThreads();
3769 wxBell();
3770
3771 wxPyEndAllowThreads(__tstate);
3772 if (PyErr_Occurred()) SWIG_fail;
3773 }
3774 Py_INCREF(Py_None); resultobj = Py_None;
3775 return resultobj;
3776 fail:
3777 return NULL;
3778 }
3779
3780
3781 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3782 PyObject *resultobj;
3783 char *kwnames[] = {
3784 NULL
3785 };
3786
3787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3788 {
3789 if (!wxPyCheckForApp()) SWIG_fail;
3790 PyThreadState* __tstate = wxPyBeginAllowThreads();
3791 wxEndBusyCursor();
3792
3793 wxPyEndAllowThreads(__tstate);
3794 if (PyErr_Occurred()) SWIG_fail;
3795 }
3796 Py_INCREF(Py_None); resultobj = Py_None;
3797 return resultobj;
3798 fail:
3799 return NULL;
3800 }
3801
3802
3803 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3804 PyObject *resultobj;
3805 bool arg1 = (bool) true ;
3806 long result;
3807 PyObject * obj0 = 0 ;
3808 char *kwnames[] = {
3809 (char *) "resetTimer", NULL
3810 };
3811
3812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3813 if (obj0) {
3814 {
3815 arg1 = (bool)(SWIG_As_bool(obj0));
3816 if (SWIG_arg_fail(1)) SWIG_fail;
3817 }
3818 }
3819 {
3820 PyThreadState* __tstate = wxPyBeginAllowThreads();
3821 result = (long)wxGetElapsedTime(arg1);
3822
3823 wxPyEndAllowThreads(__tstate);
3824 if (PyErr_Occurred()) SWIG_fail;
3825 }
3826 {
3827 resultobj = SWIG_From_long((long)(result));
3828 }
3829 return resultobj;
3830 fail:
3831 return NULL;
3832 }
3833
3834
3835 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3836 PyObject *resultobj;
3837 int *arg1 = (int *) 0 ;
3838 int *arg2 = (int *) 0 ;
3839 int temp1 ;
3840 int res1 = 0 ;
3841 int temp2 ;
3842 int res2 = 0 ;
3843 char *kwnames[] = {
3844 NULL
3845 };
3846
3847 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3848 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3850 {
3851 if (!wxPyCheckForApp()) SWIG_fail;
3852 PyThreadState* __tstate = wxPyBeginAllowThreads();
3853 wxGetMousePosition(arg1,arg2);
3854
3855 wxPyEndAllowThreads(__tstate);
3856 if (PyErr_Occurred()) SWIG_fail;
3857 }
3858 Py_INCREF(Py_None); resultobj = Py_None;
3859 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3860 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3861 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3862 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj;
3871 bool result;
3872 char *kwnames[] = {
3873 NULL
3874 };
3875
3876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3877 {
3878 PyThreadState* __tstate = wxPyBeginAllowThreads();
3879 result = (bool)wxIsBusy();
3880
3881 wxPyEndAllowThreads(__tstate);
3882 if (PyErr_Occurred()) SWIG_fail;
3883 }
3884 {
3885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3886 }
3887 return resultobj;
3888 fail:
3889 return NULL;
3890 }
3891
3892
3893 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3894 PyObject *resultobj;
3895 wxString result;
3896 char *kwnames[] = {
3897 NULL
3898 };
3899
3900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3901 {
3902 PyThreadState* __tstate = wxPyBeginAllowThreads();
3903 result = wxNow();
3904
3905 wxPyEndAllowThreads(__tstate);
3906 if (PyErr_Occurred()) SWIG_fail;
3907 }
3908 {
3909 #if wxUSE_UNICODE
3910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3911 #else
3912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3913 #endif
3914 }
3915 return resultobj;
3916 fail:
3917 return NULL;
3918 }
3919
3920
3921 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3922 PyObject *resultobj;
3923 wxString const &arg1_defvalue = wxPyEmptyString ;
3924 wxString *arg1 = (wxString *) &arg1_defvalue ;
3925 bool result;
3926 bool temp1 = false ;
3927 PyObject * obj0 = 0 ;
3928 char *kwnames[] = {
3929 (char *) "command", NULL
3930 };
3931
3932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3933 if (obj0) {
3934 {
3935 arg1 = wxString_in_helper(obj0);
3936 if (arg1 == NULL) SWIG_fail;
3937 temp1 = true;
3938 }
3939 }
3940 {
3941 PyThreadState* __tstate = wxPyBeginAllowThreads();
3942 result = (bool)wxShell((wxString const &)*arg1);
3943
3944 wxPyEndAllowThreads(__tstate);
3945 if (PyErr_Occurred()) SWIG_fail;
3946 }
3947 {
3948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3949 }
3950 {
3951 if (temp1)
3952 delete arg1;
3953 }
3954 return resultobj;
3955 fail:
3956 {
3957 if (temp1)
3958 delete arg1;
3959 }
3960 return NULL;
3961 }
3962
3963
3964 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3965 PyObject *resultobj;
3966 char *kwnames[] = {
3967 NULL
3968 };
3969
3970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3971 {
3972 PyThreadState* __tstate = wxPyBeginAllowThreads();
3973 wxStartTimer();
3974
3975 wxPyEndAllowThreads(__tstate);
3976 if (PyErr_Occurred()) SWIG_fail;
3977 }
3978 Py_INCREF(Py_None); resultobj = Py_None;
3979 return resultobj;
3980 fail:
3981 return NULL;
3982 }
3983
3984
3985 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3986 PyObject *resultobj;
3987 int *arg1 = (int *) 0 ;
3988 int *arg2 = (int *) 0 ;
3989 int result;
3990 int temp1 ;
3991 int res1 = 0 ;
3992 int temp2 ;
3993 int res2 = 0 ;
3994 char *kwnames[] = {
3995 NULL
3996 };
3997
3998 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3999 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4001 {
4002 PyThreadState* __tstate = wxPyBeginAllowThreads();
4003 result = (int)wxGetOsVersion(arg1,arg2);
4004
4005 wxPyEndAllowThreads(__tstate);
4006 if (PyErr_Occurred()) SWIG_fail;
4007 }
4008 {
4009 resultobj = SWIG_From_int((int)(result));
4010 }
4011 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4012 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4013 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4014 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4015 return resultobj;
4016 fail:
4017 return NULL;
4018 }
4019
4020
4021 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4022 PyObject *resultobj;
4023 wxString result;
4024 char *kwnames[] = {
4025 NULL
4026 };
4027
4028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4029 {
4030 PyThreadState* __tstate = wxPyBeginAllowThreads();
4031 result = wxGetOsDescription();
4032
4033 wxPyEndAllowThreads(__tstate);
4034 if (PyErr_Occurred()) SWIG_fail;
4035 }
4036 {
4037 #if wxUSE_UNICODE
4038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4039 #else
4040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4041 #endif
4042 }
4043 return resultobj;
4044 fail:
4045 return NULL;
4046 }
4047
4048
4049 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4050 PyObject *resultobj;
4051 long result;
4052 char *kwnames[] = {
4053 NULL
4054 };
4055
4056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4057 {
4058 PyThreadState* __tstate = wxPyBeginAllowThreads();
4059 result = (long)wxGetFreeMemory();
4060
4061 wxPyEndAllowThreads(__tstate);
4062 if (PyErr_Occurred()) SWIG_fail;
4063 }
4064 {
4065 resultobj = SWIG_From_long((long)(result));
4066 }
4067 return resultobj;
4068 fail:
4069 return NULL;
4070 }
4071
4072
4073 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4074 PyObject *resultobj;
4075 wxShutdownFlags arg1 ;
4076 bool result;
4077 PyObject * obj0 = 0 ;
4078 char *kwnames[] = {
4079 (char *) "wFlags", NULL
4080 };
4081
4082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4083 {
4084 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4085 if (SWIG_arg_fail(1)) SWIG_fail;
4086 }
4087 {
4088 if (!wxPyCheckForApp()) SWIG_fail;
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4091
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 {
4096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4097 }
4098 return resultobj;
4099 fail:
4100 return NULL;
4101 }
4102
4103
4104 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4105 PyObject *resultobj;
4106 int arg1 ;
4107 PyObject * obj0 = 0 ;
4108 char *kwnames[] = {
4109 (char *) "secs", NULL
4110 };
4111
4112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4113 {
4114 arg1 = (int)(SWIG_As_int(obj0));
4115 if (SWIG_arg_fail(1)) SWIG_fail;
4116 }
4117 {
4118 PyThreadState* __tstate = wxPyBeginAllowThreads();
4119 wxSleep(arg1);
4120
4121 wxPyEndAllowThreads(__tstate);
4122 if (PyErr_Occurred()) SWIG_fail;
4123 }
4124 Py_INCREF(Py_None); resultobj = Py_None;
4125 return resultobj;
4126 fail:
4127 return NULL;
4128 }
4129
4130
4131 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4132 PyObject *resultobj;
4133 unsigned long arg1 ;
4134 PyObject * obj0 = 0 ;
4135 char *kwnames[] = {
4136 (char *) "milliseconds", NULL
4137 };
4138
4139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4140 {
4141 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4142 if (SWIG_arg_fail(1)) SWIG_fail;
4143 }
4144 {
4145 PyThreadState* __tstate = wxPyBeginAllowThreads();
4146 wxMilliSleep(arg1);
4147
4148 wxPyEndAllowThreads(__tstate);
4149 if (PyErr_Occurred()) SWIG_fail;
4150 }
4151 Py_INCREF(Py_None); resultobj = Py_None;
4152 return resultobj;
4153 fail:
4154 return NULL;
4155 }
4156
4157
4158 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4159 PyObject *resultobj;
4160 unsigned long arg1 ;
4161 PyObject * obj0 = 0 ;
4162 char *kwnames[] = {
4163 (char *) "microseconds", NULL
4164 };
4165
4166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4167 {
4168 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4169 if (SWIG_arg_fail(1)) SWIG_fail;
4170 }
4171 {
4172 PyThreadState* __tstate = wxPyBeginAllowThreads();
4173 wxMicroSleep(arg1);
4174
4175 wxPyEndAllowThreads(__tstate);
4176 if (PyErr_Occurred()) SWIG_fail;
4177 }
4178 Py_INCREF(Py_None); resultobj = Py_None;
4179 return resultobj;
4180 fail:
4181 return NULL;
4182 }
4183
4184
4185 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4186 PyObject *resultobj;
4187 bool arg1 ;
4188 PyObject * obj0 = 0 ;
4189 char *kwnames[] = {
4190 (char *) "enable", NULL
4191 };
4192
4193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4194 {
4195 arg1 = (bool)(SWIG_As_bool(obj0));
4196 if (SWIG_arg_fail(1)) SWIG_fail;
4197 }
4198 {
4199 PyThreadState* __tstate = wxPyBeginAllowThreads();
4200 wxEnableTopLevelWindows(arg1);
4201
4202 wxPyEndAllowThreads(__tstate);
4203 if (PyErr_Occurred()) SWIG_fail;
4204 }
4205 Py_INCREF(Py_None); resultobj = Py_None;
4206 return resultobj;
4207 fail:
4208 return NULL;
4209 }
4210
4211
4212 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4213 PyObject *resultobj;
4214 wxString *arg1 = 0 ;
4215 wxString result;
4216 bool temp1 = false ;
4217 PyObject * obj0 = 0 ;
4218 char *kwnames[] = {
4219 (char *) "in", NULL
4220 };
4221
4222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4223 {
4224 arg1 = wxString_in_helper(obj0);
4225 if (arg1 == NULL) SWIG_fail;
4226 temp1 = true;
4227 }
4228 {
4229 PyThreadState* __tstate = wxPyBeginAllowThreads();
4230 result = wxStripMenuCodes((wxString const &)*arg1);
4231
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 {
4236 #if wxUSE_UNICODE
4237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4238 #else
4239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4240 #endif
4241 }
4242 {
4243 if (temp1)
4244 delete arg1;
4245 }
4246 return resultobj;
4247 fail:
4248 {
4249 if (temp1)
4250 delete arg1;
4251 }
4252 return NULL;
4253 }
4254
4255
4256 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj;
4258 wxString result;
4259 char *kwnames[] = {
4260 NULL
4261 };
4262
4263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 result = wxGetEmailAddress();
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 {
4272 #if wxUSE_UNICODE
4273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4274 #else
4275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4276 #endif
4277 }
4278 return resultobj;
4279 fail:
4280 return NULL;
4281 }
4282
4283
4284 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4285 PyObject *resultobj;
4286 wxString result;
4287 char *kwnames[] = {
4288 NULL
4289 };
4290
4291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4292 {
4293 PyThreadState* __tstate = wxPyBeginAllowThreads();
4294 result = wxGetHostName();
4295
4296 wxPyEndAllowThreads(__tstate);
4297 if (PyErr_Occurred()) SWIG_fail;
4298 }
4299 {
4300 #if wxUSE_UNICODE
4301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4302 #else
4303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4304 #endif
4305 }
4306 return resultobj;
4307 fail:
4308 return NULL;
4309 }
4310
4311
4312 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4313 PyObject *resultobj;
4314 wxString result;
4315 char *kwnames[] = {
4316 NULL
4317 };
4318
4319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4320 {
4321 PyThreadState* __tstate = wxPyBeginAllowThreads();
4322 result = wxGetFullHostName();
4323
4324 wxPyEndAllowThreads(__tstate);
4325 if (PyErr_Occurred()) SWIG_fail;
4326 }
4327 {
4328 #if wxUSE_UNICODE
4329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4330 #else
4331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4332 #endif
4333 }
4334 return resultobj;
4335 fail:
4336 return NULL;
4337 }
4338
4339
4340 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4341 PyObject *resultobj;
4342 wxString result;
4343 char *kwnames[] = {
4344 NULL
4345 };
4346
4347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4348 {
4349 PyThreadState* __tstate = wxPyBeginAllowThreads();
4350 result = wxGetUserId();
4351
4352 wxPyEndAllowThreads(__tstate);
4353 if (PyErr_Occurred()) SWIG_fail;
4354 }
4355 {
4356 #if wxUSE_UNICODE
4357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4358 #else
4359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4360 #endif
4361 }
4362 return resultobj;
4363 fail:
4364 return NULL;
4365 }
4366
4367
4368 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj;
4370 wxString result;
4371 char *kwnames[] = {
4372 NULL
4373 };
4374
4375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4376 {
4377 PyThreadState* __tstate = wxPyBeginAllowThreads();
4378 result = wxGetUserName();
4379
4380 wxPyEndAllowThreads(__tstate);
4381 if (PyErr_Occurred()) SWIG_fail;
4382 }
4383 {
4384 #if wxUSE_UNICODE
4385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4386 #else
4387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4388 #endif
4389 }
4390 return resultobj;
4391 fail:
4392 return NULL;
4393 }
4394
4395
4396 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4397 PyObject *resultobj;
4398 wxString result;
4399 char *kwnames[] = {
4400 NULL
4401 };
4402
4403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4404 {
4405 PyThreadState* __tstate = wxPyBeginAllowThreads();
4406 result = wxGetHomeDir();
4407
4408 wxPyEndAllowThreads(__tstate);
4409 if (PyErr_Occurred()) SWIG_fail;
4410 }
4411 {
4412 #if wxUSE_UNICODE
4413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4414 #else
4415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4416 #endif
4417 }
4418 return resultobj;
4419 fail:
4420 return NULL;
4421 }
4422
4423
4424 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4425 PyObject *resultobj;
4426 wxString const &arg1_defvalue = wxPyEmptyString ;
4427 wxString *arg1 = (wxString *) &arg1_defvalue ;
4428 wxString result;
4429 bool temp1 = false ;
4430 PyObject * obj0 = 0 ;
4431 char *kwnames[] = {
4432 (char *) "user", NULL
4433 };
4434
4435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4436 if (obj0) {
4437 {
4438 arg1 = wxString_in_helper(obj0);
4439 if (arg1 == NULL) SWIG_fail;
4440 temp1 = true;
4441 }
4442 }
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 result = wxGetUserHome((wxString const &)*arg1);
4446
4447 wxPyEndAllowThreads(__tstate);
4448 if (PyErr_Occurred()) SWIG_fail;
4449 }
4450 {
4451 #if wxUSE_UNICODE
4452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4453 #else
4454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4455 #endif
4456 }
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 return resultobj;
4462 fail:
4463 {
4464 if (temp1)
4465 delete arg1;
4466 }
4467 return NULL;
4468 }
4469
4470
4471 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4472 PyObject *resultobj;
4473 unsigned long result;
4474 char *kwnames[] = {
4475 NULL
4476 };
4477
4478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4479 {
4480 PyThreadState* __tstate = wxPyBeginAllowThreads();
4481 result = (unsigned long)wxGetProcessId();
4482
4483 wxPyEndAllowThreads(__tstate);
4484 if (PyErr_Occurred()) SWIG_fail;
4485 }
4486 {
4487 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4488 }
4489 return resultobj;
4490 fail:
4491 return NULL;
4492 }
4493
4494
4495 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4496 PyObject *resultobj;
4497 char *kwnames[] = {
4498 NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4502 {
4503 PyThreadState* __tstate = wxPyBeginAllowThreads();
4504 wxTrap();
4505
4506 wxPyEndAllowThreads(__tstate);
4507 if (PyErr_Occurred()) SWIG_fail;
4508 }
4509 Py_INCREF(Py_None); resultobj = Py_None;
4510 return resultobj;
4511 fail:
4512 return NULL;
4513 }
4514
4515
4516 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj;
4518 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4519 wxString *arg1 = (wxString *) &arg1_defvalue ;
4520 wxString const &arg2_defvalue = wxPyEmptyString ;
4521 wxString *arg2 = (wxString *) &arg2_defvalue ;
4522 wxString const &arg3_defvalue = wxPyEmptyString ;
4523 wxString *arg3 = (wxString *) &arg3_defvalue ;
4524 wxString const &arg4_defvalue = wxPyEmptyString ;
4525 wxString *arg4 = (wxString *) &arg4_defvalue ;
4526 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4527 wxString *arg5 = (wxString *) &arg5_defvalue ;
4528 int arg6 = (int) 0 ;
4529 wxWindow *arg7 = (wxWindow *) NULL ;
4530 int arg8 = (int) -1 ;
4531 int arg9 = (int) -1 ;
4532 wxString result;
4533 bool temp1 = false ;
4534 bool temp2 = false ;
4535 bool temp3 = false ;
4536 bool temp4 = false ;
4537 bool temp5 = false ;
4538 PyObject * obj0 = 0 ;
4539 PyObject * obj1 = 0 ;
4540 PyObject * obj2 = 0 ;
4541 PyObject * obj3 = 0 ;
4542 PyObject * obj4 = 0 ;
4543 PyObject * obj5 = 0 ;
4544 PyObject * obj6 = 0 ;
4545 PyObject * obj7 = 0 ;
4546 PyObject * obj8 = 0 ;
4547 char *kwnames[] = {
4548 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4549 };
4550
4551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4552 if (obj0) {
4553 {
4554 arg1 = wxString_in_helper(obj0);
4555 if (arg1 == NULL) SWIG_fail;
4556 temp1 = true;
4557 }
4558 }
4559 if (obj1) {
4560 {
4561 arg2 = wxString_in_helper(obj1);
4562 if (arg2 == NULL) SWIG_fail;
4563 temp2 = true;
4564 }
4565 }
4566 if (obj2) {
4567 {
4568 arg3 = wxString_in_helper(obj2);
4569 if (arg3 == NULL) SWIG_fail;
4570 temp3 = true;
4571 }
4572 }
4573 if (obj3) {
4574 {
4575 arg4 = wxString_in_helper(obj3);
4576 if (arg4 == NULL) SWIG_fail;
4577 temp4 = true;
4578 }
4579 }
4580 if (obj4) {
4581 {
4582 arg5 = wxString_in_helper(obj4);
4583 if (arg5 == NULL) SWIG_fail;
4584 temp5 = true;
4585 }
4586 }
4587 if (obj5) {
4588 {
4589 arg6 = (int)(SWIG_As_int(obj5));
4590 if (SWIG_arg_fail(6)) SWIG_fail;
4591 }
4592 }
4593 if (obj6) {
4594 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4595 if (SWIG_arg_fail(7)) SWIG_fail;
4596 }
4597 if (obj7) {
4598 {
4599 arg8 = (int)(SWIG_As_int(obj7));
4600 if (SWIG_arg_fail(8)) SWIG_fail;
4601 }
4602 }
4603 if (obj8) {
4604 {
4605 arg9 = (int)(SWIG_As_int(obj8));
4606 if (SWIG_arg_fail(9)) SWIG_fail;
4607 }
4608 }
4609 {
4610 if (!wxPyCheckForApp()) SWIG_fail;
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4613
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 {
4618 #if wxUSE_UNICODE
4619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4620 #else
4621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4622 #endif
4623 }
4624 {
4625 if (temp1)
4626 delete arg1;
4627 }
4628 {
4629 if (temp2)
4630 delete arg2;
4631 }
4632 {
4633 if (temp3)
4634 delete arg3;
4635 }
4636 {
4637 if (temp4)
4638 delete arg4;
4639 }
4640 {
4641 if (temp5)
4642 delete arg5;
4643 }
4644 return resultobj;
4645 fail:
4646 {
4647 if (temp1)
4648 delete arg1;
4649 }
4650 {
4651 if (temp2)
4652 delete arg2;
4653 }
4654 {
4655 if (temp3)
4656 delete arg3;
4657 }
4658 {
4659 if (temp4)
4660 delete arg4;
4661 }
4662 {
4663 if (temp5)
4664 delete arg5;
4665 }
4666 return NULL;
4667 }
4668
4669
4670 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj;
4672 wxString *arg1 = 0 ;
4673 wxString *arg2 = 0 ;
4674 wxString const &arg3_defvalue = wxPyEmptyString ;
4675 wxString *arg3 = (wxString *) &arg3_defvalue ;
4676 wxWindow *arg4 = (wxWindow *) NULL ;
4677 wxString result;
4678 bool temp1 = false ;
4679 bool temp2 = false ;
4680 bool temp3 = false ;
4681 PyObject * obj0 = 0 ;
4682 PyObject * obj1 = 0 ;
4683 PyObject * obj2 = 0 ;
4684 PyObject * obj3 = 0 ;
4685 char *kwnames[] = {
4686 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4687 };
4688
4689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4690 {
4691 arg1 = wxString_in_helper(obj0);
4692 if (arg1 == NULL) SWIG_fail;
4693 temp1 = true;
4694 }
4695 {
4696 arg2 = wxString_in_helper(obj1);
4697 if (arg2 == NULL) SWIG_fail;
4698 temp2 = true;
4699 }
4700 if (obj2) {
4701 {
4702 arg3 = wxString_in_helper(obj2);
4703 if (arg3 == NULL) SWIG_fail;
4704 temp3 = true;
4705 }
4706 }
4707 if (obj3) {
4708 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4709 if (SWIG_arg_fail(4)) SWIG_fail;
4710 }
4711 {
4712 if (!wxPyCheckForApp()) SWIG_fail;
4713 PyThreadState* __tstate = wxPyBeginAllowThreads();
4714 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4715
4716 wxPyEndAllowThreads(__tstate);
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 {
4720 #if wxUSE_UNICODE
4721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4722 #else
4723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4724 #endif
4725 }
4726 {
4727 if (temp1)
4728 delete arg1;
4729 }
4730 {
4731 if (temp2)
4732 delete arg2;
4733 }
4734 {
4735 if (temp3)
4736 delete arg3;
4737 }
4738 return resultobj;
4739 fail:
4740 {
4741 if (temp1)
4742 delete arg1;
4743 }
4744 {
4745 if (temp2)
4746 delete arg2;
4747 }
4748 {
4749 if (temp3)
4750 delete arg3;
4751 }
4752 return NULL;
4753 }
4754
4755
4756 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4757 PyObject *resultobj;
4758 wxString *arg1 = 0 ;
4759 wxString *arg2 = 0 ;
4760 wxString const &arg3_defvalue = wxPyEmptyString ;
4761 wxString *arg3 = (wxString *) &arg3_defvalue ;
4762 wxWindow *arg4 = (wxWindow *) NULL ;
4763 wxString result;
4764 bool temp1 = false ;
4765 bool temp2 = false ;
4766 bool temp3 = false ;
4767 PyObject * obj0 = 0 ;
4768 PyObject * obj1 = 0 ;
4769 PyObject * obj2 = 0 ;
4770 PyObject * obj3 = 0 ;
4771 char *kwnames[] = {
4772 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4773 };
4774
4775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4776 {
4777 arg1 = wxString_in_helper(obj0);
4778 if (arg1 == NULL) SWIG_fail;
4779 temp1 = true;
4780 }
4781 {
4782 arg2 = wxString_in_helper(obj1);
4783 if (arg2 == NULL) SWIG_fail;
4784 temp2 = true;
4785 }
4786 if (obj2) {
4787 {
4788 arg3 = wxString_in_helper(obj2);
4789 if (arg3 == NULL) SWIG_fail;
4790 temp3 = true;
4791 }
4792 }
4793 if (obj3) {
4794 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4795 if (SWIG_arg_fail(4)) SWIG_fail;
4796 }
4797 {
4798 if (!wxPyCheckForApp()) SWIG_fail;
4799 PyThreadState* __tstate = wxPyBeginAllowThreads();
4800 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4801
4802 wxPyEndAllowThreads(__tstate);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 {
4806 #if wxUSE_UNICODE
4807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4808 #else
4809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4810 #endif
4811 }
4812 {
4813 if (temp1)
4814 delete arg1;
4815 }
4816 {
4817 if (temp2)
4818 delete arg2;
4819 }
4820 {
4821 if (temp3)
4822 delete arg3;
4823 }
4824 return resultobj;
4825 fail:
4826 {
4827 if (temp1)
4828 delete arg1;
4829 }
4830 {
4831 if (temp2)
4832 delete arg2;
4833 }
4834 {
4835 if (temp3)
4836 delete arg3;
4837 }
4838 return NULL;
4839 }
4840
4841
4842 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4843 PyObject *resultobj;
4844 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4845 wxString *arg1 = (wxString *) &arg1_defvalue ;
4846 wxString const &arg2_defvalue = wxPyEmptyString ;
4847 wxString *arg2 = (wxString *) &arg2_defvalue ;
4848 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4849 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4850 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4851 wxWindow *arg5 = (wxWindow *) NULL ;
4852 wxString result;
4853 bool temp1 = false ;
4854 bool temp2 = false ;
4855 wxPoint temp4 ;
4856 PyObject * obj0 = 0 ;
4857 PyObject * obj1 = 0 ;
4858 PyObject * obj2 = 0 ;
4859 PyObject * obj3 = 0 ;
4860 PyObject * obj4 = 0 ;
4861 char *kwnames[] = {
4862 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4863 };
4864
4865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4866 if (obj0) {
4867 {
4868 arg1 = wxString_in_helper(obj0);
4869 if (arg1 == NULL) SWIG_fail;
4870 temp1 = true;
4871 }
4872 }
4873 if (obj1) {
4874 {
4875 arg2 = wxString_in_helper(obj1);
4876 if (arg2 == NULL) SWIG_fail;
4877 temp2 = true;
4878 }
4879 }
4880 if (obj2) {
4881 {
4882 arg3 = (long)(SWIG_As_long(obj2));
4883 if (SWIG_arg_fail(3)) SWIG_fail;
4884 }
4885 }
4886 if (obj3) {
4887 {
4888 arg4 = &temp4;
4889 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4890 }
4891 }
4892 if (obj4) {
4893 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4894 if (SWIG_arg_fail(5)) SWIG_fail;
4895 }
4896 {
4897 if (!wxPyCheckForApp()) SWIG_fail;
4898 PyThreadState* __tstate = wxPyBeginAllowThreads();
4899 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4900
4901 wxPyEndAllowThreads(__tstate);
4902 if (PyErr_Occurred()) SWIG_fail;
4903 }
4904 {
4905 #if wxUSE_UNICODE
4906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4907 #else
4908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4909 #endif
4910 }
4911 {
4912 if (temp1)
4913 delete arg1;
4914 }
4915 {
4916 if (temp2)
4917 delete arg2;
4918 }
4919 return resultobj;
4920 fail:
4921 {
4922 if (temp1)
4923 delete arg1;
4924 }
4925 {
4926 if (temp2)
4927 delete arg2;
4928 }
4929 return NULL;
4930 }
4931
4932
4933 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4934 PyObject *resultobj;
4935 wxString *arg1 = 0 ;
4936 wxString const &arg2_defvalue = wxPyEmptyString ;
4937 wxString *arg2 = (wxString *) &arg2_defvalue ;
4938 wxString const &arg3_defvalue = wxPyEmptyString ;
4939 wxString *arg3 = (wxString *) &arg3_defvalue ;
4940 wxWindow *arg4 = (wxWindow *) NULL ;
4941 int arg5 = (int) -1 ;
4942 int arg6 = (int) -1 ;
4943 bool arg7 = (bool) true ;
4944 wxString result;
4945 bool temp1 = false ;
4946 bool temp2 = false ;
4947 bool temp3 = false ;
4948 PyObject * obj0 = 0 ;
4949 PyObject * obj1 = 0 ;
4950 PyObject * obj2 = 0 ;
4951 PyObject * obj3 = 0 ;
4952 PyObject * obj4 = 0 ;
4953 PyObject * obj5 = 0 ;
4954 PyObject * obj6 = 0 ;
4955 char *kwnames[] = {
4956 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4957 };
4958
4959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4960 {
4961 arg1 = wxString_in_helper(obj0);
4962 if (arg1 == NULL) SWIG_fail;
4963 temp1 = true;
4964 }
4965 if (obj1) {
4966 {
4967 arg2 = wxString_in_helper(obj1);
4968 if (arg2 == NULL) SWIG_fail;
4969 temp2 = true;
4970 }
4971 }
4972 if (obj2) {
4973 {
4974 arg3 = wxString_in_helper(obj2);
4975 if (arg3 == NULL) SWIG_fail;
4976 temp3 = true;
4977 }
4978 }
4979 if (obj3) {
4980 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4981 if (SWIG_arg_fail(4)) SWIG_fail;
4982 }
4983 if (obj4) {
4984 {
4985 arg5 = (int)(SWIG_As_int(obj4));
4986 if (SWIG_arg_fail(5)) SWIG_fail;
4987 }
4988 }
4989 if (obj5) {
4990 {
4991 arg6 = (int)(SWIG_As_int(obj5));
4992 if (SWIG_arg_fail(6)) SWIG_fail;
4993 }
4994 }
4995 if (obj6) {
4996 {
4997 arg7 = (bool)(SWIG_As_bool(obj6));
4998 if (SWIG_arg_fail(7)) SWIG_fail;
4999 }
5000 }
5001 {
5002 if (!wxPyCheckForApp()) SWIG_fail;
5003 PyThreadState* __tstate = wxPyBeginAllowThreads();
5004 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5005
5006 wxPyEndAllowThreads(__tstate);
5007 if (PyErr_Occurred()) SWIG_fail;
5008 }
5009 {
5010 #if wxUSE_UNICODE
5011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5012 #else
5013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5014 #endif
5015 }
5016 {
5017 if (temp1)
5018 delete arg1;
5019 }
5020 {
5021 if (temp2)
5022 delete arg2;
5023 }
5024 {
5025 if (temp3)
5026 delete arg3;
5027 }
5028 return resultobj;
5029 fail:
5030 {
5031 if (temp1)
5032 delete arg1;
5033 }
5034 {
5035 if (temp2)
5036 delete arg2;
5037 }
5038 {
5039 if (temp3)
5040 delete arg3;
5041 }
5042 return NULL;
5043 }
5044
5045
5046 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5047 PyObject *resultobj;
5048 wxString *arg1 = 0 ;
5049 wxString const &arg2_defvalue = wxPyEmptyString ;
5050 wxString *arg2 = (wxString *) &arg2_defvalue ;
5051 wxString const &arg3_defvalue = wxPyEmptyString ;
5052 wxString *arg3 = (wxString *) &arg3_defvalue ;
5053 wxWindow *arg4 = (wxWindow *) NULL ;
5054 wxString result;
5055 bool temp1 = false ;
5056 bool temp2 = false ;
5057 bool temp3 = false ;
5058 PyObject * obj0 = 0 ;
5059 PyObject * obj1 = 0 ;
5060 PyObject * obj2 = 0 ;
5061 PyObject * obj3 = 0 ;
5062 char *kwnames[] = {
5063 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5064 };
5065
5066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5067 {
5068 arg1 = wxString_in_helper(obj0);
5069 if (arg1 == NULL) SWIG_fail;
5070 temp1 = true;
5071 }
5072 if (obj1) {
5073 {
5074 arg2 = wxString_in_helper(obj1);
5075 if (arg2 == NULL) SWIG_fail;
5076 temp2 = true;
5077 }
5078 }
5079 if (obj2) {
5080 {
5081 arg3 = wxString_in_helper(obj2);
5082 if (arg3 == NULL) SWIG_fail;
5083 temp3 = true;
5084 }
5085 }
5086 if (obj3) {
5087 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5088 if (SWIG_arg_fail(4)) SWIG_fail;
5089 }
5090 {
5091 if (!wxPyCheckForApp()) SWIG_fail;
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5094
5095 wxPyEndAllowThreads(__tstate);
5096 if (PyErr_Occurred()) SWIG_fail;
5097 }
5098 {
5099 #if wxUSE_UNICODE
5100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5101 #else
5102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5103 #endif
5104 }
5105 {
5106 if (temp1)
5107 delete arg1;
5108 }
5109 {
5110 if (temp2)
5111 delete arg2;
5112 }
5113 {
5114 if (temp3)
5115 delete arg3;
5116 }
5117 return resultobj;
5118 fail:
5119 {
5120 if (temp1)
5121 delete arg1;
5122 }
5123 {
5124 if (temp2)
5125 delete arg2;
5126 }
5127 {
5128 if (temp3)
5129 delete arg3;
5130 }
5131 return NULL;
5132 }
5133
5134
5135 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5136 PyObject *resultobj;
5137 wxString *arg1 = 0 ;
5138 wxString *arg2 = 0 ;
5139 int arg3 ;
5140 wxString *arg4 = (wxString *) 0 ;
5141 wxWindow *arg5 = (wxWindow *) NULL ;
5142 int arg6 = (int) -1 ;
5143 int arg7 = (int) -1 ;
5144 bool arg8 = (bool) true ;
5145 int arg9 = (int) 150 ;
5146 int arg10 = (int) 200 ;
5147 wxString result;
5148 bool temp1 = false ;
5149 bool temp2 = false ;
5150 PyObject * obj0 = 0 ;
5151 PyObject * obj1 = 0 ;
5152 PyObject * obj2 = 0 ;
5153 PyObject * obj3 = 0 ;
5154 PyObject * obj4 = 0 ;
5155 PyObject * obj5 = 0 ;
5156 PyObject * obj6 = 0 ;
5157 PyObject * obj7 = 0 ;
5158 PyObject * obj8 = 0 ;
5159 char *kwnames[] = {
5160 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5161 };
5162
5163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5164 {
5165 arg1 = wxString_in_helper(obj0);
5166 if (arg1 == NULL) SWIG_fail;
5167 temp1 = true;
5168 }
5169 {
5170 arg2 = wxString_in_helper(obj1);
5171 if (arg2 == NULL) SWIG_fail;
5172 temp2 = true;
5173 }
5174 {
5175 arg3 = PyList_Size(obj2);
5176 arg4 = wxString_LIST_helper(obj2);
5177 if (arg4 == NULL) SWIG_fail;
5178 }
5179 if (obj3) {
5180 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5181 if (SWIG_arg_fail(5)) SWIG_fail;
5182 }
5183 if (obj4) {
5184 {
5185 arg6 = (int)(SWIG_As_int(obj4));
5186 if (SWIG_arg_fail(6)) SWIG_fail;
5187 }
5188 }
5189 if (obj5) {
5190 {
5191 arg7 = (int)(SWIG_As_int(obj5));
5192 if (SWIG_arg_fail(7)) SWIG_fail;
5193 }
5194 }
5195 if (obj6) {
5196 {
5197 arg8 = (bool)(SWIG_As_bool(obj6));
5198 if (SWIG_arg_fail(8)) SWIG_fail;
5199 }
5200 }
5201 if (obj7) {
5202 {
5203 arg9 = (int)(SWIG_As_int(obj7));
5204 if (SWIG_arg_fail(9)) SWIG_fail;
5205 }
5206 }
5207 if (obj8) {
5208 {
5209 arg10 = (int)(SWIG_As_int(obj8));
5210 if (SWIG_arg_fail(10)) SWIG_fail;
5211 }
5212 }
5213 {
5214 if (!wxPyCheckForApp()) SWIG_fail;
5215 PyThreadState* __tstate = wxPyBeginAllowThreads();
5216 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5217
5218 wxPyEndAllowThreads(__tstate);
5219 if (PyErr_Occurred()) SWIG_fail;
5220 }
5221 {
5222 #if wxUSE_UNICODE
5223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5224 #else
5225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5226 #endif
5227 }
5228 {
5229 if (temp1)
5230 delete arg1;
5231 }
5232 {
5233 if (temp2)
5234 delete arg2;
5235 }
5236 {
5237 if (arg4) delete [] arg4;
5238 }
5239 return resultobj;
5240 fail:
5241 {
5242 if (temp1)
5243 delete arg1;
5244 }
5245 {
5246 if (temp2)
5247 delete arg2;
5248 }
5249 {
5250 if (arg4) delete [] arg4;
5251 }
5252 return NULL;
5253 }
5254
5255
5256 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5257 PyObject *resultobj;
5258 wxString *arg1 = 0 ;
5259 wxString *arg2 = 0 ;
5260 int arg3 ;
5261 wxString *arg4 = (wxString *) 0 ;
5262 wxWindow *arg5 = (wxWindow *) NULL ;
5263 int arg6 = (int) -1 ;
5264 int arg7 = (int) -1 ;
5265 bool arg8 = (bool) true ;
5266 int arg9 = (int) 150 ;
5267 int arg10 = (int) 200 ;
5268 int result;
5269 bool temp1 = false ;
5270 bool temp2 = false ;
5271 PyObject * obj0 = 0 ;
5272 PyObject * obj1 = 0 ;
5273 PyObject * obj2 = 0 ;
5274 PyObject * obj3 = 0 ;
5275 PyObject * obj4 = 0 ;
5276 PyObject * obj5 = 0 ;
5277 PyObject * obj6 = 0 ;
5278 PyObject * obj7 = 0 ;
5279 PyObject * obj8 = 0 ;
5280 char *kwnames[] = {
5281 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5282 };
5283
5284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5285 {
5286 arg1 = wxString_in_helper(obj0);
5287 if (arg1 == NULL) SWIG_fail;
5288 temp1 = true;
5289 }
5290 {
5291 arg2 = wxString_in_helper(obj1);
5292 if (arg2 == NULL) SWIG_fail;
5293 temp2 = true;
5294 }
5295 {
5296 arg3 = PyList_Size(obj2);
5297 arg4 = wxString_LIST_helper(obj2);
5298 if (arg4 == NULL) SWIG_fail;
5299 }
5300 if (obj3) {
5301 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5302 if (SWIG_arg_fail(5)) SWIG_fail;
5303 }
5304 if (obj4) {
5305 {
5306 arg6 = (int)(SWIG_As_int(obj4));
5307 if (SWIG_arg_fail(6)) SWIG_fail;
5308 }
5309 }
5310 if (obj5) {
5311 {
5312 arg7 = (int)(SWIG_As_int(obj5));
5313 if (SWIG_arg_fail(7)) SWIG_fail;
5314 }
5315 }
5316 if (obj6) {
5317 {
5318 arg8 = (bool)(SWIG_As_bool(obj6));
5319 if (SWIG_arg_fail(8)) SWIG_fail;
5320 }
5321 }
5322 if (obj7) {
5323 {
5324 arg9 = (int)(SWIG_As_int(obj7));
5325 if (SWIG_arg_fail(9)) SWIG_fail;
5326 }
5327 }
5328 if (obj8) {
5329 {
5330 arg10 = (int)(SWIG_As_int(obj8));
5331 if (SWIG_arg_fail(10)) SWIG_fail;
5332 }
5333 }
5334 {
5335 if (!wxPyCheckForApp()) SWIG_fail;
5336 PyThreadState* __tstate = wxPyBeginAllowThreads();
5337 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5338
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 {
5343 resultobj = SWIG_From_int((int)(result));
5344 }
5345 {
5346 if (temp1)
5347 delete arg1;
5348 }
5349 {
5350 if (temp2)
5351 delete arg2;
5352 }
5353 {
5354 if (arg4) delete [] arg4;
5355 }
5356 return resultobj;
5357 fail:
5358 {
5359 if (temp1)
5360 delete arg1;
5361 }
5362 {
5363 if (temp2)
5364 delete arg2;
5365 }
5366 {
5367 if (arg4) delete [] arg4;
5368 }
5369 return NULL;
5370 }
5371
5372
5373 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5374 PyObject *resultobj;
5375 wxString *arg1 = 0 ;
5376 wxString const &arg2_defvalue = wxPyEmptyString ;
5377 wxString *arg2 = (wxString *) &arg2_defvalue ;
5378 int arg3 = (int) wxOK|wxCENTRE ;
5379 wxWindow *arg4 = (wxWindow *) NULL ;
5380 int arg5 = (int) -1 ;
5381 int arg6 = (int) -1 ;
5382 int result;
5383 bool temp1 = false ;
5384 bool temp2 = false ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 PyObject * obj2 = 0 ;
5388 PyObject * obj3 = 0 ;
5389 PyObject * obj4 = 0 ;
5390 PyObject * obj5 = 0 ;
5391 char *kwnames[] = {
5392 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5393 };
5394
5395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5396 {
5397 arg1 = wxString_in_helper(obj0);
5398 if (arg1 == NULL) SWIG_fail;
5399 temp1 = true;
5400 }
5401 if (obj1) {
5402 {
5403 arg2 = wxString_in_helper(obj1);
5404 if (arg2 == NULL) SWIG_fail;
5405 temp2 = true;
5406 }
5407 }
5408 if (obj2) {
5409 {
5410 arg3 = (int)(SWIG_As_int(obj2));
5411 if (SWIG_arg_fail(3)) SWIG_fail;
5412 }
5413 }
5414 if (obj3) {
5415 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5416 if (SWIG_arg_fail(4)) SWIG_fail;
5417 }
5418 if (obj4) {
5419 {
5420 arg5 = (int)(SWIG_As_int(obj4));
5421 if (SWIG_arg_fail(5)) SWIG_fail;
5422 }
5423 }
5424 if (obj5) {
5425 {
5426 arg6 = (int)(SWIG_As_int(obj5));
5427 if (SWIG_arg_fail(6)) SWIG_fail;
5428 }
5429 }
5430 {
5431 if (!wxPyCheckForApp()) SWIG_fail;
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5434
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 {
5439 resultobj = SWIG_From_int((int)(result));
5440 }
5441 {
5442 if (temp1)
5443 delete arg1;
5444 }
5445 {
5446 if (temp2)
5447 delete arg2;
5448 }
5449 return resultobj;
5450 fail:
5451 {
5452 if (temp1)
5453 delete arg1;
5454 }
5455 {
5456 if (temp2)
5457 delete arg2;
5458 }
5459 return NULL;
5460 }
5461
5462
5463 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5464 PyObject *resultobj;
5465 wxString *arg1 = 0 ;
5466 wxString *arg2 = 0 ;
5467 wxString *arg3 = 0 ;
5468 long arg4 ;
5469 long arg5 = (long) 0 ;
5470 long arg6 = (long) 100 ;
5471 wxWindow *arg7 = (wxWindow *) NULL ;
5472 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5473 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5474 long result;
5475 bool temp1 = false ;
5476 bool temp2 = false ;
5477 bool temp3 = false ;
5478 wxPoint temp8 ;
5479 PyObject * obj0 = 0 ;
5480 PyObject * obj1 = 0 ;
5481 PyObject * obj2 = 0 ;
5482 PyObject * obj3 = 0 ;
5483 PyObject * obj4 = 0 ;
5484 PyObject * obj5 = 0 ;
5485 PyObject * obj6 = 0 ;
5486 PyObject * obj7 = 0 ;
5487 char *kwnames[] = {
5488 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5489 };
5490
5491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5492 {
5493 arg1 = wxString_in_helper(obj0);
5494 if (arg1 == NULL) SWIG_fail;
5495 temp1 = true;
5496 }
5497 {
5498 arg2 = wxString_in_helper(obj1);
5499 if (arg2 == NULL) SWIG_fail;
5500 temp2 = true;
5501 }
5502 {
5503 arg3 = wxString_in_helper(obj2);
5504 if (arg3 == NULL) SWIG_fail;
5505 temp3 = true;
5506 }
5507 {
5508 arg4 = (long)(SWIG_As_long(obj3));
5509 if (SWIG_arg_fail(4)) SWIG_fail;
5510 }
5511 if (obj4) {
5512 {
5513 arg5 = (long)(SWIG_As_long(obj4));
5514 if (SWIG_arg_fail(5)) SWIG_fail;
5515 }
5516 }
5517 if (obj5) {
5518 {
5519 arg6 = (long)(SWIG_As_long(obj5));
5520 if (SWIG_arg_fail(6)) SWIG_fail;
5521 }
5522 }
5523 if (obj6) {
5524 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5525 if (SWIG_arg_fail(7)) SWIG_fail;
5526 }
5527 if (obj7) {
5528 {
5529 arg8 = &temp8;
5530 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5531 }
5532 }
5533 {
5534 if (!wxPyCheckForApp()) SWIG_fail;
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 resultobj = SWIG_From_long((long)(result));
5543 }
5544 {
5545 if (temp1)
5546 delete arg1;
5547 }
5548 {
5549 if (temp2)
5550 delete arg2;
5551 }
5552 {
5553 if (temp3)
5554 delete arg3;
5555 }
5556 return resultobj;
5557 fail:
5558 {
5559 if (temp1)
5560 delete arg1;
5561 }
5562 {
5563 if (temp2)
5564 delete arg2;
5565 }
5566 {
5567 if (temp3)
5568 delete arg3;
5569 }
5570 return NULL;
5571 }
5572
5573
5574 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5575 PyObject *resultobj;
5576 bool result;
5577 char *kwnames[] = {
5578 NULL
5579 };
5580
5581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5582 {
5583 if (!wxPyCheckForApp()) SWIG_fail;
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 result = (bool)wxColourDisplay();
5586
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 {
5591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5592 }
5593 return resultobj;
5594 fail:
5595 return NULL;
5596 }
5597
5598
5599 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5600 PyObject *resultobj;
5601 int result;
5602 char *kwnames[] = {
5603 NULL
5604 };
5605
5606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5607 {
5608 if (!wxPyCheckForApp()) SWIG_fail;
5609 PyThreadState* __tstate = wxPyBeginAllowThreads();
5610 result = (int)wxDisplayDepth();
5611
5612 wxPyEndAllowThreads(__tstate);
5613 if (PyErr_Occurred()) SWIG_fail;
5614 }
5615 {
5616 resultobj = SWIG_From_int((int)(result));
5617 }
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 int result;
5627 char *kwnames[] = {
5628 NULL
5629 };
5630
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5632 {
5633 if (!wxPyCheckForApp()) SWIG_fail;
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 result = (int)wxGetDisplayDepth();
5636
5637 wxPyEndAllowThreads(__tstate);
5638 if (PyErr_Occurred()) SWIG_fail;
5639 }
5640 {
5641 resultobj = SWIG_From_int((int)(result));
5642 }
5643 return resultobj;
5644 fail:
5645 return NULL;
5646 }
5647
5648
5649 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj;
5651 int *arg1 = (int *) 0 ;
5652 int *arg2 = (int *) 0 ;
5653 int temp1 ;
5654 int res1 = 0 ;
5655 int temp2 ;
5656 int res2 = 0 ;
5657 char *kwnames[] = {
5658 NULL
5659 };
5660
5661 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5662 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5664 {
5665 if (!wxPyCheckForApp()) SWIG_fail;
5666 PyThreadState* __tstate = wxPyBeginAllowThreads();
5667 wxDisplaySize(arg1,arg2);
5668
5669 wxPyEndAllowThreads(__tstate);
5670 if (PyErr_Occurred()) SWIG_fail;
5671 }
5672 Py_INCREF(Py_None); resultobj = Py_None;
5673 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5674 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5675 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5676 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5677 return resultobj;
5678 fail:
5679 return NULL;
5680 }
5681
5682
5683 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5684 PyObject *resultobj;
5685 wxSize result;
5686 char *kwnames[] = {
5687 NULL
5688 };
5689
5690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5691 {
5692 if (!wxPyCheckForApp()) SWIG_fail;
5693 PyThreadState* __tstate = wxPyBeginAllowThreads();
5694 result = wxGetDisplaySize();
5695
5696 wxPyEndAllowThreads(__tstate);
5697 if (PyErr_Occurred()) SWIG_fail;
5698 }
5699 {
5700 wxSize * resultptr;
5701 resultptr = new wxSize((wxSize &)(result));
5702 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5703 }
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj;
5712 int *arg1 = (int *) 0 ;
5713 int *arg2 = (int *) 0 ;
5714 int temp1 ;
5715 int res1 = 0 ;
5716 int temp2 ;
5717 int res2 = 0 ;
5718 char *kwnames[] = {
5719 NULL
5720 };
5721
5722 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5723 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5725 {
5726 if (!wxPyCheckForApp()) SWIG_fail;
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 wxDisplaySizeMM(arg1,arg2);
5729
5730 wxPyEndAllowThreads(__tstate);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 Py_INCREF(Py_None); resultobj = Py_None;
5734 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5735 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5736 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5737 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5738 return resultobj;
5739 fail:
5740 return NULL;
5741 }
5742
5743
5744 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5745 PyObject *resultobj;
5746 wxSize result;
5747 char *kwnames[] = {
5748 NULL
5749 };
5750
5751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5752 {
5753 if (!wxPyCheckForApp()) SWIG_fail;
5754 PyThreadState* __tstate = wxPyBeginAllowThreads();
5755 result = wxGetDisplaySizeMM();
5756
5757 wxPyEndAllowThreads(__tstate);
5758 if (PyErr_Occurred()) SWIG_fail;
5759 }
5760 {
5761 wxSize * resultptr;
5762 resultptr = new wxSize((wxSize &)(result));
5763 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5764 }
5765 return resultobj;
5766 fail:
5767 return NULL;
5768 }
5769
5770
5771 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5772 PyObject *resultobj;
5773 int *arg1 = (int *) 0 ;
5774 int *arg2 = (int *) 0 ;
5775 int *arg3 = (int *) 0 ;
5776 int *arg4 = (int *) 0 ;
5777 int temp1 ;
5778 int res1 = 0 ;
5779 int temp2 ;
5780 int res2 = 0 ;
5781 int temp3 ;
5782 int res3 = 0 ;
5783 int temp4 ;
5784 int res4 = 0 ;
5785 char *kwnames[] = {
5786 NULL
5787 };
5788
5789 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5790 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5791 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5792 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5794 {
5795 if (!wxPyCheckForApp()) SWIG_fail;
5796 PyThreadState* __tstate = wxPyBeginAllowThreads();
5797 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5798
5799 wxPyEndAllowThreads(__tstate);
5800 if (PyErr_Occurred()) SWIG_fail;
5801 }
5802 Py_INCREF(Py_None); resultobj = Py_None;
5803 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5804 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5805 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5806 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5807 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5808 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5809 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5810 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5811 return resultobj;
5812 fail:
5813 return NULL;
5814 }
5815
5816
5817 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj;
5819 wxRect result;
5820 char *kwnames[] = {
5821 NULL
5822 };
5823
5824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5825 {
5826 if (!wxPyCheckForApp()) SWIG_fail;
5827 PyThreadState* __tstate = wxPyBeginAllowThreads();
5828 result = wxGetClientDisplayRect();
5829
5830 wxPyEndAllowThreads(__tstate);
5831 if (PyErr_Occurred()) SWIG_fail;
5832 }
5833 {
5834 wxRect * resultptr;
5835 resultptr = new wxRect((wxRect &)(result));
5836 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5837 }
5838 return resultobj;
5839 fail:
5840 return NULL;
5841 }
5842
5843
5844 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5845 PyObject *resultobj;
5846 wxCursor *arg1 = 0 ;
5847 PyObject * obj0 = 0 ;
5848 char *kwnames[] = {
5849 (char *) "cursor", NULL
5850 };
5851
5852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5853 {
5854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5855 if (SWIG_arg_fail(1)) SWIG_fail;
5856 if (arg1 == NULL) {
5857 SWIG_null_ref("wxCursor");
5858 }
5859 if (SWIG_arg_fail(1)) SWIG_fail;
5860 }
5861 {
5862 if (!wxPyCheckForApp()) SWIG_fail;
5863 PyThreadState* __tstate = wxPyBeginAllowThreads();
5864 wxSetCursor(*arg1);
5865
5866 wxPyEndAllowThreads(__tstate);
5867 if (PyErr_Occurred()) SWIG_fail;
5868 }
5869 Py_INCREF(Py_None); resultobj = Py_None;
5870 return resultobj;
5871 fail:
5872 return NULL;
5873 }
5874
5875
5876 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5877 PyObject *resultobj;
5878 void *result;
5879 char *kwnames[] = {
5880 NULL
5881 };
5882
5883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5884 {
5885 if (!wxPyCheckForApp()) SWIG_fail;
5886 PyThreadState* __tstate = wxPyBeginAllowThreads();
5887 result = (void *)wxGetXDisplay();
5888
5889 wxPyEndAllowThreads(__tstate);
5890 if (PyErr_Occurred()) SWIG_fail;
5891 }
5892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5893 return resultobj;
5894 fail:
5895 return NULL;
5896 }
5897
5898
5899 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5900 PyObject *resultobj;
5901 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5902 PyObject * obj0 = 0 ;
5903 char *kwnames[] = {
5904 (char *) "cursor", NULL
5905 };
5906
5907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5908 if (obj0) {
5909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5910 if (SWIG_arg_fail(1)) SWIG_fail;
5911 }
5912 {
5913 if (!wxPyCheckForApp()) SWIG_fail;
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 wxBeginBusyCursor(arg1);
5916
5917 wxPyEndAllowThreads(__tstate);
5918 if (PyErr_Occurred()) SWIG_fail;
5919 }
5920 Py_INCREF(Py_None); resultobj = Py_None;
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj;
5929 wxWindow *result;
5930 char *kwnames[] = {
5931 NULL
5932 };
5933
5934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5935 {
5936 if (!wxPyCheckForApp()) SWIG_fail;
5937 PyThreadState* __tstate = wxPyBeginAllowThreads();
5938 result = (wxWindow *)wxGetActiveWindow();
5939
5940 wxPyEndAllowThreads(__tstate);
5941 if (PyErr_Occurred()) SWIG_fail;
5942 }
5943 {
5944 resultobj = wxPyMake_wxObject(result, 0);
5945 }
5946 return resultobj;
5947 fail:
5948 return NULL;
5949 }
5950
5951
5952 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5953 PyObject *resultobj;
5954 wxPoint *arg1 = 0 ;
5955 wxWindow *result;
5956 wxPoint temp1 ;
5957 PyObject * obj0 = 0 ;
5958 char *kwnames[] = {
5959 (char *) "pt", NULL
5960 };
5961
5962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5963 {
5964 arg1 = &temp1;
5965 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5966 }
5967 {
5968 if (!wxPyCheckForApp()) SWIG_fail;
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5971
5972 wxPyEndAllowThreads(__tstate);
5973 if (PyErr_Occurred()) SWIG_fail;
5974 }
5975 {
5976 resultobj = wxPyMake_wxObject(result, 0);
5977 }
5978 return resultobj;
5979 fail:
5980 return NULL;
5981 }
5982
5983
5984 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5985 PyObject *resultobj;
5986 wxPoint *arg1 = 0 ;
5987 wxWindow *result;
5988 wxPoint temp1 ;
5989 PyObject * obj0 = 0 ;
5990 char *kwnames[] = {
5991 (char *) "pt", NULL
5992 };
5993
5994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5995 {
5996 arg1 = &temp1;
5997 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5998 }
5999 {
6000 if (!wxPyCheckForApp()) SWIG_fail;
6001 PyThreadState* __tstate = wxPyBeginAllowThreads();
6002 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6003
6004 wxPyEndAllowThreads(__tstate);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 {
6008 resultobj = wxPyMake_wxObject(result, 0);
6009 }
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj;
6018 wxWindow *arg1 = (wxWindow *) 0 ;
6019 wxWindow *result;
6020 PyObject * obj0 = 0 ;
6021 char *kwnames[] = {
6022 (char *) "win", NULL
6023 };
6024
6025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6027 if (SWIG_arg_fail(1)) SWIG_fail;
6028 {
6029 if (!wxPyCheckForApp()) SWIG_fail;
6030 PyThreadState* __tstate = wxPyBeginAllowThreads();
6031 result = (wxWindow *)wxGetTopLevelParent(arg1);
6032
6033 wxPyEndAllowThreads(__tstate);
6034 if (PyErr_Occurred()) SWIG_fail;
6035 }
6036 {
6037 resultobj = wxPyMake_wxObject(result, 0);
6038 }
6039 return resultobj;
6040 fail:
6041 return NULL;
6042 }
6043
6044
6045 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6046 PyObject *resultobj;
6047 wxString *arg1 = 0 ;
6048 bool result;
6049 bool temp1 = false ;
6050 PyObject * obj0 = 0 ;
6051 char *kwnames[] = {
6052 (char *) "url", NULL
6053 };
6054
6055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6056 {
6057 arg1 = wxString_in_helper(obj0);
6058 if (arg1 == NULL) SWIG_fail;
6059 temp1 = true;
6060 }
6061 {
6062 PyThreadState* __tstate = wxPyBeginAllowThreads();
6063 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6064
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 {
6069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6070 }
6071 {
6072 if (temp1)
6073 delete arg1;
6074 }
6075 return resultobj;
6076 fail:
6077 {
6078 if (temp1)
6079 delete arg1;
6080 }
6081 return NULL;
6082 }
6083
6084
6085 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6086 PyObject *resultobj;
6087 wxKeyCode arg1 ;
6088 bool result;
6089 PyObject * obj0 = 0 ;
6090 char *kwnames[] = {
6091 (char *) "key", NULL
6092 };
6093
6094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6095 {
6096 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6097 if (SWIG_arg_fail(1)) SWIG_fail;
6098 }
6099 {
6100 if (!wxPyCheckForApp()) SWIG_fail;
6101 PyThreadState* __tstate = wxPyBeginAllowThreads();
6102 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6103
6104 wxPyEndAllowThreads(__tstate);
6105 if (PyErr_Occurred()) SWIG_fail;
6106 }
6107 {
6108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6109 }
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj;
6118 char *kwnames[] = {
6119 NULL
6120 };
6121
6122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6123 {
6124 if (!wxPyCheckForApp()) SWIG_fail;
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 wxWakeUpMainThread();
6127
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 Py_INCREF(Py_None); resultobj = Py_None;
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6139 PyObject *resultobj;
6140 char *kwnames[] = {
6141 NULL
6142 };
6143
6144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6145 {
6146 if (!wxPyCheckForApp()) SWIG_fail;
6147 PyThreadState* __tstate = wxPyBeginAllowThreads();
6148 wxMutexGuiEnter();
6149
6150 wxPyEndAllowThreads(__tstate);
6151 if (PyErr_Occurred()) SWIG_fail;
6152 }
6153 Py_INCREF(Py_None); resultobj = Py_None;
6154 return resultobj;
6155 fail:
6156 return NULL;
6157 }
6158
6159
6160 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj;
6162 char *kwnames[] = {
6163 NULL
6164 };
6165
6166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6167 {
6168 if (!wxPyCheckForApp()) SWIG_fail;
6169 PyThreadState* __tstate = wxPyBeginAllowThreads();
6170 wxMutexGuiLeave();
6171
6172 wxPyEndAllowThreads(__tstate);
6173 if (PyErr_Occurred()) SWIG_fail;
6174 }
6175 Py_INCREF(Py_None); resultobj = Py_None;
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj;
6184 wxMutexGuiLocker *result;
6185 char *kwnames[] = {
6186 NULL
6187 };
6188
6189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6190 {
6191 if (!wxPyCheckForApp()) SWIG_fail;
6192 PyThreadState* __tstate = wxPyBeginAllowThreads();
6193 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6194
6195 wxPyEndAllowThreads(__tstate);
6196 if (PyErr_Occurred()) SWIG_fail;
6197 }
6198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6199 return resultobj;
6200 fail:
6201 return NULL;
6202 }
6203
6204
6205 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6206 PyObject *resultobj;
6207 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6208 PyObject * obj0 = 0 ;
6209 char *kwnames[] = {
6210 (char *) "self", NULL
6211 };
6212
6213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6215 if (SWIG_arg_fail(1)) SWIG_fail;
6216 {
6217 PyThreadState* __tstate = wxPyBeginAllowThreads();
6218 delete arg1;
6219
6220 wxPyEndAllowThreads(__tstate);
6221 if (PyErr_Occurred()) SWIG_fail;
6222 }
6223 Py_INCREF(Py_None); resultobj = Py_None;
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6231 PyObject *obj;
6232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6233 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6234 Py_INCREF(obj);
6235 return Py_BuildValue((char *)"");
6236 }
6237 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6238 PyObject *resultobj;
6239 bool result;
6240 char *kwnames[] = {
6241 NULL
6242 };
6243
6244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6245 {
6246 PyThreadState* __tstate = wxPyBeginAllowThreads();
6247 result = (bool)wxThread_IsMain();
6248
6249 wxPyEndAllowThreads(__tstate);
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 {
6253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6254 }
6255 return resultobj;
6256 fail:
6257 return NULL;
6258 }
6259
6260
6261 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6262 PyObject *resultobj;
6263 wxString *arg1 = 0 ;
6264 wxToolTip *result;
6265 bool temp1 = false ;
6266 PyObject * obj0 = 0 ;
6267 char *kwnames[] = {
6268 (char *) "tip", NULL
6269 };
6270
6271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6272 {
6273 arg1 = wxString_in_helper(obj0);
6274 if (arg1 == NULL) SWIG_fail;
6275 temp1 = true;
6276 }
6277 {
6278 if (!wxPyCheckForApp()) SWIG_fail;
6279 PyThreadState* __tstate = wxPyBeginAllowThreads();
6280 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6281
6282 wxPyEndAllowThreads(__tstate);
6283 if (PyErr_Occurred()) SWIG_fail;
6284 }
6285 {
6286 resultobj = wxPyMake_wxObject(result, 1);
6287 }
6288 {
6289 if (temp1)
6290 delete arg1;
6291 }
6292 return resultobj;
6293 fail:
6294 {
6295 if (temp1)
6296 delete arg1;
6297 }
6298 return NULL;
6299 }
6300
6301
6302 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj;
6304 wxToolTip *arg1 = (wxToolTip *) 0 ;
6305 wxString *arg2 = 0 ;
6306 bool temp2 = false ;
6307 PyObject * obj0 = 0 ;
6308 PyObject * obj1 = 0 ;
6309 char *kwnames[] = {
6310 (char *) "self",(char *) "tip", NULL
6311 };
6312
6313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6315 if (SWIG_arg_fail(1)) SWIG_fail;
6316 {
6317 arg2 = wxString_in_helper(obj1);
6318 if (arg2 == NULL) SWIG_fail;
6319 temp2 = true;
6320 }
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 (arg1)->SetTip((wxString const &)*arg2);
6324
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 Py_INCREF(Py_None); resultobj = Py_None;
6329 {
6330 if (temp2)
6331 delete arg2;
6332 }
6333 return resultobj;
6334 fail:
6335 {
6336 if (temp2)
6337 delete arg2;
6338 }
6339 return NULL;
6340 }
6341
6342
6343 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6344 PyObject *resultobj;
6345 wxToolTip *arg1 = (wxToolTip *) 0 ;
6346 wxString result;
6347 PyObject * obj0 = 0 ;
6348 char *kwnames[] = {
6349 (char *) "self", NULL
6350 };
6351
6352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6354 if (SWIG_arg_fail(1)) SWIG_fail;
6355 {
6356 PyThreadState* __tstate = wxPyBeginAllowThreads();
6357 result = (arg1)->GetTip();
6358
6359 wxPyEndAllowThreads(__tstate);
6360 if (PyErr_Occurred()) SWIG_fail;
6361 }
6362 {
6363 #if wxUSE_UNICODE
6364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6365 #else
6366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6367 #endif
6368 }
6369 return resultobj;
6370 fail:
6371 return NULL;
6372 }
6373
6374
6375 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6376 PyObject *resultobj;
6377 wxToolTip *arg1 = (wxToolTip *) 0 ;
6378 wxWindow *result;
6379 PyObject * obj0 = 0 ;
6380 char *kwnames[] = {
6381 (char *) "self", NULL
6382 };
6383
6384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6386 if (SWIG_arg_fail(1)) SWIG_fail;
6387 {
6388 PyThreadState* __tstate = wxPyBeginAllowThreads();
6389 result = (wxWindow *)(arg1)->GetWindow();
6390
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 {
6395 resultobj = wxPyMake_wxObject(result, 0);
6396 }
6397 return resultobj;
6398 fail:
6399 return NULL;
6400 }
6401
6402
6403 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj;
6405 bool arg1 ;
6406 PyObject * obj0 = 0 ;
6407 char *kwnames[] = {
6408 (char *) "flag", NULL
6409 };
6410
6411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6412 {
6413 arg1 = (bool)(SWIG_As_bool(obj0));
6414 if (SWIG_arg_fail(1)) SWIG_fail;
6415 }
6416 {
6417 PyThreadState* __tstate = wxPyBeginAllowThreads();
6418 wxToolTip::Enable(arg1);
6419
6420 wxPyEndAllowThreads(__tstate);
6421 if (PyErr_Occurred()) SWIG_fail;
6422 }
6423 Py_INCREF(Py_None); resultobj = Py_None;
6424 return resultobj;
6425 fail:
6426 return NULL;
6427 }
6428
6429
6430 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6431 PyObject *resultobj;
6432 long arg1 ;
6433 PyObject * obj0 = 0 ;
6434 char *kwnames[] = {
6435 (char *) "milliseconds", NULL
6436 };
6437
6438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6439 {
6440 arg1 = (long)(SWIG_As_long(obj0));
6441 if (SWIG_arg_fail(1)) SWIG_fail;
6442 }
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 wxToolTip::SetDelay(arg1);
6446
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 Py_INCREF(Py_None); resultobj = Py_None;
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6458 PyObject *obj;
6459 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6460 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6461 Py_INCREF(obj);
6462 return Py_BuildValue((char *)"");
6463 }
6464 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6465 PyObject *resultobj;
6466 wxWindow *arg1 = (wxWindow *) 0 ;
6467 wxSize *arg2 = 0 ;
6468 wxCaret *result;
6469 wxSize temp2 ;
6470 PyObject * obj0 = 0 ;
6471 PyObject * obj1 = 0 ;
6472 char *kwnames[] = {
6473 (char *) "window",(char *) "size", NULL
6474 };
6475
6476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6478 if (SWIG_arg_fail(1)) SWIG_fail;
6479 {
6480 arg2 = &temp2;
6481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6482 }
6483 {
6484 if (!wxPyCheckForApp()) SWIG_fail;
6485 PyThreadState* __tstate = wxPyBeginAllowThreads();
6486 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6487
6488 wxPyEndAllowThreads(__tstate);
6489 if (PyErr_Occurred()) SWIG_fail;
6490 }
6491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6492 return resultobj;
6493 fail:
6494 return NULL;
6495 }
6496
6497
6498 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6499 PyObject *resultobj;
6500 wxCaret *arg1 = (wxCaret *) 0 ;
6501 PyObject * obj0 = 0 ;
6502 char *kwnames[] = {
6503 (char *) "self", NULL
6504 };
6505
6506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6508 if (SWIG_arg_fail(1)) SWIG_fail;
6509 {
6510 PyThreadState* __tstate = wxPyBeginAllowThreads();
6511 wxCaret_Destroy(arg1);
6512
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 Py_INCREF(Py_None); resultobj = Py_None;
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6524 PyObject *resultobj;
6525 wxCaret *arg1 = (wxCaret *) 0 ;
6526 bool result;
6527 PyObject * obj0 = 0 ;
6528 char *kwnames[] = {
6529 (char *) "self", NULL
6530 };
6531
6532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6534 if (SWIG_arg_fail(1)) SWIG_fail;
6535 {
6536 PyThreadState* __tstate = wxPyBeginAllowThreads();
6537 result = (bool)(arg1)->IsOk();
6538
6539 wxPyEndAllowThreads(__tstate);
6540 if (PyErr_Occurred()) SWIG_fail;
6541 }
6542 {
6543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6544 }
6545 return resultobj;
6546 fail:
6547 return NULL;
6548 }
6549
6550
6551 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6552 PyObject *resultobj;
6553 wxCaret *arg1 = (wxCaret *) 0 ;
6554 bool result;
6555 PyObject * obj0 = 0 ;
6556 char *kwnames[] = {
6557 (char *) "self", NULL
6558 };
6559
6560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6562 if (SWIG_arg_fail(1)) SWIG_fail;
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 result = (bool)(arg1)->IsVisible();
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 {
6571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6572 }
6573 return resultobj;
6574 fail:
6575 return NULL;
6576 }
6577
6578
6579 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6580 PyObject *resultobj;
6581 wxCaret *arg1 = (wxCaret *) 0 ;
6582 wxPoint result;
6583 PyObject * obj0 = 0 ;
6584 char *kwnames[] = {
6585 (char *) "self", NULL
6586 };
6587
6588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6590 if (SWIG_arg_fail(1)) SWIG_fail;
6591 {
6592 PyThreadState* __tstate = wxPyBeginAllowThreads();
6593 result = (arg1)->GetPosition();
6594
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 {
6599 wxPoint * resultptr;
6600 resultptr = new wxPoint((wxPoint &)(result));
6601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6602 }
6603 return resultobj;
6604 fail:
6605 return NULL;
6606 }
6607
6608
6609 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6610 PyObject *resultobj;
6611 wxCaret *arg1 = (wxCaret *) 0 ;
6612 int *arg2 = (int *) 0 ;
6613 int *arg3 = (int *) 0 ;
6614 int temp2 ;
6615 int res2 = 0 ;
6616 int temp3 ;
6617 int res3 = 0 ;
6618 PyObject * obj0 = 0 ;
6619 char *kwnames[] = {
6620 (char *) "self", NULL
6621 };
6622
6623 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6624 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6627 if (SWIG_arg_fail(1)) SWIG_fail;
6628 {
6629 PyThreadState* __tstate = wxPyBeginAllowThreads();
6630 (arg1)->GetPosition(arg2,arg3);
6631
6632 wxPyEndAllowThreads(__tstate);
6633 if (PyErr_Occurred()) SWIG_fail;
6634 }
6635 Py_INCREF(Py_None); resultobj = Py_None;
6636 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6637 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6638 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6639 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6640 return resultobj;
6641 fail:
6642 return NULL;
6643 }
6644
6645
6646 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6647 PyObject *resultobj;
6648 wxCaret *arg1 = (wxCaret *) 0 ;
6649 wxSize result;
6650 PyObject * obj0 = 0 ;
6651 char *kwnames[] = {
6652 (char *) "self", NULL
6653 };
6654
6655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6657 if (SWIG_arg_fail(1)) SWIG_fail;
6658 {
6659 PyThreadState* __tstate = wxPyBeginAllowThreads();
6660 result = (arg1)->GetSize();
6661
6662 wxPyEndAllowThreads(__tstate);
6663 if (PyErr_Occurred()) SWIG_fail;
6664 }
6665 {
6666 wxSize * resultptr;
6667 resultptr = new wxSize((wxSize &)(result));
6668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6669 }
6670 return resultobj;
6671 fail:
6672 return NULL;
6673 }
6674
6675
6676 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6677 PyObject *resultobj;
6678 wxCaret *arg1 = (wxCaret *) 0 ;
6679 int *arg2 = (int *) 0 ;
6680 int *arg3 = (int *) 0 ;
6681 int temp2 ;
6682 int res2 = 0 ;
6683 int temp3 ;
6684 int res3 = 0 ;
6685 PyObject * obj0 = 0 ;
6686 char *kwnames[] = {
6687 (char *) "self", NULL
6688 };
6689
6690 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6691 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6694 if (SWIG_arg_fail(1)) SWIG_fail;
6695 {
6696 PyThreadState* __tstate = wxPyBeginAllowThreads();
6697 (arg1)->GetSize(arg2,arg3);
6698
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 Py_INCREF(Py_None); resultobj = Py_None;
6703 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6704 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6705 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6706 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj;
6715 wxCaret *arg1 = (wxCaret *) 0 ;
6716 wxWindow *result;
6717 PyObject * obj0 = 0 ;
6718 char *kwnames[] = {
6719 (char *) "self", NULL
6720 };
6721
6722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6724 if (SWIG_arg_fail(1)) SWIG_fail;
6725 {
6726 PyThreadState* __tstate = wxPyBeginAllowThreads();
6727 result = (wxWindow *)(arg1)->GetWindow();
6728
6729 wxPyEndAllowThreads(__tstate);
6730 if (PyErr_Occurred()) SWIG_fail;
6731 }
6732 {
6733 resultobj = wxPyMake_wxObject(result, 0);
6734 }
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6742 PyObject *resultobj;
6743 wxCaret *arg1 = (wxCaret *) 0 ;
6744 int arg2 ;
6745 int arg3 ;
6746 PyObject * obj0 = 0 ;
6747 PyObject * obj1 = 0 ;
6748 PyObject * obj2 = 0 ;
6749 char *kwnames[] = {
6750 (char *) "self",(char *) "x",(char *) "y", NULL
6751 };
6752
6753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6755 if (SWIG_arg_fail(1)) SWIG_fail;
6756 {
6757 arg2 = (int)(SWIG_As_int(obj1));
6758 if (SWIG_arg_fail(2)) SWIG_fail;
6759 }
6760 {
6761 arg3 = (int)(SWIG_As_int(obj2));
6762 if (SWIG_arg_fail(3)) SWIG_fail;
6763 }
6764 {
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 (arg1)->Move(arg2,arg3);
6767
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 Py_INCREF(Py_None); resultobj = Py_None;
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6779 PyObject *resultobj;
6780 wxCaret *arg1 = (wxCaret *) 0 ;
6781 wxPoint *arg2 = 0 ;
6782 wxPoint temp2 ;
6783 PyObject * obj0 = 0 ;
6784 PyObject * obj1 = 0 ;
6785 char *kwnames[] = {
6786 (char *) "self",(char *) "pt", NULL
6787 };
6788
6789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6791 if (SWIG_arg_fail(1)) SWIG_fail;
6792 {
6793 arg2 = &temp2;
6794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6795 }
6796 {
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 (arg1)->Move((wxPoint const &)*arg2);
6799
6800 wxPyEndAllowThreads(__tstate);
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 Py_INCREF(Py_None); resultobj = Py_None;
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj;
6812 wxCaret *arg1 = (wxCaret *) 0 ;
6813 int arg2 ;
6814 int arg3 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 PyObject * obj2 = 0 ;
6818 char *kwnames[] = {
6819 (char *) "self",(char *) "width",(char *) "height", NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6824 if (SWIG_arg_fail(1)) SWIG_fail;
6825 {
6826 arg2 = (int)(SWIG_As_int(obj1));
6827 if (SWIG_arg_fail(2)) SWIG_fail;
6828 }
6829 {
6830 arg3 = (int)(SWIG_As_int(obj2));
6831 if (SWIG_arg_fail(3)) SWIG_fail;
6832 }
6833 {
6834 PyThreadState* __tstate = wxPyBeginAllowThreads();
6835 (arg1)->SetSize(arg2,arg3);
6836
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 Py_INCREF(Py_None); resultobj = Py_None;
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6848 PyObject *resultobj;
6849 wxCaret *arg1 = (wxCaret *) 0 ;
6850 wxSize *arg2 = 0 ;
6851 wxSize temp2 ;
6852 PyObject * obj0 = 0 ;
6853 PyObject * obj1 = 0 ;
6854 char *kwnames[] = {
6855 (char *) "self",(char *) "size", NULL
6856 };
6857
6858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6860 if (SWIG_arg_fail(1)) SWIG_fail;
6861 {
6862 arg2 = &temp2;
6863 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6864 }
6865 {
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 (arg1)->SetSize((wxSize const &)*arg2);
6868
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 Py_INCREF(Py_None); resultobj = Py_None;
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6880 PyObject *resultobj;
6881 wxCaret *arg1 = (wxCaret *) 0 ;
6882 int arg2 = (int) true ;
6883 PyObject * obj0 = 0 ;
6884 PyObject * obj1 = 0 ;
6885 char *kwnames[] = {
6886 (char *) "self",(char *) "show", NULL
6887 };
6888
6889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6891 if (SWIG_arg_fail(1)) SWIG_fail;
6892 if (obj1) {
6893 {
6894 arg2 = (int)(SWIG_As_int(obj1));
6895 if (SWIG_arg_fail(2)) SWIG_fail;
6896 }
6897 }
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 (arg1)->Show(arg2);
6901
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 Py_INCREF(Py_None); resultobj = Py_None;
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6913 PyObject *resultobj;
6914 wxCaret *arg1 = (wxCaret *) 0 ;
6915 PyObject * obj0 = 0 ;
6916 char *kwnames[] = {
6917 (char *) "self", NULL
6918 };
6919
6920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6922 if (SWIG_arg_fail(1)) SWIG_fail;
6923 {
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 (arg1)->Hide();
6926
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 Py_INCREF(Py_None); resultobj = Py_None;
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6938 PyObject *resultobj;
6939 int result;
6940 char *kwnames[] = {
6941 NULL
6942 };
6943
6944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6945 {
6946 PyThreadState* __tstate = wxPyBeginAllowThreads();
6947 result = (int)wxCaret::GetBlinkTime();
6948
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 {
6953 resultobj = SWIG_From_int((int)(result));
6954 }
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj;
6963 int arg1 ;
6964 PyObject * obj0 = 0 ;
6965 char *kwnames[] = {
6966 (char *) "milliseconds", NULL
6967 };
6968
6969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6970 {
6971 arg1 = (int)(SWIG_As_int(obj0));
6972 if (SWIG_arg_fail(1)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 wxCaret::SetBlinkTime(arg1);
6977
6978 wxPyEndAllowThreads(__tstate);
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 Py_INCREF(Py_None); resultobj = Py_None;
6982 return resultobj;
6983 fail:
6984 return NULL;
6985 }
6986
6987
6988 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6989 PyObject *obj;
6990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6991 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6992 Py_INCREF(obj);
6993 return Py_BuildValue((char *)"");
6994 }
6995 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6996 PyObject *resultobj;
6997 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6998 wxBusyCursor *result;
6999 PyObject * obj0 = 0 ;
7000 char *kwnames[] = {
7001 (char *) "cursor", NULL
7002 };
7003
7004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7005 if (obj0) {
7006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7007 if (SWIG_arg_fail(1)) SWIG_fail;
7008 }
7009 {
7010 if (!wxPyCheckForApp()) SWIG_fail;
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7013
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7025 PyObject *resultobj;
7026 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7027 PyObject * obj0 = 0 ;
7028 char *kwnames[] = {
7029 (char *) "self", NULL
7030 };
7031
7032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7034 if (SWIG_arg_fail(1)) SWIG_fail;
7035 {
7036 PyThreadState* __tstate = wxPyBeginAllowThreads();
7037 delete arg1;
7038
7039 wxPyEndAllowThreads(__tstate);
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 Py_INCREF(Py_None); resultobj = Py_None;
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7050 PyObject *obj;
7051 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7052 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7053 Py_INCREF(obj);
7054 return Py_BuildValue((char *)"");
7055 }
7056 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7057 PyObject *resultobj;
7058 wxWindow *arg1 = (wxWindow *) NULL ;
7059 wxWindowDisabler *result;
7060 PyObject * obj0 = 0 ;
7061 char *kwnames[] = {
7062 (char *) "winToSkip", NULL
7063 };
7064
7065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7066 if (obj0) {
7067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7068 if (SWIG_arg_fail(1)) SWIG_fail;
7069 }
7070 {
7071 if (!wxPyCheckForApp()) SWIG_fail;
7072 PyThreadState* __tstate = wxPyBeginAllowThreads();
7073 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7074
7075 wxPyEndAllowThreads(__tstate);
7076 if (PyErr_Occurred()) SWIG_fail;
7077 }
7078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7079 return resultobj;
7080 fail:
7081 return NULL;
7082 }
7083
7084
7085 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7086 PyObject *resultobj;
7087 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7088 PyObject * obj0 = 0 ;
7089 char *kwnames[] = {
7090 (char *) "self", NULL
7091 };
7092
7093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7095 if (SWIG_arg_fail(1)) SWIG_fail;
7096 {
7097 PyThreadState* __tstate = wxPyBeginAllowThreads();
7098 delete arg1;
7099
7100 wxPyEndAllowThreads(__tstate);
7101 if (PyErr_Occurred()) SWIG_fail;
7102 }
7103 Py_INCREF(Py_None); resultobj = Py_None;
7104 return resultobj;
7105 fail:
7106 return NULL;
7107 }
7108
7109
7110 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7111 PyObject *obj;
7112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7113 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7114 Py_INCREF(obj);
7115 return Py_BuildValue((char *)"");
7116 }
7117 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7118 PyObject *resultobj;
7119 wxString *arg1 = 0 ;
7120 wxBusyInfo *result;
7121 bool temp1 = false ;
7122 PyObject * obj0 = 0 ;
7123 char *kwnames[] = {
7124 (char *) "message", NULL
7125 };
7126
7127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7128 {
7129 arg1 = wxString_in_helper(obj0);
7130 if (arg1 == NULL) SWIG_fail;
7131 temp1 = true;
7132 }
7133 {
7134 if (!wxPyCheckForApp()) SWIG_fail;
7135 PyThreadState* __tstate = wxPyBeginAllowThreads();
7136 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7137
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7142 {
7143 if (temp1)
7144 delete arg1;
7145 }
7146 return resultobj;
7147 fail:
7148 {
7149 if (temp1)
7150 delete arg1;
7151 }
7152 return NULL;
7153 }
7154
7155
7156 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7157 PyObject *resultobj;
7158 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7159 PyObject * obj0 = 0 ;
7160 char *kwnames[] = {
7161 (char *) "self", NULL
7162 };
7163
7164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7166 if (SWIG_arg_fail(1)) SWIG_fail;
7167 {
7168 PyThreadState* __tstate = wxPyBeginAllowThreads();
7169 delete arg1;
7170
7171 wxPyEndAllowThreads(__tstate);
7172 if (PyErr_Occurred()) SWIG_fail;
7173 }
7174 Py_INCREF(Py_None); resultobj = Py_None;
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7182 PyObject *obj;
7183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7184 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7185 Py_INCREF(obj);
7186 return Py_BuildValue((char *)"");
7187 }
7188 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7189 PyObject *resultobj;
7190 wxStopWatch *result;
7191 char *kwnames[] = {
7192 NULL
7193 };
7194
7195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7196 {
7197 PyThreadState* __tstate = wxPyBeginAllowThreads();
7198 result = (wxStopWatch *)new wxStopWatch();
7199
7200 wxPyEndAllowThreads(__tstate);
7201 if (PyErr_Occurred()) SWIG_fail;
7202 }
7203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7204 return resultobj;
7205 fail:
7206 return NULL;
7207 }
7208
7209
7210 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7211 PyObject *resultobj;
7212 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7213 long arg2 = (long) 0 ;
7214 PyObject * obj0 = 0 ;
7215 PyObject * obj1 = 0 ;
7216 char *kwnames[] = {
7217 (char *) "self",(char *) "t0", NULL
7218 };
7219
7220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7222 if (SWIG_arg_fail(1)) SWIG_fail;
7223 if (obj1) {
7224 {
7225 arg2 = (long)(SWIG_As_long(obj1));
7226 if (SWIG_arg_fail(2)) SWIG_fail;
7227 }
7228 }
7229 {
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 (arg1)->Start(arg2);
7232
7233 wxPyEndAllowThreads(__tstate);
7234 if (PyErr_Occurred()) SWIG_fail;
7235 }
7236 Py_INCREF(Py_None); resultobj = Py_None;
7237 return resultobj;
7238 fail:
7239 return NULL;
7240 }
7241
7242
7243 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7244 PyObject *resultobj;
7245 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7246 PyObject * obj0 = 0 ;
7247 char *kwnames[] = {
7248 (char *) "self", NULL
7249 };
7250
7251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7253 if (SWIG_arg_fail(1)) SWIG_fail;
7254 {
7255 PyThreadState* __tstate = wxPyBeginAllowThreads();
7256 (arg1)->Pause();
7257
7258 wxPyEndAllowThreads(__tstate);
7259 if (PyErr_Occurred()) SWIG_fail;
7260 }
7261 Py_INCREF(Py_None); resultobj = Py_None;
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj;
7270 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7271 PyObject * obj0 = 0 ;
7272 char *kwnames[] = {
7273 (char *) "self", NULL
7274 };
7275
7276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7278 if (SWIG_arg_fail(1)) SWIG_fail;
7279 {
7280 PyThreadState* __tstate = wxPyBeginAllowThreads();
7281 (arg1)->Resume();
7282
7283 wxPyEndAllowThreads(__tstate);
7284 if (PyErr_Occurred()) SWIG_fail;
7285 }
7286 Py_INCREF(Py_None); resultobj = Py_None;
7287 return resultobj;
7288 fail:
7289 return NULL;
7290 }
7291
7292
7293 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7294 PyObject *resultobj;
7295 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7296 long result;
7297 PyObject * obj0 = 0 ;
7298 char *kwnames[] = {
7299 (char *) "self", NULL
7300 };
7301
7302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7304 if (SWIG_arg_fail(1)) SWIG_fail;
7305 {
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (long)((wxStopWatch const *)arg1)->Time();
7308
7309 wxPyEndAllowThreads(__tstate);
7310 if (PyErr_Occurred()) SWIG_fail;
7311 }
7312 {
7313 resultobj = SWIG_From_long((long)(result));
7314 }
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7322 PyObject *obj;
7323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7324 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7325 Py_INCREF(obj);
7326 return Py_BuildValue((char *)"");
7327 }
7328 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7329 PyObject *resultobj;
7330 int arg1 = (int) 9 ;
7331 int arg2 = (int) wxID_FILE1 ;
7332 wxFileHistory *result;
7333 PyObject * obj0 = 0 ;
7334 PyObject * obj1 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "maxFiles",(char *) "idBase", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7340 if (obj0) {
7341 {
7342 arg1 = (int)(SWIG_As_int(obj0));
7343 if (SWIG_arg_fail(1)) SWIG_fail;
7344 }
7345 }
7346 if (obj1) {
7347 {
7348 arg2 = (int)(SWIG_As_int(obj1));
7349 if (SWIG_arg_fail(2)) SWIG_fail;
7350 }
7351 }
7352 {
7353 PyThreadState* __tstate = wxPyBeginAllowThreads();
7354 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7355
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7367 PyObject *resultobj;
7368 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7369 PyObject * obj0 = 0 ;
7370 char *kwnames[] = {
7371 (char *) "self", NULL
7372 };
7373
7374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7376 if (SWIG_arg_fail(1)) SWIG_fail;
7377 {
7378 PyThreadState* __tstate = wxPyBeginAllowThreads();
7379 delete arg1;
7380
7381 wxPyEndAllowThreads(__tstate);
7382 if (PyErr_Occurred()) SWIG_fail;
7383 }
7384 Py_INCREF(Py_None); resultobj = Py_None;
7385 return resultobj;
7386 fail:
7387 return NULL;
7388 }
7389
7390
7391 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7392 PyObject *resultobj;
7393 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7394 wxString *arg2 = 0 ;
7395 bool temp2 = false ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char *kwnames[] = {
7399 (char *) "self",(char *) "file", NULL
7400 };
7401
7402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(1)) SWIG_fail;
7405 {
7406 arg2 = wxString_in_helper(obj1);
7407 if (arg2 == NULL) SWIG_fail;
7408 temp2 = true;
7409 }
7410 {
7411 PyThreadState* __tstate = wxPyBeginAllowThreads();
7412 (arg1)->AddFileToHistory((wxString const &)*arg2);
7413
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 Py_INCREF(Py_None); resultobj = Py_None;
7418 {
7419 if (temp2)
7420 delete arg2;
7421 }
7422 return resultobj;
7423 fail:
7424 {
7425 if (temp2)
7426 delete arg2;
7427 }
7428 return NULL;
7429 }
7430
7431
7432 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7433 PyObject *resultobj;
7434 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7435 int arg2 ;
7436 PyObject * obj0 = 0 ;
7437 PyObject * obj1 = 0 ;
7438 char *kwnames[] = {
7439 (char *) "self",(char *) "i", NULL
7440 };
7441
7442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7444 if (SWIG_arg_fail(1)) SWIG_fail;
7445 {
7446 arg2 = (int)(SWIG_As_int(obj1));
7447 if (SWIG_arg_fail(2)) SWIG_fail;
7448 }
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 (arg1)->RemoveFileFromHistory(arg2);
7452
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 Py_INCREF(Py_None); resultobj = Py_None;
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj;
7465 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7466 int result;
7467 PyObject * obj0 = 0 ;
7468 char *kwnames[] = {
7469 (char *) "self", NULL
7470 };
7471
7472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7474 if (SWIG_arg_fail(1)) SWIG_fail;
7475 {
7476 PyThreadState* __tstate = wxPyBeginAllowThreads();
7477 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7478
7479 wxPyEndAllowThreads(__tstate);
7480 if (PyErr_Occurred()) SWIG_fail;
7481 }
7482 {
7483 resultobj = SWIG_From_int((int)(result));
7484 }
7485 return resultobj;
7486 fail:
7487 return NULL;
7488 }
7489
7490
7491 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7492 PyObject *resultobj;
7493 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7494 wxMenu *arg2 = (wxMenu *) 0 ;
7495 PyObject * obj0 = 0 ;
7496 PyObject * obj1 = 0 ;
7497 char *kwnames[] = {
7498 (char *) "self",(char *) "menu", NULL
7499 };
7500
7501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7503 if (SWIG_arg_fail(1)) SWIG_fail;
7504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7505 if (SWIG_arg_fail(2)) SWIG_fail;
7506 {
7507 PyThreadState* __tstate = wxPyBeginAllowThreads();
7508 (arg1)->UseMenu(arg2);
7509
7510 wxPyEndAllowThreads(__tstate);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 Py_INCREF(Py_None); resultobj = Py_None;
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj;
7522 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7523 wxMenu *arg2 = (wxMenu *) 0 ;
7524 PyObject * obj0 = 0 ;
7525 PyObject * obj1 = 0 ;
7526 char *kwnames[] = {
7527 (char *) "self",(char *) "menu", NULL
7528 };
7529
7530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7532 if (SWIG_arg_fail(1)) SWIG_fail;
7533 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7534 if (SWIG_arg_fail(2)) SWIG_fail;
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 (arg1)->RemoveMenu(arg2);
7538
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 Py_INCREF(Py_None); resultobj = Py_None;
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7552 wxConfigBase *arg2 = 0 ;
7553 PyObject * obj0 = 0 ;
7554 PyObject * obj1 = 0 ;
7555 char *kwnames[] = {
7556 (char *) "self",(char *) "config", NULL
7557 };
7558
7559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7561 if (SWIG_arg_fail(1)) SWIG_fail;
7562 {
7563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7564 if (SWIG_arg_fail(2)) SWIG_fail;
7565 if (arg2 == NULL) {
7566 SWIG_null_ref("wxConfigBase");
7567 }
7568 if (SWIG_arg_fail(2)) SWIG_fail;
7569 }
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 (arg1)->Load(*arg2);
7573
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 Py_INCREF(Py_None); resultobj = Py_None;
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj;
7586 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7587 wxConfigBase *arg2 = 0 ;
7588 PyObject * obj0 = 0 ;
7589 PyObject * obj1 = 0 ;
7590 char *kwnames[] = {
7591 (char *) "self",(char *) "config", NULL
7592 };
7593
7594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7596 if (SWIG_arg_fail(1)) SWIG_fail;
7597 {
7598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7599 if (SWIG_arg_fail(2)) SWIG_fail;
7600 if (arg2 == NULL) {
7601 SWIG_null_ref("wxConfigBase");
7602 }
7603 if (SWIG_arg_fail(2)) SWIG_fail;
7604 }
7605 {
7606 PyThreadState* __tstate = wxPyBeginAllowThreads();
7607 (arg1)->Save(*arg2);
7608
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 Py_INCREF(Py_None); resultobj = Py_None;
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7620 PyObject *resultobj;
7621 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7622 PyObject * obj0 = 0 ;
7623 char *kwnames[] = {
7624 (char *) "self", NULL
7625 };
7626
7627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7629 if (SWIG_arg_fail(1)) SWIG_fail;
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 (arg1)->AddFilesToMenu();
7633
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 Py_INCREF(Py_None); resultobj = Py_None;
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7645 PyObject *resultobj;
7646 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7647 wxMenu *arg2 = (wxMenu *) 0 ;
7648 PyObject * obj0 = 0 ;
7649 PyObject * obj1 = 0 ;
7650 char *kwnames[] = {
7651 (char *) "self",(char *) "menu", NULL
7652 };
7653
7654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7656 if (SWIG_arg_fail(1)) SWIG_fail;
7657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7658 if (SWIG_arg_fail(2)) SWIG_fail;
7659 {
7660 PyThreadState* __tstate = wxPyBeginAllowThreads();
7661 (arg1)->AddFilesToMenu(arg2);
7662
7663 wxPyEndAllowThreads(__tstate);
7664 if (PyErr_Occurred()) SWIG_fail;
7665 }
7666 Py_INCREF(Py_None); resultobj = Py_None;
7667 return resultobj;
7668 fail:
7669 return NULL;
7670 }
7671
7672
7673 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7674 PyObject *resultobj;
7675 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7676 int arg2 ;
7677 wxString result;
7678 PyObject * obj0 = 0 ;
7679 PyObject * obj1 = 0 ;
7680 char *kwnames[] = {
7681 (char *) "self",(char *) "i", NULL
7682 };
7683
7684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7686 if (SWIG_arg_fail(1)) SWIG_fail;
7687 {
7688 arg2 = (int)(SWIG_As_int(obj1));
7689 if (SWIG_arg_fail(2)) SWIG_fail;
7690 }
7691 {
7692 PyThreadState* __tstate = wxPyBeginAllowThreads();
7693 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7694
7695 wxPyEndAllowThreads(__tstate);
7696 if (PyErr_Occurred()) SWIG_fail;
7697 }
7698 {
7699 #if wxUSE_UNICODE
7700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7701 #else
7702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7703 #endif
7704 }
7705 return resultobj;
7706 fail:
7707 return NULL;
7708 }
7709
7710
7711 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7712 PyObject *resultobj;
7713 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7714 int result;
7715 PyObject * obj0 = 0 ;
7716 char *kwnames[] = {
7717 (char *) "self", NULL
7718 };
7719
7720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7722 if (SWIG_arg_fail(1)) SWIG_fail;
7723 {
7724 PyThreadState* __tstate = wxPyBeginAllowThreads();
7725 result = (int)((wxFileHistory const *)arg1)->GetCount();
7726
7727 wxPyEndAllowThreads(__tstate);
7728 if (PyErr_Occurred()) SWIG_fail;
7729 }
7730 {
7731 resultobj = SWIG_From_int((int)(result));
7732 }
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7740 PyObject *obj;
7741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7742 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7743 Py_INCREF(obj);
7744 return Py_BuildValue((char *)"");
7745 }
7746 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7747 PyObject *resultobj;
7748 wxString *arg1 = 0 ;
7749 wxString const &arg2_defvalue = wxPyEmptyString ;
7750 wxString *arg2 = (wxString *) &arg2_defvalue ;
7751 wxSingleInstanceChecker *result;
7752 bool temp1 = false ;
7753 bool temp2 = false ;
7754 PyObject * obj0 = 0 ;
7755 PyObject * obj1 = 0 ;
7756 char *kwnames[] = {
7757 (char *) "name",(char *) "path", NULL
7758 };
7759
7760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7761 {
7762 arg1 = wxString_in_helper(obj0);
7763 if (arg1 == NULL) SWIG_fail;
7764 temp1 = true;
7765 }
7766 if (obj1) {
7767 {
7768 arg2 = wxString_in_helper(obj1);
7769 if (arg2 == NULL) SWIG_fail;
7770 temp2 = true;
7771 }
7772 }
7773 {
7774 PyThreadState* __tstate = wxPyBeginAllowThreads();
7775 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7776
7777 wxPyEndAllowThreads(__tstate);
7778 if (PyErr_Occurred()) SWIG_fail;
7779 }
7780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7781 {
7782 if (temp1)
7783 delete arg1;
7784 }
7785 {
7786 if (temp2)
7787 delete arg2;
7788 }
7789 return resultobj;
7790 fail:
7791 {
7792 if (temp1)
7793 delete arg1;
7794 }
7795 {
7796 if (temp2)
7797 delete arg2;
7798 }
7799 return NULL;
7800 }
7801
7802
7803 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7804 PyObject *resultobj;
7805 wxSingleInstanceChecker *result;
7806 char *kwnames[] = {
7807 NULL
7808 };
7809
7810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7811 {
7812 PyThreadState* __tstate = wxPyBeginAllowThreads();
7813 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7814
7815 wxPyEndAllowThreads(__tstate);
7816 if (PyErr_Occurred()) SWIG_fail;
7817 }
7818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7819 return resultobj;
7820 fail:
7821 return NULL;
7822 }
7823
7824
7825 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7826 PyObject *resultobj;
7827 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7828 PyObject * obj0 = 0 ;
7829 char *kwnames[] = {
7830 (char *) "self", NULL
7831 };
7832
7833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7835 if (SWIG_arg_fail(1)) SWIG_fail;
7836 {
7837 PyThreadState* __tstate = wxPyBeginAllowThreads();
7838 delete arg1;
7839
7840 wxPyEndAllowThreads(__tstate);
7841 if (PyErr_Occurred()) SWIG_fail;
7842 }
7843 Py_INCREF(Py_None); resultobj = Py_None;
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj;
7852 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7853 wxString *arg2 = 0 ;
7854 wxString const &arg3_defvalue = wxPyEmptyString ;
7855 wxString *arg3 = (wxString *) &arg3_defvalue ;
7856 bool result;
7857 bool temp2 = false ;
7858 bool temp3 = false ;
7859 PyObject * obj0 = 0 ;
7860 PyObject * obj1 = 0 ;
7861 PyObject * obj2 = 0 ;
7862 char *kwnames[] = {
7863 (char *) "self",(char *) "name",(char *) "path", NULL
7864 };
7865
7866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7868 if (SWIG_arg_fail(1)) SWIG_fail;
7869 {
7870 arg2 = wxString_in_helper(obj1);
7871 if (arg2 == NULL) SWIG_fail;
7872 temp2 = true;
7873 }
7874 if (obj2) {
7875 {
7876 arg3 = wxString_in_helper(obj2);
7877 if (arg3 == NULL) SWIG_fail;
7878 temp3 = true;
7879 }
7880 }
7881 {
7882 PyThreadState* __tstate = wxPyBeginAllowThreads();
7883 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7884
7885 wxPyEndAllowThreads(__tstate);
7886 if (PyErr_Occurred()) SWIG_fail;
7887 }
7888 {
7889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7890 }
7891 {
7892 if (temp2)
7893 delete arg2;
7894 }
7895 {
7896 if (temp3)
7897 delete arg3;
7898 }
7899 return resultobj;
7900 fail:
7901 {
7902 if (temp2)
7903 delete arg2;
7904 }
7905 {
7906 if (temp3)
7907 delete arg3;
7908 }
7909 return NULL;
7910 }
7911
7912
7913 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7914 PyObject *resultobj;
7915 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7916 bool result;
7917 PyObject * obj0 = 0 ;
7918 char *kwnames[] = {
7919 (char *) "self", NULL
7920 };
7921
7922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7924 if (SWIG_arg_fail(1)) SWIG_fail;
7925 {
7926 PyThreadState* __tstate = wxPyBeginAllowThreads();
7927 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7928
7929 wxPyEndAllowThreads(__tstate);
7930 if (PyErr_Occurred()) SWIG_fail;
7931 }
7932 {
7933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7934 }
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7942 PyObject *obj;
7943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7944 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7945 Py_INCREF(obj);
7946 return Py_BuildValue((char *)"");
7947 }
7948 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj;
7950 wxWindow *arg1 = (wxWindow *) 0 ;
7951 wxDC *arg2 = 0 ;
7952 bool result;
7953 PyObject * obj0 = 0 ;
7954 PyObject * obj1 = 0 ;
7955 char *kwnames[] = {
7956 (char *) "window",(char *) "dc", NULL
7957 };
7958
7959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7961 if (SWIG_arg_fail(1)) SWIG_fail;
7962 {
7963 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7964 if (SWIG_arg_fail(2)) SWIG_fail;
7965 if (arg2 == NULL) {
7966 SWIG_null_ref("wxDC");
7967 }
7968 if (SWIG_arg_fail(2)) SWIG_fail;
7969 }
7970 {
7971 PyThreadState* __tstate = wxPyBeginAllowThreads();
7972 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7973
7974 wxPyEndAllowThreads(__tstate);
7975 if (PyErr_Occurred()) SWIG_fail;
7976 }
7977 {
7978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7979 }
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7987 PyObject *resultobj;
7988 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7989 PyObject * obj0 = 0 ;
7990 char *kwnames[] = {
7991 (char *) "self", NULL
7992 };
7993
7994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7996 if (SWIG_arg_fail(1)) SWIG_fail;
7997 {
7998 PyThreadState* __tstate = wxPyBeginAllowThreads();
7999 delete arg1;
8000
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 Py_INCREF(Py_None); resultobj = Py_None;
8005 return resultobj;
8006 fail:
8007 return NULL;
8008 }
8009
8010
8011 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8012 PyObject *resultobj;
8013 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8014 wxString result;
8015 PyObject * obj0 = 0 ;
8016 char *kwnames[] = {
8017 (char *) "self", NULL
8018 };
8019
8020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8022 if (SWIG_arg_fail(1)) SWIG_fail;
8023 {
8024 PyThreadState* __tstate = wxPyBeginAllowThreads();
8025 result = (arg1)->GetTip();
8026
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 {
8031 #if wxUSE_UNICODE
8032 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8033 #else
8034 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8035 #endif
8036 }
8037 return resultobj;
8038 fail:
8039 return NULL;
8040 }
8041
8042
8043 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8044 PyObject *resultobj;
8045 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8046 size_t result;
8047 PyObject * obj0 = 0 ;
8048 char *kwnames[] = {
8049 (char *) "self", NULL
8050 };
8051
8052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8054 if (SWIG_arg_fail(1)) SWIG_fail;
8055 {
8056 PyThreadState* __tstate = wxPyBeginAllowThreads();
8057 result = (size_t)(arg1)->GetCurrentTip();
8058
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 {
8063 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8064 }
8065 return resultobj;
8066 fail:
8067 return NULL;
8068 }
8069
8070
8071 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8072 PyObject *resultobj;
8073 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8074 wxString *arg2 = 0 ;
8075 wxString result;
8076 bool temp2 = false ;
8077 PyObject * obj0 = 0 ;
8078 PyObject * obj1 = 0 ;
8079 char *kwnames[] = {
8080 (char *) "self",(char *) "tip", NULL
8081 };
8082
8083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8085 if (SWIG_arg_fail(1)) SWIG_fail;
8086 {
8087 arg2 = wxString_in_helper(obj1);
8088 if (arg2 == NULL) SWIG_fail;
8089 temp2 = true;
8090 }
8091 {
8092 PyThreadState* __tstate = wxPyBeginAllowThreads();
8093 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8094
8095 wxPyEndAllowThreads(__tstate);
8096 if (PyErr_Occurred()) SWIG_fail;
8097 }
8098 {
8099 #if wxUSE_UNICODE
8100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8101 #else
8102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8103 #endif
8104 }
8105 {
8106 if (temp2)
8107 delete arg2;
8108 }
8109 return resultobj;
8110 fail:
8111 {
8112 if (temp2)
8113 delete arg2;
8114 }
8115 return NULL;
8116 }
8117
8118
8119 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8120 PyObject *obj;
8121 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8122 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8123 Py_INCREF(obj);
8124 return Py_BuildValue((char *)"");
8125 }
8126 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj;
8128 size_t arg1 ;
8129 wxPyTipProvider *result;
8130 PyObject * obj0 = 0 ;
8131 char *kwnames[] = {
8132 (char *) "currentTip", NULL
8133 };
8134
8135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8136 {
8137 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8138 if (SWIG_arg_fail(1)) SWIG_fail;
8139 }
8140 {
8141 PyThreadState* __tstate = wxPyBeginAllowThreads();
8142 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8143
8144 wxPyEndAllowThreads(__tstate);
8145 if (PyErr_Occurred()) SWIG_fail;
8146 }
8147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj;
8156 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8157 PyObject *arg2 = (PyObject *) 0 ;
8158 PyObject *arg3 = (PyObject *) 0 ;
8159 PyObject * obj0 = 0 ;
8160 PyObject * obj1 = 0 ;
8161 PyObject * obj2 = 0 ;
8162 char *kwnames[] = {
8163 (char *) "self",(char *) "self",(char *) "_class", NULL
8164 };
8165
8166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8168 if (SWIG_arg_fail(1)) SWIG_fail;
8169 arg2 = obj1;
8170 arg3 = obj2;
8171 {
8172 PyThreadState* __tstate = wxPyBeginAllowThreads();
8173 (arg1)->_setCallbackInfo(arg2,arg3);
8174
8175 wxPyEndAllowThreads(__tstate);
8176 if (PyErr_Occurred()) SWIG_fail;
8177 }
8178 Py_INCREF(Py_None); resultobj = Py_None;
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8186 PyObject *obj;
8187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8188 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8189 Py_INCREF(obj);
8190 return Py_BuildValue((char *)"");
8191 }
8192 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8193 PyObject *resultobj;
8194 wxWindow *arg1 = (wxWindow *) 0 ;
8195 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8196 bool arg3 = (bool) true ;
8197 bool result;
8198 PyObject * obj0 = 0 ;
8199 PyObject * obj1 = 0 ;
8200 PyObject * obj2 = 0 ;
8201 char *kwnames[] = {
8202 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8203 };
8204
8205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8207 if (SWIG_arg_fail(1)) SWIG_fail;
8208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8209 if (SWIG_arg_fail(2)) SWIG_fail;
8210 if (obj2) {
8211 {
8212 arg3 = (bool)(SWIG_As_bool(obj2));
8213 if (SWIG_arg_fail(3)) SWIG_fail;
8214 }
8215 }
8216 {
8217 if (!wxPyCheckForApp()) SWIG_fail;
8218 PyThreadState* __tstate = wxPyBeginAllowThreads();
8219 result = (bool)wxShowTip(arg1,arg2,arg3);
8220
8221 wxPyEndAllowThreads(__tstate);
8222 if (PyErr_Occurred()) SWIG_fail;
8223 }
8224 {
8225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8226 }
8227 return resultobj;
8228 fail:
8229 return NULL;
8230 }
8231
8232
8233 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8234 PyObject *resultobj;
8235 wxString *arg1 = 0 ;
8236 size_t arg2 ;
8237 wxTipProvider *result;
8238 bool temp1 = false ;
8239 PyObject * obj0 = 0 ;
8240 PyObject * obj1 = 0 ;
8241 char *kwnames[] = {
8242 (char *) "filename",(char *) "currentTip", NULL
8243 };
8244
8245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8246 {
8247 arg1 = wxString_in_helper(obj0);
8248 if (arg1 == NULL) SWIG_fail;
8249 temp1 = true;
8250 }
8251 {
8252 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8253 if (SWIG_arg_fail(2)) SWIG_fail;
8254 }
8255 {
8256 if (!wxPyCheckForApp()) SWIG_fail;
8257 PyThreadState* __tstate = wxPyBeginAllowThreads();
8258 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8259
8260 wxPyEndAllowThreads(__tstate);
8261 if (PyErr_Occurred()) SWIG_fail;
8262 }
8263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8264 {
8265 if (temp1)
8266 delete arg1;
8267 }
8268 return resultobj;
8269 fail:
8270 {
8271 if (temp1)
8272 delete arg1;
8273 }
8274 return NULL;
8275 }
8276
8277
8278 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8279 PyObject *resultobj;
8280 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8281 int arg2 = (int) -1 ;
8282 wxPyTimer *result;
8283 PyObject * obj0 = 0 ;
8284 PyObject * obj1 = 0 ;
8285 char *kwnames[] = {
8286 (char *) "owner",(char *) "id", NULL
8287 };
8288
8289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8290 if (obj0) {
8291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8292 if (SWIG_arg_fail(1)) SWIG_fail;
8293 }
8294 if (obj1) {
8295 {
8296 arg2 = (int)(SWIG_As_int(obj1));
8297 if (SWIG_arg_fail(2)) SWIG_fail;
8298 }
8299 }
8300 {
8301 if (!wxPyCheckForApp()) SWIG_fail;
8302 PyThreadState* __tstate = wxPyBeginAllowThreads();
8303 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8304
8305 wxPyEndAllowThreads(__tstate);
8306 if (PyErr_Occurred()) SWIG_fail;
8307 }
8308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8309 return resultobj;
8310 fail:
8311 return NULL;
8312 }
8313
8314
8315 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8316 PyObject *resultobj;
8317 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8318 PyObject * obj0 = 0 ;
8319 char *kwnames[] = {
8320 (char *) "self", NULL
8321 };
8322
8323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8325 if (SWIG_arg_fail(1)) SWIG_fail;
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 delete arg1;
8329
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 Py_INCREF(Py_None); resultobj = Py_None;
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj;
8342 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8343 PyObject *arg2 = (PyObject *) 0 ;
8344 PyObject *arg3 = (PyObject *) 0 ;
8345 int arg4 = (int) 1 ;
8346 PyObject * obj0 = 0 ;
8347 PyObject * obj1 = 0 ;
8348 PyObject * obj2 = 0 ;
8349 PyObject * obj3 = 0 ;
8350 char *kwnames[] = {
8351 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8352 };
8353
8354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8356 if (SWIG_arg_fail(1)) SWIG_fail;
8357 arg2 = obj1;
8358 arg3 = obj2;
8359 if (obj3) {
8360 {
8361 arg4 = (int)(SWIG_As_int(obj3));
8362 if (SWIG_arg_fail(4)) SWIG_fail;
8363 }
8364 }
8365 {
8366 PyThreadState* __tstate = wxPyBeginAllowThreads();
8367 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8368
8369 wxPyEndAllowThreads(__tstate);
8370 if (PyErr_Occurred()) SWIG_fail;
8371 }
8372 Py_INCREF(Py_None); resultobj = Py_None;
8373 return resultobj;
8374 fail:
8375 return NULL;
8376 }
8377
8378
8379 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8380 PyObject *resultobj;
8381 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8382 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8383 int arg3 = (int) -1 ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 PyObject * obj2 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self",(char *) "owner",(char *) "id", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8395 if (SWIG_arg_fail(2)) SWIG_fail;
8396 if (obj2) {
8397 {
8398 arg3 = (int)(SWIG_As_int(obj2));
8399 if (SWIG_arg_fail(3)) SWIG_fail;
8400 }
8401 }
8402 {
8403 PyThreadState* __tstate = wxPyBeginAllowThreads();
8404 (arg1)->SetOwner(arg2,arg3);
8405
8406 wxPyEndAllowThreads(__tstate);
8407 if (PyErr_Occurred()) SWIG_fail;
8408 }
8409 Py_INCREF(Py_None); resultobj = Py_None;
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8417 PyObject *resultobj;
8418 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8419 wxEvtHandler *result;
8420 PyObject * obj0 = 0 ;
8421 char *kwnames[] = {
8422 (char *) "self", NULL
8423 };
8424
8425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8427 if (SWIG_arg_fail(1)) SWIG_fail;
8428 {
8429 PyThreadState* __tstate = wxPyBeginAllowThreads();
8430 result = (wxEvtHandler *)(arg1)->GetOwner();
8431
8432 wxPyEndAllowThreads(__tstate);
8433 if (PyErr_Occurred()) SWIG_fail;
8434 }
8435 {
8436 resultobj = wxPyMake_wxObject(result, 0);
8437 }
8438 return resultobj;
8439 fail:
8440 return NULL;
8441 }
8442
8443
8444 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8445 PyObject *resultobj;
8446 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8447 int arg2 = (int) -1 ;
8448 bool arg3 = (bool) false ;
8449 bool result;
8450 PyObject * obj0 = 0 ;
8451 PyObject * obj1 = 0 ;
8452 PyObject * obj2 = 0 ;
8453 char *kwnames[] = {
8454 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8455 };
8456
8457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8459 if (SWIG_arg_fail(1)) SWIG_fail;
8460 if (obj1) {
8461 {
8462 arg2 = (int)(SWIG_As_int(obj1));
8463 if (SWIG_arg_fail(2)) SWIG_fail;
8464 }
8465 }
8466 if (obj2) {
8467 {
8468 arg3 = (bool)(SWIG_As_bool(obj2));
8469 if (SWIG_arg_fail(3)) SWIG_fail;
8470 }
8471 }
8472 {
8473 PyThreadState* __tstate = wxPyBeginAllowThreads();
8474 result = (bool)(arg1)->Start(arg2,arg3);
8475
8476 wxPyEndAllowThreads(__tstate);
8477 if (PyErr_Occurred()) SWIG_fail;
8478 }
8479 {
8480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8481 }
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8489 PyObject *resultobj;
8490 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8491 PyObject * obj0 = 0 ;
8492 char *kwnames[] = {
8493 (char *) "self", NULL
8494 };
8495
8496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8498 if (SWIG_arg_fail(1)) SWIG_fail;
8499 {
8500 PyThreadState* __tstate = wxPyBeginAllowThreads();
8501 (arg1)->Stop();
8502
8503 wxPyEndAllowThreads(__tstate);
8504 if (PyErr_Occurred()) SWIG_fail;
8505 }
8506 Py_INCREF(Py_None); resultobj = Py_None;
8507 return resultobj;
8508 fail:
8509 return NULL;
8510 }
8511
8512
8513 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8514 PyObject *resultobj;
8515 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8516 bool result;
8517 PyObject * obj0 = 0 ;
8518 char *kwnames[] = {
8519 (char *) "self", NULL
8520 };
8521
8522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8524 if (SWIG_arg_fail(1)) SWIG_fail;
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8528
8529 wxPyEndAllowThreads(__tstate);
8530 if (PyErr_Occurred()) SWIG_fail;
8531 }
8532 {
8533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8534 }
8535 return resultobj;
8536 fail:
8537 return NULL;
8538 }
8539
8540
8541 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8542 PyObject *resultobj;
8543 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8544 int result;
8545 PyObject * obj0 = 0 ;
8546 char *kwnames[] = {
8547 (char *) "self", NULL
8548 };
8549
8550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8552 if (SWIG_arg_fail(1)) SWIG_fail;
8553 {
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8556
8557 wxPyEndAllowThreads(__tstate);
8558 if (PyErr_Occurred()) SWIG_fail;
8559 }
8560 {
8561 resultobj = SWIG_From_int((int)(result));
8562 }
8563 return resultobj;
8564 fail:
8565 return NULL;
8566 }
8567
8568
8569 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8570 PyObject *resultobj;
8571 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8572 bool result;
8573 PyObject * obj0 = 0 ;
8574 char *kwnames[] = {
8575 (char *) "self", NULL
8576 };
8577
8578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8580 if (SWIG_arg_fail(1)) SWIG_fail;
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8584
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 {
8589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8590 }
8591 return resultobj;
8592 fail:
8593 return NULL;
8594 }
8595
8596
8597 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8598 PyObject *resultobj;
8599 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8600 int result;
8601 PyObject * obj0 = 0 ;
8602 char *kwnames[] = {
8603 (char *) "self", NULL
8604 };
8605
8606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8608 if (SWIG_arg_fail(1)) SWIG_fail;
8609 {
8610 PyThreadState* __tstate = wxPyBeginAllowThreads();
8611 result = (int)((wxPyTimer const *)arg1)->GetId();
8612
8613 wxPyEndAllowThreads(__tstate);
8614 if (PyErr_Occurred()) SWIG_fail;
8615 }
8616 {
8617 resultobj = SWIG_From_int((int)(result));
8618 }
8619 return resultobj;
8620 fail:
8621 return NULL;
8622 }
8623
8624
8625 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8626 PyObject *obj;
8627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8628 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8629 Py_INCREF(obj);
8630 return Py_BuildValue((char *)"");
8631 }
8632 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8633 PyObject *resultobj;
8634 int arg1 = (int) 0 ;
8635 int arg2 = (int) 0 ;
8636 wxTimerEvent *result;
8637 PyObject * obj0 = 0 ;
8638 PyObject * obj1 = 0 ;
8639 char *kwnames[] = {
8640 (char *) "timerid",(char *) "interval", NULL
8641 };
8642
8643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8644 if (obj0) {
8645 {
8646 arg1 = (int)(SWIG_As_int(obj0));
8647 if (SWIG_arg_fail(1)) SWIG_fail;
8648 }
8649 }
8650 if (obj1) {
8651 {
8652 arg2 = (int)(SWIG_As_int(obj1));
8653 if (SWIG_arg_fail(2)) SWIG_fail;
8654 }
8655 }
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8659
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8664 return resultobj;
8665 fail:
8666 return NULL;
8667 }
8668
8669
8670 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8671 PyObject *resultobj;
8672 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8673 int result;
8674 PyObject * obj0 = 0 ;
8675 char *kwnames[] = {
8676 (char *) "self", NULL
8677 };
8678
8679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8681 if (SWIG_arg_fail(1)) SWIG_fail;
8682 {
8683 PyThreadState* __tstate = wxPyBeginAllowThreads();
8684 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8685
8686 wxPyEndAllowThreads(__tstate);
8687 if (PyErr_Occurred()) SWIG_fail;
8688 }
8689 {
8690 resultobj = SWIG_From_int((int)(result));
8691 }
8692 return resultobj;
8693 fail:
8694 return NULL;
8695 }
8696
8697
8698 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8699 PyObject *obj;
8700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8701 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8702 Py_INCREF(obj);
8703 return Py_BuildValue((char *)"");
8704 }
8705 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8706 PyObject *resultobj;
8707 wxTimer *arg1 = 0 ;
8708 wxTimerRunner *result;
8709 PyObject * obj0 = 0 ;
8710
8711 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8712 {
8713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8714 if (SWIG_arg_fail(1)) SWIG_fail;
8715 if (arg1 == NULL) {
8716 SWIG_null_ref("wxTimer");
8717 }
8718 if (SWIG_arg_fail(1)) SWIG_fail;
8719 }
8720 {
8721 if (!wxPyCheckForApp()) SWIG_fail;
8722 PyThreadState* __tstate = wxPyBeginAllowThreads();
8723 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8724
8725 wxPyEndAllowThreads(__tstate);
8726 if (PyErr_Occurred()) SWIG_fail;
8727 }
8728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8729 return resultobj;
8730 fail:
8731 return NULL;
8732 }
8733
8734
8735 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8736 PyObject *resultobj;
8737 wxTimer *arg1 = 0 ;
8738 int arg2 ;
8739 bool arg3 = (bool) false ;
8740 wxTimerRunner *result;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 PyObject * obj2 = 0 ;
8744
8745 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8746 {
8747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8748 if (SWIG_arg_fail(1)) SWIG_fail;
8749 if (arg1 == NULL) {
8750 SWIG_null_ref("wxTimer");
8751 }
8752 if (SWIG_arg_fail(1)) SWIG_fail;
8753 }
8754 {
8755 arg2 = (int)(SWIG_As_int(obj1));
8756 if (SWIG_arg_fail(2)) SWIG_fail;
8757 }
8758 if (obj2) {
8759 {
8760 arg3 = (bool)(SWIG_As_bool(obj2));
8761 if (SWIG_arg_fail(3)) SWIG_fail;
8762 }
8763 }
8764 {
8765 if (!wxPyCheckForApp()) SWIG_fail;
8766 PyThreadState* __tstate = wxPyBeginAllowThreads();
8767 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8768
8769 wxPyEndAllowThreads(__tstate);
8770 if (PyErr_Occurred()) SWIG_fail;
8771 }
8772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8773 return resultobj;
8774 fail:
8775 return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8780 int argc;
8781 PyObject *argv[4];
8782 int ii;
8783
8784 argc = PyObject_Length(args);
8785 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8786 argv[ii] = PyTuple_GetItem(args,ii);
8787 }
8788 if (argc == 1) {
8789 int _v;
8790 {
8791 void *ptr = 0;
8792 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8793 _v = 0;
8794 PyErr_Clear();
8795 } else {
8796 _v = (ptr != 0);
8797 }
8798 }
8799 if (_v) {
8800 return _wrap_new_TimerRunner__SWIG_0(self,args);
8801 }
8802 }
8803 if ((argc >= 2) && (argc <= 3)) {
8804 int _v;
8805 {
8806 void *ptr = 0;
8807 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8808 _v = 0;
8809 PyErr_Clear();
8810 } else {
8811 _v = (ptr != 0);
8812 }
8813 }
8814 if (_v) {
8815 _v = SWIG_Check_int(argv[1]);
8816 if (_v) {
8817 if (argc <= 2) {
8818 return _wrap_new_TimerRunner__SWIG_1(self,args);
8819 }
8820 _v = SWIG_Check_bool(argv[2]);
8821 if (_v) {
8822 return _wrap_new_TimerRunner__SWIG_1(self,args);
8823 }
8824 }
8825 }
8826 }
8827
8828 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8829 return NULL;
8830 }
8831
8832
8833 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8834 PyObject *resultobj;
8835 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8836 PyObject * obj0 = 0 ;
8837 char *kwnames[] = {
8838 (char *) "self", NULL
8839 };
8840
8841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8843 if (SWIG_arg_fail(1)) SWIG_fail;
8844 {
8845 PyThreadState* __tstate = wxPyBeginAllowThreads();
8846 delete arg1;
8847
8848 wxPyEndAllowThreads(__tstate);
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 Py_INCREF(Py_None); resultobj = Py_None;
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj;
8860 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8861 int arg2 ;
8862 bool arg3 = (bool) false ;
8863 PyObject * obj0 = 0 ;
8864 PyObject * obj1 = 0 ;
8865 PyObject * obj2 = 0 ;
8866 char *kwnames[] = {
8867 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8868 };
8869
8870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8872 if (SWIG_arg_fail(1)) SWIG_fail;
8873 {
8874 arg2 = (int)(SWIG_As_int(obj1));
8875 if (SWIG_arg_fail(2)) SWIG_fail;
8876 }
8877 if (obj2) {
8878 {
8879 arg3 = (bool)(SWIG_As_bool(obj2));
8880 if (SWIG_arg_fail(3)) SWIG_fail;
8881 }
8882 }
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 (arg1)->Start(arg2,arg3);
8886
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 Py_INCREF(Py_None); resultobj = Py_None;
8891 return resultobj;
8892 fail:
8893 return NULL;
8894 }
8895
8896
8897 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8898 PyObject *obj;
8899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8900 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8901 Py_INCREF(obj);
8902 return Py_BuildValue((char *)"");
8903 }
8904 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8905 PyObject *resultobj;
8906 wxLog *result;
8907 char *kwnames[] = {
8908 NULL
8909 };
8910
8911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8912 {
8913 PyThreadState* __tstate = wxPyBeginAllowThreads();
8914 result = (wxLog *)new wxLog();
8915
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
8926 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8927 PyObject *resultobj;
8928 bool result;
8929 char *kwnames[] = {
8930 NULL
8931 };
8932
8933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8934 {
8935 PyThreadState* __tstate = wxPyBeginAllowThreads();
8936 result = (bool)wxLog::IsEnabled();
8937
8938 wxPyEndAllowThreads(__tstate);
8939 if (PyErr_Occurred()) SWIG_fail;
8940 }
8941 {
8942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8943 }
8944 return resultobj;
8945 fail:
8946 return NULL;
8947 }
8948
8949
8950 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8951 PyObject *resultobj;
8952 bool arg1 = (bool) true ;
8953 bool result;
8954 PyObject * obj0 = 0 ;
8955 char *kwnames[] = {
8956 (char *) "doIt", NULL
8957 };
8958
8959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8960 if (obj0) {
8961 {
8962 arg1 = (bool)(SWIG_As_bool(obj0));
8963 if (SWIG_arg_fail(1)) SWIG_fail;
8964 }
8965 }
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 result = (bool)wxLog::EnableLogging(arg1);
8969
8970 wxPyEndAllowThreads(__tstate);
8971 if (PyErr_Occurred()) SWIG_fail;
8972 }
8973 {
8974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8975 }
8976 return resultobj;
8977 fail:
8978 return NULL;
8979 }
8980
8981
8982 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8983 PyObject *resultobj;
8984 wxLogLevel arg1 ;
8985 wxChar *arg2 = (wxChar *) 0 ;
8986 time_t arg3 ;
8987 PyObject * obj0 = 0 ;
8988 PyObject * obj1 = 0 ;
8989 PyObject * obj2 = 0 ;
8990 char *kwnames[] = {
8991 (char *) "level",(char *) "szString",(char *) "t", NULL
8992 };
8993
8994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8995 {
8996 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8997 if (SWIG_arg_fail(1)) SWIG_fail;
8998 }
8999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9000 if (SWIG_arg_fail(2)) SWIG_fail;
9001 {
9002 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
9003 if (SWIG_arg_fail(3)) SWIG_fail;
9004 }
9005 {
9006 PyThreadState* __tstate = wxPyBeginAllowThreads();
9007 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9008
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 Py_INCREF(Py_None); resultobj = Py_None;
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj;
9021 wxLog *arg1 = (wxLog *) 0 ;
9022 PyObject * obj0 = 0 ;
9023 char *kwnames[] = {
9024 (char *) "self", NULL
9025 };
9026
9027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9029 if (SWIG_arg_fail(1)) SWIG_fail;
9030 {
9031 PyThreadState* __tstate = wxPyBeginAllowThreads();
9032 (arg1)->Flush();
9033
9034 wxPyEndAllowThreads(__tstate);
9035 if (PyErr_Occurred()) SWIG_fail;
9036 }
9037 Py_INCREF(Py_None); resultobj = Py_None;
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj;
9046 char *kwnames[] = {
9047 NULL
9048 };
9049
9050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9051 {
9052 PyThreadState* __tstate = wxPyBeginAllowThreads();
9053 wxLog::FlushActive();
9054
9055 wxPyEndAllowThreads(__tstate);
9056 if (PyErr_Occurred()) SWIG_fail;
9057 }
9058 Py_INCREF(Py_None); resultobj = Py_None;
9059 return resultobj;
9060 fail:
9061 return NULL;
9062 }
9063
9064
9065 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9066 PyObject *resultobj;
9067 wxLog *result;
9068 char *kwnames[] = {
9069 NULL
9070 };
9071
9072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (wxLog *)wxLog::GetActiveTarget();
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9088 PyObject *resultobj;
9089 wxLog *arg1 = (wxLog *) 0 ;
9090 wxLog *result;
9091 PyObject * obj0 = 0 ;
9092 char *kwnames[] = {
9093 (char *) "pLogger", NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9098 if (SWIG_arg_fail(1)) SWIG_fail;
9099 {
9100 PyThreadState* __tstate = wxPyBeginAllowThreads();
9101 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9102
9103 wxPyEndAllowThreads(__tstate);
9104 if (PyErr_Occurred()) SWIG_fail;
9105 }
9106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9107 return resultobj;
9108 fail:
9109 return NULL;
9110 }
9111
9112
9113 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj;
9115 char *kwnames[] = {
9116 NULL
9117 };
9118
9119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9120 {
9121 PyThreadState* __tstate = wxPyBeginAllowThreads();
9122 wxLog::Suspend();
9123
9124 wxPyEndAllowThreads(__tstate);
9125 if (PyErr_Occurred()) SWIG_fail;
9126 }
9127 Py_INCREF(Py_None); resultobj = Py_None;
9128 return resultobj;
9129 fail:
9130 return NULL;
9131 }
9132
9133
9134 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9135 PyObject *resultobj;
9136 char *kwnames[] = {
9137 NULL
9138 };
9139
9140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9141 {
9142 PyThreadState* __tstate = wxPyBeginAllowThreads();
9143 wxLog::Resume();
9144
9145 wxPyEndAllowThreads(__tstate);
9146 if (PyErr_Occurred()) SWIG_fail;
9147 }
9148 Py_INCREF(Py_None); resultobj = Py_None;
9149 return resultobj;
9150 fail:
9151 return NULL;
9152 }
9153
9154
9155 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9156 PyObject *resultobj;
9157 bool arg1 = (bool) true ;
9158 PyObject * obj0 = 0 ;
9159 char *kwnames[] = {
9160 (char *) "bVerbose", NULL
9161 };
9162
9163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9164 if (obj0) {
9165 {
9166 arg1 = (bool)(SWIG_As_bool(obj0));
9167 if (SWIG_arg_fail(1)) SWIG_fail;
9168 }
9169 }
9170 {
9171 PyThreadState* __tstate = wxPyBeginAllowThreads();
9172 wxLog::SetVerbose(arg1);
9173
9174 wxPyEndAllowThreads(__tstate);
9175 if (PyErr_Occurred()) SWIG_fail;
9176 }
9177 Py_INCREF(Py_None); resultobj = Py_None;
9178 return resultobj;
9179 fail:
9180 return NULL;
9181 }
9182
9183
9184 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9185 PyObject *resultobj;
9186 wxLogLevel arg1 ;
9187 PyObject * obj0 = 0 ;
9188 char *kwnames[] = {
9189 (char *) "logLevel", NULL
9190 };
9191
9192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9193 {
9194 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9195 if (SWIG_arg_fail(1)) SWIG_fail;
9196 }
9197 {
9198 PyThreadState* __tstate = wxPyBeginAllowThreads();
9199 wxLog::SetLogLevel(arg1);
9200
9201 wxPyEndAllowThreads(__tstate);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 Py_INCREF(Py_None); resultobj = Py_None;
9205 return resultobj;
9206 fail:
9207 return NULL;
9208 }
9209
9210
9211 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9212 PyObject *resultobj;
9213 char *kwnames[] = {
9214 NULL
9215 };
9216
9217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9218 {
9219 PyThreadState* __tstate = wxPyBeginAllowThreads();
9220 wxLog::DontCreateOnDemand();
9221
9222 wxPyEndAllowThreads(__tstate);
9223 if (PyErr_Occurred()) SWIG_fail;
9224 }
9225 Py_INCREF(Py_None); resultobj = Py_None;
9226 return resultobj;
9227 fail:
9228 return NULL;
9229 }
9230
9231
9232 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9233 PyObject *resultobj;
9234 wxTraceMask arg1 ;
9235 PyObject * obj0 = 0 ;
9236 char *kwnames[] = {
9237 (char *) "ulMask", NULL
9238 };
9239
9240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9241 {
9242 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9243 if (SWIG_arg_fail(1)) SWIG_fail;
9244 }
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 wxLog::SetTraceMask(arg1);
9248
9249 wxPyEndAllowThreads(__tstate);
9250 if (PyErr_Occurred()) SWIG_fail;
9251 }
9252 Py_INCREF(Py_None); resultobj = Py_None;
9253 return resultobj;
9254 fail:
9255 return NULL;
9256 }
9257
9258
9259 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9260 PyObject *resultobj;
9261 wxString *arg1 = 0 ;
9262 bool temp1 = false ;
9263 PyObject * obj0 = 0 ;
9264 char *kwnames[] = {
9265 (char *) "str", NULL
9266 };
9267
9268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9269 {
9270 arg1 = wxString_in_helper(obj0);
9271 if (arg1 == NULL) SWIG_fail;
9272 temp1 = true;
9273 }
9274 {
9275 PyThreadState* __tstate = wxPyBeginAllowThreads();
9276 wxLog::AddTraceMask((wxString const &)*arg1);
9277
9278 wxPyEndAllowThreads(__tstate);
9279 if (PyErr_Occurred()) SWIG_fail;
9280 }
9281 Py_INCREF(Py_None); resultobj = Py_None;
9282 {
9283 if (temp1)
9284 delete arg1;
9285 }
9286 return resultobj;
9287 fail:
9288 {
9289 if (temp1)
9290 delete arg1;
9291 }
9292 return NULL;
9293 }
9294
9295
9296 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9297 PyObject *resultobj;
9298 wxString *arg1 = 0 ;
9299 bool temp1 = false ;
9300 PyObject * obj0 = 0 ;
9301 char *kwnames[] = {
9302 (char *) "str", NULL
9303 };
9304
9305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9306 {
9307 arg1 = wxString_in_helper(obj0);
9308 if (arg1 == NULL) SWIG_fail;
9309 temp1 = true;
9310 }
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 wxLog::RemoveTraceMask((wxString const &)*arg1);
9314
9315 wxPyEndAllowThreads(__tstate);
9316 if (PyErr_Occurred()) SWIG_fail;
9317 }
9318 Py_INCREF(Py_None); resultobj = Py_None;
9319 {
9320 if (temp1)
9321 delete arg1;
9322 }
9323 return resultobj;
9324 fail:
9325 {
9326 if (temp1)
9327 delete arg1;
9328 }
9329 return NULL;
9330 }
9331
9332
9333 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj;
9335 char *kwnames[] = {
9336 NULL
9337 };
9338
9339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9340 {
9341 PyThreadState* __tstate = wxPyBeginAllowThreads();
9342 wxLog::ClearTraceMasks();
9343
9344 wxPyEndAllowThreads(__tstate);
9345 if (PyErr_Occurred()) SWIG_fail;
9346 }
9347 Py_INCREF(Py_None); resultobj = Py_None;
9348 return resultobj;
9349 fail:
9350 return NULL;
9351 }
9352
9353
9354 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9355 PyObject *resultobj;
9356 wxArrayString *result;
9357 char *kwnames[] = {
9358 NULL
9359 };
9360
9361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9362 {
9363 PyThreadState* __tstate = wxPyBeginAllowThreads();
9364 {
9365 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9366 result = (wxArrayString *) &_result_ref;
9367 }
9368
9369 wxPyEndAllowThreads(__tstate);
9370 if (PyErr_Occurred()) SWIG_fail;
9371 }
9372 {
9373 resultobj = wxArrayString2PyList_helper(*result);
9374 }
9375 return resultobj;
9376 fail:
9377 return NULL;
9378 }
9379
9380
9381 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9382 PyObject *resultobj;
9383 wxChar *arg1 = (wxChar *) 0 ;
9384 PyObject * obj0 = 0 ;
9385 char *kwnames[] = {
9386 (char *) "ts", NULL
9387 };
9388
9389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9391 if (SWIG_arg_fail(1)) SWIG_fail;
9392 {
9393 PyThreadState* __tstate = wxPyBeginAllowThreads();
9394 wxLog::SetTimestamp((wxChar const *)arg1);
9395
9396 wxPyEndAllowThreads(__tstate);
9397 if (PyErr_Occurred()) SWIG_fail;
9398 }
9399 Py_INCREF(Py_None); resultobj = Py_None;
9400 return resultobj;
9401 fail:
9402 return NULL;
9403 }
9404
9405
9406 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9407 PyObject *resultobj;
9408 bool result;
9409 char *kwnames[] = {
9410 NULL
9411 };
9412
9413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = (bool)wxLog::GetVerbose();
9417
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 {
9422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9423 }
9424 return resultobj;
9425 fail:
9426 return NULL;
9427 }
9428
9429
9430 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj;
9432 wxTraceMask result;
9433 char *kwnames[] = {
9434 NULL
9435 };
9436
9437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9438 {
9439 PyThreadState* __tstate = wxPyBeginAllowThreads();
9440 result = (wxTraceMask)wxLog::GetTraceMask();
9441
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 {
9446 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9447 }
9448 return resultobj;
9449 fail:
9450 return NULL;
9451 }
9452
9453
9454 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9455 PyObject *resultobj;
9456 wxChar *arg1 = (wxChar *) 0 ;
9457 bool result;
9458 PyObject * obj0 = 0 ;
9459 char *kwnames[] = {
9460 (char *) "mask", NULL
9461 };
9462
9463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9465 if (SWIG_arg_fail(1)) SWIG_fail;
9466 {
9467 PyThreadState* __tstate = wxPyBeginAllowThreads();
9468 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9469
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 {
9474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9475 }
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9483 PyObject *resultobj;
9484 wxLogLevel result;
9485 char *kwnames[] = {
9486 NULL
9487 };
9488
9489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9490 {
9491 PyThreadState* __tstate = wxPyBeginAllowThreads();
9492 result = (wxLogLevel)wxLog::GetLogLevel();
9493
9494 wxPyEndAllowThreads(__tstate);
9495 if (PyErr_Occurred()) SWIG_fail;
9496 }
9497 {
9498 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9499 }
9500 return resultobj;
9501 fail:
9502 return NULL;
9503 }
9504
9505
9506 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9507 PyObject *resultobj;
9508 wxChar *result;
9509 char *kwnames[] = {
9510 NULL
9511 };
9512
9513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 result = (wxChar *)wxLog::GetTimestamp();
9517
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9522 return resultobj;
9523 fail:
9524 return NULL;
9525 }
9526
9527
9528 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9529 PyObject *resultobj;
9530 wxString result;
9531 char *kwnames[] = {
9532 NULL
9533 };
9534
9535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 result = Log_TimeStamp();
9539
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 {
9544 #if wxUSE_UNICODE
9545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9546 #else
9547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9548 #endif
9549 }
9550 return resultobj;
9551 fail:
9552 return NULL;
9553 }
9554
9555
9556 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9557 PyObject *resultobj;
9558 wxLog *arg1 = (wxLog *) 0 ;
9559 PyObject * obj0 = 0 ;
9560 char *kwnames[] = {
9561 (char *) "self", NULL
9562 };
9563
9564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9566 if (SWIG_arg_fail(1)) SWIG_fail;
9567 {
9568 PyThreadState* __tstate = wxPyBeginAllowThreads();
9569 wxLog_Destroy(arg1);
9570
9571 wxPyEndAllowThreads(__tstate);
9572 if (PyErr_Occurred()) SWIG_fail;
9573 }
9574 Py_INCREF(Py_None); resultobj = Py_None;
9575 return resultobj;
9576 fail:
9577 return NULL;
9578 }
9579
9580
9581 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9582 PyObject *obj;
9583 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9584 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9585 Py_INCREF(obj);
9586 return Py_BuildValue((char *)"");
9587 }
9588 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9589 PyObject *resultobj;
9590 wxLogStderr *result;
9591 char *kwnames[] = {
9592 NULL
9593 };
9594
9595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9596 {
9597 PyThreadState* __tstate = wxPyBeginAllowThreads();
9598 result = (wxLogStderr *)new wxLogStderr();
9599
9600 wxPyEndAllowThreads(__tstate);
9601 if (PyErr_Occurred()) SWIG_fail;
9602 }
9603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9604 return resultobj;
9605 fail:
9606 return NULL;
9607 }
9608
9609
9610 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9611 PyObject *obj;
9612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9613 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9614 Py_INCREF(obj);
9615 return Py_BuildValue((char *)"");
9616 }
9617 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9618 PyObject *resultobj;
9619 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9620 wxLogTextCtrl *result;
9621 PyObject * obj0 = 0 ;
9622 char *kwnames[] = {
9623 (char *) "pTextCtrl", NULL
9624 };
9625
9626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9628 if (SWIG_arg_fail(1)) SWIG_fail;
9629 {
9630 PyThreadState* __tstate = wxPyBeginAllowThreads();
9631 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9632
9633 wxPyEndAllowThreads(__tstate);
9634 if (PyErr_Occurred()) SWIG_fail;
9635 }
9636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9637 return resultobj;
9638 fail:
9639 return NULL;
9640 }
9641
9642
9643 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9644 PyObject *obj;
9645 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9646 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9647 Py_INCREF(obj);
9648 return Py_BuildValue((char *)"");
9649 }
9650 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9651 PyObject *resultobj;
9652 wxLogGui *result;
9653 char *kwnames[] = {
9654 NULL
9655 };
9656
9657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9658 {
9659 PyThreadState* __tstate = wxPyBeginAllowThreads();
9660 result = (wxLogGui *)new wxLogGui();
9661
9662 wxPyEndAllowThreads(__tstate);
9663 if (PyErr_Occurred()) SWIG_fail;
9664 }
9665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9666 return resultobj;
9667 fail:
9668 return NULL;
9669 }
9670
9671
9672 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9673 PyObject *obj;
9674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9675 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9676 Py_INCREF(obj);
9677 return Py_BuildValue((char *)"");
9678 }
9679 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9680 PyObject *resultobj;
9681 wxFrame *arg1 = (wxFrame *) 0 ;
9682 wxString *arg2 = 0 ;
9683 bool arg3 = (bool) true ;
9684 bool arg4 = (bool) true ;
9685 wxLogWindow *result;
9686 bool temp2 = false ;
9687 PyObject * obj0 = 0 ;
9688 PyObject * obj1 = 0 ;
9689 PyObject * obj2 = 0 ;
9690 PyObject * obj3 = 0 ;
9691 char *kwnames[] = {
9692 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9693 };
9694
9695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9697 if (SWIG_arg_fail(1)) SWIG_fail;
9698 {
9699 arg2 = wxString_in_helper(obj1);
9700 if (arg2 == NULL) SWIG_fail;
9701 temp2 = true;
9702 }
9703 if (obj2) {
9704 {
9705 arg3 = (bool)(SWIG_As_bool(obj2));
9706 if (SWIG_arg_fail(3)) SWIG_fail;
9707 }
9708 }
9709 if (obj3) {
9710 {
9711 arg4 = (bool)(SWIG_As_bool(obj3));
9712 if (SWIG_arg_fail(4)) SWIG_fail;
9713 }
9714 }
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9718
9719 wxPyEndAllowThreads(__tstate);
9720 if (PyErr_Occurred()) SWIG_fail;
9721 }
9722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9723 {
9724 if (temp2)
9725 delete arg2;
9726 }
9727 return resultobj;
9728 fail:
9729 {
9730 if (temp2)
9731 delete arg2;
9732 }
9733 return NULL;
9734 }
9735
9736
9737 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9738 PyObject *resultobj;
9739 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9740 bool arg2 = (bool) true ;
9741 PyObject * obj0 = 0 ;
9742 PyObject * obj1 = 0 ;
9743 char *kwnames[] = {
9744 (char *) "self",(char *) "bShow", NULL
9745 };
9746
9747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9749 if (SWIG_arg_fail(1)) SWIG_fail;
9750 if (obj1) {
9751 {
9752 arg2 = (bool)(SWIG_As_bool(obj1));
9753 if (SWIG_arg_fail(2)) SWIG_fail;
9754 }
9755 }
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 (arg1)->Show(arg2);
9759
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 Py_INCREF(Py_None); resultobj = Py_None;
9764 return resultobj;
9765 fail:
9766 return NULL;
9767 }
9768
9769
9770 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9771 PyObject *resultobj;
9772 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9773 wxFrame *result;
9774 PyObject * obj0 = 0 ;
9775 char *kwnames[] = {
9776 (char *) "self", NULL
9777 };
9778
9779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9781 if (SWIG_arg_fail(1)) SWIG_fail;
9782 {
9783 PyThreadState* __tstate = wxPyBeginAllowThreads();
9784 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9785
9786 wxPyEndAllowThreads(__tstate);
9787 if (PyErr_Occurred()) SWIG_fail;
9788 }
9789 {
9790 resultobj = wxPyMake_wxObject(result, 0);
9791 }
9792 return resultobj;
9793 fail:
9794 return NULL;
9795 }
9796
9797
9798 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9799 PyObject *resultobj;
9800 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9801 wxLog *result;
9802 PyObject * obj0 = 0 ;
9803 char *kwnames[] = {
9804 (char *) "self", NULL
9805 };
9806
9807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9809 if (SWIG_arg_fail(1)) SWIG_fail;
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9813
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9818 return resultobj;
9819 fail:
9820 return NULL;
9821 }
9822
9823
9824 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj;
9826 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9827 bool result;
9828 PyObject * obj0 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "self", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9839
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 {
9844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9845 }
9846 return resultobj;
9847 fail:
9848 return NULL;
9849 }
9850
9851
9852 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9853 PyObject *resultobj;
9854 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9855 bool arg2 ;
9856 PyObject * obj0 = 0 ;
9857 PyObject * obj1 = 0 ;
9858 char *kwnames[] = {
9859 (char *) "self",(char *) "bDoPass", NULL
9860 };
9861
9862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9864 if (SWIG_arg_fail(1)) SWIG_fail;
9865 {
9866 arg2 = (bool)(SWIG_As_bool(obj1));
9867 if (SWIG_arg_fail(2)) SWIG_fail;
9868 }
9869 {
9870 PyThreadState* __tstate = wxPyBeginAllowThreads();
9871 (arg1)->PassMessages(arg2);
9872
9873 wxPyEndAllowThreads(__tstate);
9874 if (PyErr_Occurred()) SWIG_fail;
9875 }
9876 Py_INCREF(Py_None); resultobj = Py_None;
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9884 PyObject *obj;
9885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9886 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9887 Py_INCREF(obj);
9888 return Py_BuildValue((char *)"");
9889 }
9890 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9891 PyObject *resultobj;
9892 wxLog *arg1 = (wxLog *) 0 ;
9893 wxLogChain *result;
9894 PyObject * obj0 = 0 ;
9895 char *kwnames[] = {
9896 (char *) "logger", NULL
9897 };
9898
9899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9901 if (SWIG_arg_fail(1)) SWIG_fail;
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (wxLogChain *)new wxLogChain(arg1);
9905
9906 wxPyEndAllowThreads(__tstate);
9907 if (PyErr_Occurred()) SWIG_fail;
9908 }
9909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9917 PyObject *resultobj;
9918 wxLogChain *arg1 = (wxLogChain *) 0 ;
9919 wxLog *arg2 = (wxLog *) 0 ;
9920 PyObject * obj0 = 0 ;
9921 PyObject * obj1 = 0 ;
9922 char *kwnames[] = {
9923 (char *) "self",(char *) "logger", NULL
9924 };
9925
9926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9928 if (SWIG_arg_fail(1)) SWIG_fail;
9929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(2)) SWIG_fail;
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 (arg1)->SetLog(arg2);
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 Py_INCREF(Py_None); resultobj = Py_None;
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9946 PyObject *resultobj;
9947 wxLogChain *arg1 = (wxLogChain *) 0 ;
9948 bool arg2 ;
9949 PyObject * obj0 = 0 ;
9950 PyObject * obj1 = 0 ;
9951 char *kwnames[] = {
9952 (char *) "self",(char *) "bDoPass", NULL
9953 };
9954
9955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9957 if (SWIG_arg_fail(1)) SWIG_fail;
9958 {
9959 arg2 = (bool)(SWIG_As_bool(obj1));
9960 if (SWIG_arg_fail(2)) SWIG_fail;
9961 }
9962 {
9963 PyThreadState* __tstate = wxPyBeginAllowThreads();
9964 (arg1)->PassMessages(arg2);
9965
9966 wxPyEndAllowThreads(__tstate);
9967 if (PyErr_Occurred()) SWIG_fail;
9968 }
9969 Py_INCREF(Py_None); resultobj = Py_None;
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9977 PyObject *resultobj;
9978 wxLogChain *arg1 = (wxLogChain *) 0 ;
9979 bool result;
9980 PyObject * obj0 = 0 ;
9981 char *kwnames[] = {
9982 (char *) "self", NULL
9983 };
9984
9985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9987 if (SWIG_arg_fail(1)) SWIG_fail;
9988 {
9989 PyThreadState* __tstate = wxPyBeginAllowThreads();
9990 result = (bool)(arg1)->IsPassingMessages();
9991
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 {
9996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9997 }
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj;
10006 wxLogChain *arg1 = (wxLogChain *) 0 ;
10007 wxLog *result;
10008 PyObject * obj0 = 0 ;
10009 char *kwnames[] = {
10010 (char *) "self", NULL
10011 };
10012
10013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10015 if (SWIG_arg_fail(1)) SWIG_fail;
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 result = (wxLog *)(arg1)->GetOldLog();
10019
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10024 return resultobj;
10025 fail:
10026 return NULL;
10027 }
10028
10029
10030 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10031 PyObject *obj;
10032 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10033 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10034 Py_INCREF(obj);
10035 return Py_BuildValue((char *)"");
10036 }
10037 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj;
10039 unsigned long result;
10040 char *kwnames[] = {
10041 NULL
10042 };
10043
10044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10045 {
10046 PyThreadState* __tstate = wxPyBeginAllowThreads();
10047 result = (unsigned long)wxSysErrorCode();
10048
10049 wxPyEndAllowThreads(__tstate);
10050 if (PyErr_Occurred()) SWIG_fail;
10051 }
10052 {
10053 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10054 }
10055 return resultobj;
10056 fail:
10057 return NULL;
10058 }
10059
10060
10061 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10062 PyObject *resultobj;
10063 unsigned long arg1 = (unsigned long) 0 ;
10064 wxString result;
10065 PyObject * obj0 = 0 ;
10066 char *kwnames[] = {
10067 (char *) "nErrCode", NULL
10068 };
10069
10070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10071 if (obj0) {
10072 {
10073 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10074 if (SWIG_arg_fail(1)) SWIG_fail;
10075 }
10076 }
10077 {
10078 PyThreadState* __tstate = wxPyBeginAllowThreads();
10079 result = wxSysErrorMsg(arg1);
10080
10081 wxPyEndAllowThreads(__tstate);
10082 if (PyErr_Occurred()) SWIG_fail;
10083 }
10084 {
10085 #if wxUSE_UNICODE
10086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10087 #else
10088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10089 #endif
10090 }
10091 return resultobj;
10092 fail:
10093 return NULL;
10094 }
10095
10096
10097 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10098 PyObject *resultobj;
10099 wxString *arg1 = 0 ;
10100 bool temp1 = false ;
10101 PyObject * obj0 = 0 ;
10102 char *kwnames[] = {
10103 (char *) "msg", NULL
10104 };
10105
10106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10107 {
10108 arg1 = wxString_in_helper(obj0);
10109 if (arg1 == NULL) SWIG_fail;
10110 temp1 = true;
10111 }
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 wxPyLogFatalError((wxString const &)*arg1);
10115
10116 wxPyEndAllowThreads(__tstate);
10117 if (PyErr_Occurred()) SWIG_fail;
10118 }
10119 Py_INCREF(Py_None); resultobj = Py_None;
10120 {
10121 if (temp1)
10122 delete arg1;
10123 }
10124 return resultobj;
10125 fail:
10126 {
10127 if (temp1)
10128 delete arg1;
10129 }
10130 return NULL;
10131 }
10132
10133
10134 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10135 PyObject *resultobj;
10136 wxString *arg1 = 0 ;
10137 bool temp1 = false ;
10138 PyObject * obj0 = 0 ;
10139 char *kwnames[] = {
10140 (char *) "msg", NULL
10141 };
10142
10143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10144 {
10145 arg1 = wxString_in_helper(obj0);
10146 if (arg1 == NULL) SWIG_fail;
10147 temp1 = true;
10148 }
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 wxPyLogError((wxString const &)*arg1);
10152
10153 wxPyEndAllowThreads(__tstate);
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 Py_INCREF(Py_None); resultobj = Py_None;
10157 {
10158 if (temp1)
10159 delete arg1;
10160 }
10161 return resultobj;
10162 fail:
10163 {
10164 if (temp1)
10165 delete arg1;
10166 }
10167 return NULL;
10168 }
10169
10170
10171 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10172 PyObject *resultobj;
10173 wxString *arg1 = 0 ;
10174 bool temp1 = false ;
10175 PyObject * obj0 = 0 ;
10176 char *kwnames[] = {
10177 (char *) "msg", NULL
10178 };
10179
10180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10181 {
10182 arg1 = wxString_in_helper(obj0);
10183 if (arg1 == NULL) SWIG_fail;
10184 temp1 = true;
10185 }
10186 {
10187 PyThreadState* __tstate = wxPyBeginAllowThreads();
10188 wxPyLogWarning((wxString const &)*arg1);
10189
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 Py_INCREF(Py_None); resultobj = Py_None;
10194 {
10195 if (temp1)
10196 delete arg1;
10197 }
10198 return resultobj;
10199 fail:
10200 {
10201 if (temp1)
10202 delete arg1;
10203 }
10204 return NULL;
10205 }
10206
10207
10208 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10209 PyObject *resultobj;
10210 wxString *arg1 = 0 ;
10211 bool temp1 = false ;
10212 PyObject * obj0 = 0 ;
10213 char *kwnames[] = {
10214 (char *) "msg", NULL
10215 };
10216
10217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10218 {
10219 arg1 = wxString_in_helper(obj0);
10220 if (arg1 == NULL) SWIG_fail;
10221 temp1 = true;
10222 }
10223 {
10224 PyThreadState* __tstate = wxPyBeginAllowThreads();
10225 wxPyLogMessage((wxString const &)*arg1);
10226
10227 wxPyEndAllowThreads(__tstate);
10228 if (PyErr_Occurred()) SWIG_fail;
10229 }
10230 Py_INCREF(Py_None); resultobj = Py_None;
10231 {
10232 if (temp1)
10233 delete arg1;
10234 }
10235 return resultobj;
10236 fail:
10237 {
10238 if (temp1)
10239 delete arg1;
10240 }
10241 return NULL;
10242 }
10243
10244
10245 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10246 PyObject *resultobj;
10247 wxString *arg1 = 0 ;
10248 bool temp1 = false ;
10249 PyObject * obj0 = 0 ;
10250 char *kwnames[] = {
10251 (char *) "msg", NULL
10252 };
10253
10254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10255 {
10256 arg1 = wxString_in_helper(obj0);
10257 if (arg1 == NULL) SWIG_fail;
10258 temp1 = true;
10259 }
10260 {
10261 PyThreadState* __tstate = wxPyBeginAllowThreads();
10262 wxPyLogInfo((wxString const &)*arg1);
10263
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 Py_INCREF(Py_None); resultobj = Py_None;
10268 {
10269 if (temp1)
10270 delete arg1;
10271 }
10272 return resultobj;
10273 fail:
10274 {
10275 if (temp1)
10276 delete arg1;
10277 }
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj;
10284 wxString *arg1 = 0 ;
10285 bool temp1 = false ;
10286 PyObject * obj0 = 0 ;
10287 char *kwnames[] = {
10288 (char *) "msg", NULL
10289 };
10290
10291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10292 {
10293 arg1 = wxString_in_helper(obj0);
10294 if (arg1 == NULL) SWIG_fail;
10295 temp1 = true;
10296 }
10297 {
10298 PyThreadState* __tstate = wxPyBeginAllowThreads();
10299 wxPyLogDebug((wxString const &)*arg1);
10300
10301 wxPyEndAllowThreads(__tstate);
10302 if (PyErr_Occurred()) SWIG_fail;
10303 }
10304 Py_INCREF(Py_None); resultobj = Py_None;
10305 {
10306 if (temp1)
10307 delete arg1;
10308 }
10309 return resultobj;
10310 fail:
10311 {
10312 if (temp1)
10313 delete arg1;
10314 }
10315 return NULL;
10316 }
10317
10318
10319 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10320 PyObject *resultobj;
10321 wxString *arg1 = 0 ;
10322 bool temp1 = false ;
10323 PyObject * obj0 = 0 ;
10324 char *kwnames[] = {
10325 (char *) "msg", NULL
10326 };
10327
10328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10329 {
10330 arg1 = wxString_in_helper(obj0);
10331 if (arg1 == NULL) SWIG_fail;
10332 temp1 = true;
10333 }
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 wxPyLogVerbose((wxString const &)*arg1);
10337
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 Py_INCREF(Py_None); resultobj = Py_None;
10342 {
10343 if (temp1)
10344 delete arg1;
10345 }
10346 return resultobj;
10347 fail:
10348 {
10349 if (temp1)
10350 delete arg1;
10351 }
10352 return NULL;
10353 }
10354
10355
10356 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10357 PyObject *resultobj;
10358 wxString *arg1 = 0 ;
10359 bool temp1 = false ;
10360 PyObject * obj0 = 0 ;
10361 char *kwnames[] = {
10362 (char *) "msg", NULL
10363 };
10364
10365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10366 {
10367 arg1 = wxString_in_helper(obj0);
10368 if (arg1 == NULL) SWIG_fail;
10369 temp1 = true;
10370 }
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 wxPyLogStatus((wxString const &)*arg1);
10374
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 Py_INCREF(Py_None); resultobj = Py_None;
10379 {
10380 if (temp1)
10381 delete arg1;
10382 }
10383 return resultobj;
10384 fail:
10385 {
10386 if (temp1)
10387 delete arg1;
10388 }
10389 return NULL;
10390 }
10391
10392
10393 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10394 PyObject *resultobj;
10395 wxFrame *arg1 = (wxFrame *) 0 ;
10396 wxString *arg2 = 0 ;
10397 bool temp2 = false ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400 char *kwnames[] = {
10401 (char *) "pFrame",(char *) "msg", NULL
10402 };
10403
10404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10406 if (SWIG_arg_fail(1)) SWIG_fail;
10407 {
10408 arg2 = wxString_in_helper(obj1);
10409 if (arg2 == NULL) SWIG_fail;
10410 temp2 = true;
10411 }
10412 {
10413 PyThreadState* __tstate = wxPyBeginAllowThreads();
10414 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10415
10416 wxPyEndAllowThreads(__tstate);
10417 if (PyErr_Occurred()) SWIG_fail;
10418 }
10419 Py_INCREF(Py_None); resultobj = Py_None;
10420 {
10421 if (temp2)
10422 delete arg2;
10423 }
10424 return resultobj;
10425 fail:
10426 {
10427 if (temp2)
10428 delete arg2;
10429 }
10430 return NULL;
10431 }
10432
10433
10434 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10435 PyObject *resultobj;
10436 wxString *arg1 = 0 ;
10437 bool temp1 = false ;
10438 PyObject * obj0 = 0 ;
10439 char *kwnames[] = {
10440 (char *) "msg", NULL
10441 };
10442
10443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10444 {
10445 arg1 = wxString_in_helper(obj0);
10446 if (arg1 == NULL) SWIG_fail;
10447 temp1 = true;
10448 }
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 wxPyLogSysError((wxString const &)*arg1);
10452
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 Py_INCREF(Py_None); resultobj = Py_None;
10457 {
10458 if (temp1)
10459 delete arg1;
10460 }
10461 return resultobj;
10462 fail:
10463 {
10464 if (temp1)
10465 delete arg1;
10466 }
10467 return NULL;
10468 }
10469
10470
10471 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10472 PyObject *resultobj;
10473 unsigned long arg1 ;
10474 wxString *arg2 = 0 ;
10475 bool temp2 = false ;
10476 PyObject * obj0 = 0 ;
10477 PyObject * obj1 = 0 ;
10478 char *kwnames[] = {
10479 (char *) "level",(char *) "msg", NULL
10480 };
10481
10482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10483 {
10484 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10485 if (SWIG_arg_fail(1)) SWIG_fail;
10486 }
10487 {
10488 arg2 = wxString_in_helper(obj1);
10489 if (arg2 == NULL) SWIG_fail;
10490 temp2 = true;
10491 }
10492 {
10493 PyThreadState* __tstate = wxPyBeginAllowThreads();
10494 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10495
10496 wxPyEndAllowThreads(__tstate);
10497 if (PyErr_Occurred()) SWIG_fail;
10498 }
10499 Py_INCREF(Py_None); resultobj = Py_None;
10500 {
10501 if (temp2)
10502 delete arg2;
10503 }
10504 return resultobj;
10505 fail:
10506 {
10507 if (temp2)
10508 delete arg2;
10509 }
10510 return NULL;
10511 }
10512
10513
10514 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10515 PyObject *resultobj;
10516 unsigned long arg1 ;
10517 wxString *arg2 = 0 ;
10518 bool temp2 = false ;
10519 PyObject * obj0 = 0 ;
10520 PyObject * obj1 = 0 ;
10521
10522 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10523 {
10524 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10525 if (SWIG_arg_fail(1)) SWIG_fail;
10526 }
10527 {
10528 arg2 = wxString_in_helper(obj1);
10529 if (arg2 == NULL) SWIG_fail;
10530 temp2 = true;
10531 }
10532 {
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 wxPyLogTrace(arg1,(wxString const &)*arg2);
10535
10536 wxPyEndAllowThreads(__tstate);
10537 if (PyErr_Occurred()) SWIG_fail;
10538 }
10539 Py_INCREF(Py_None); resultobj = Py_None;
10540 {
10541 if (temp2)
10542 delete arg2;
10543 }
10544 return resultobj;
10545 fail:
10546 {
10547 if (temp2)
10548 delete arg2;
10549 }
10550 return NULL;
10551 }
10552
10553
10554 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10555 PyObject *resultobj;
10556 wxString *arg1 = 0 ;
10557 wxString *arg2 = 0 ;
10558 bool temp1 = false ;
10559 bool temp2 = false ;
10560 PyObject * obj0 = 0 ;
10561 PyObject * obj1 = 0 ;
10562
10563 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10564 {
10565 arg1 = wxString_in_helper(obj0);
10566 if (arg1 == NULL) SWIG_fail;
10567 temp1 = true;
10568 }
10569 {
10570 arg2 = wxString_in_helper(obj1);
10571 if (arg2 == NULL) SWIG_fail;
10572 temp2 = true;
10573 }
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10577
10578 wxPyEndAllowThreads(__tstate);
10579 if (PyErr_Occurred()) SWIG_fail;
10580 }
10581 Py_INCREF(Py_None); resultobj = Py_None;
10582 {
10583 if (temp1)
10584 delete arg1;
10585 }
10586 {
10587 if (temp2)
10588 delete arg2;
10589 }
10590 return resultobj;
10591 fail:
10592 {
10593 if (temp1)
10594 delete arg1;
10595 }
10596 {
10597 if (temp2)
10598 delete arg2;
10599 }
10600 return NULL;
10601 }
10602
10603
10604 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10605 int argc;
10606 PyObject *argv[3];
10607 int ii;
10608
10609 argc = PyObject_Length(args);
10610 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10611 argv[ii] = PyTuple_GetItem(args,ii);
10612 }
10613 if (argc == 2) {
10614 int _v;
10615 {
10616 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10617 }
10618 if (_v) {
10619 {
10620 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10621 }
10622 if (_v) {
10623 return _wrap_LogTrace__SWIG_1(self,args);
10624 }
10625 }
10626 }
10627 if (argc == 2) {
10628 int _v;
10629 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10630 if (_v) {
10631 {
10632 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10633 }
10634 if (_v) {
10635 return _wrap_LogTrace__SWIG_0(self,args);
10636 }
10637 }
10638 }
10639
10640 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10641 return NULL;
10642 }
10643
10644
10645 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10646 PyObject *resultobj;
10647 wxString *arg1 = 0 ;
10648 wxString *arg2 = 0 ;
10649 bool temp1 = false ;
10650 bool temp2 = false ;
10651 PyObject * obj0 = 0 ;
10652 PyObject * obj1 = 0 ;
10653 char *kwnames[] = {
10654 (char *) "title",(char *) "text", NULL
10655 };
10656
10657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10658 {
10659 arg1 = wxString_in_helper(obj0);
10660 if (arg1 == NULL) SWIG_fail;
10661 temp1 = true;
10662 }
10663 {
10664 arg2 = wxString_in_helper(obj1);
10665 if (arg2 == NULL) SWIG_fail;
10666 temp2 = true;
10667 }
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10671
10672 wxPyEndAllowThreads(__tstate);
10673 if (PyErr_Occurred()) SWIG_fail;
10674 }
10675 Py_INCREF(Py_None); resultobj = Py_None;
10676 {
10677 if (temp1)
10678 delete arg1;
10679 }
10680 {
10681 if (temp2)
10682 delete arg2;
10683 }
10684 return resultobj;
10685 fail:
10686 {
10687 if (temp1)
10688 delete arg1;
10689 }
10690 {
10691 if (temp2)
10692 delete arg2;
10693 }
10694 return NULL;
10695 }
10696
10697
10698 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj;
10700 wxLogNull *result;
10701 char *kwnames[] = {
10702 NULL
10703 };
10704
10705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10706 {
10707 PyThreadState* __tstate = wxPyBeginAllowThreads();
10708 result = (wxLogNull *)new wxLogNull();
10709
10710 wxPyEndAllowThreads(__tstate);
10711 if (PyErr_Occurred()) SWIG_fail;
10712 }
10713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10714 return resultobj;
10715 fail:
10716 return NULL;
10717 }
10718
10719
10720 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10721 PyObject *resultobj;
10722 wxLogNull *arg1 = (wxLogNull *) 0 ;
10723 PyObject * obj0 = 0 ;
10724 char *kwnames[] = {
10725 (char *) "self", NULL
10726 };
10727
10728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10730 if (SWIG_arg_fail(1)) SWIG_fail;
10731 {
10732 PyThreadState* __tstate = wxPyBeginAllowThreads();
10733 delete arg1;
10734
10735 wxPyEndAllowThreads(__tstate);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 Py_INCREF(Py_None); resultobj = Py_None;
10739 return resultobj;
10740 fail:
10741 return NULL;
10742 }
10743
10744
10745 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10746 PyObject *obj;
10747 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10748 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10749 Py_INCREF(obj);
10750 return Py_BuildValue((char *)"");
10751 }
10752 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10753 PyObject *resultobj;
10754 wxPyLog *result;
10755 char *kwnames[] = {
10756 NULL
10757 };
10758
10759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10760 {
10761 PyThreadState* __tstate = wxPyBeginAllowThreads();
10762 result = (wxPyLog *)new wxPyLog();
10763
10764 wxPyEndAllowThreads(__tstate);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10775 PyObject *resultobj;
10776 wxPyLog *arg1 = (wxPyLog *) 0 ;
10777 PyObject *arg2 = (PyObject *) 0 ;
10778 PyObject *arg3 = (PyObject *) 0 ;
10779 PyObject * obj0 = 0 ;
10780 PyObject * obj1 = 0 ;
10781 PyObject * obj2 = 0 ;
10782 char *kwnames[] = {
10783 (char *) "self",(char *) "self",(char *) "_class", NULL
10784 };
10785
10786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10788 if (SWIG_arg_fail(1)) SWIG_fail;
10789 arg2 = obj1;
10790 arg3 = obj2;
10791 {
10792 PyThreadState* __tstate = wxPyBeginAllowThreads();
10793 (arg1)->_setCallbackInfo(arg2,arg3);
10794
10795 wxPyEndAllowThreads(__tstate);
10796 if (PyErr_Occurred()) SWIG_fail;
10797 }
10798 Py_INCREF(Py_None); resultobj = Py_None;
10799 return resultobj;
10800 fail:
10801 return NULL;
10802 }
10803
10804
10805 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10806 PyObject *obj;
10807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10808 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10809 Py_INCREF(obj);
10810 return Py_BuildValue((char *)"");
10811 }
10812 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10813 PyObject *resultobj;
10814 int arg1 ;
10815 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10816 int arg3 = (int) wxKILL_NOCHILDREN ;
10817 wxKillError result;
10818 PyObject * obj0 = 0 ;
10819 PyObject * obj1 = 0 ;
10820 PyObject * obj2 = 0 ;
10821 char *kwnames[] = {
10822 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10823 };
10824
10825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10826 {
10827 arg1 = (int)(SWIG_As_int(obj0));
10828 if (SWIG_arg_fail(1)) SWIG_fail;
10829 }
10830 if (obj1) {
10831 {
10832 arg2 = (wxSignal)(SWIG_As_int(obj1));
10833 if (SWIG_arg_fail(2)) SWIG_fail;
10834 }
10835 }
10836 if (obj2) {
10837 {
10838 arg3 = (int)(SWIG_As_int(obj2));
10839 if (SWIG_arg_fail(3)) SWIG_fail;
10840 }
10841 }
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10845
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 resultobj = SWIG_From_int((result));
10850 return resultobj;
10851 fail:
10852 return NULL;
10853 }
10854
10855
10856 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10857 PyObject *resultobj;
10858 int arg1 ;
10859 bool result;
10860 PyObject * obj0 = 0 ;
10861 char *kwnames[] = {
10862 (char *) "pid", NULL
10863 };
10864
10865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10866 {
10867 arg1 = (int)(SWIG_As_int(obj0));
10868 if (SWIG_arg_fail(1)) SWIG_fail;
10869 }
10870 {
10871 PyThreadState* __tstate = wxPyBeginAllowThreads();
10872 result = (bool)wxPyProcess::Exists(arg1);
10873
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 {
10878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10879 }
10880 return resultobj;
10881 fail:
10882 return NULL;
10883 }
10884
10885
10886 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10887 PyObject *resultobj;
10888 wxString *arg1 = 0 ;
10889 int arg2 = (int) wxEXEC_ASYNC ;
10890 wxPyProcess *result;
10891 bool temp1 = false ;
10892 PyObject * obj0 = 0 ;
10893 PyObject * obj1 = 0 ;
10894 char *kwnames[] = {
10895 (char *) "cmd",(char *) "flags", NULL
10896 };
10897
10898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10899 {
10900 arg1 = wxString_in_helper(obj0);
10901 if (arg1 == NULL) SWIG_fail;
10902 temp1 = true;
10903 }
10904 if (obj1) {
10905 {
10906 arg2 = (int)(SWIG_As_int(obj1));
10907 if (SWIG_arg_fail(2)) SWIG_fail;
10908 }
10909 }
10910 {
10911 PyThreadState* __tstate = wxPyBeginAllowThreads();
10912 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10913
10914 wxPyEndAllowThreads(__tstate);
10915 if (PyErr_Occurred()) SWIG_fail;
10916 }
10917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10918 {
10919 if (temp1)
10920 delete arg1;
10921 }
10922 return resultobj;
10923 fail:
10924 {
10925 if (temp1)
10926 delete arg1;
10927 }
10928 return NULL;
10929 }
10930
10931
10932 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10933 PyObject *resultobj;
10934 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10935 int arg2 = (int) -1 ;
10936 wxPyProcess *result;
10937 PyObject * obj0 = 0 ;
10938 PyObject * obj1 = 0 ;
10939 char *kwnames[] = {
10940 (char *) "parent",(char *) "id", NULL
10941 };
10942
10943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10944 if (obj0) {
10945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10946 if (SWIG_arg_fail(1)) SWIG_fail;
10947 }
10948 if (obj1) {
10949 {
10950 arg2 = (int)(SWIG_As_int(obj1));
10951 if (SWIG_arg_fail(2)) SWIG_fail;
10952 }
10953 }
10954 {
10955 PyThreadState* __tstate = wxPyBeginAllowThreads();
10956 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10957
10958 wxPyEndAllowThreads(__tstate);
10959 if (PyErr_Occurred()) SWIG_fail;
10960 }
10961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10962 return resultobj;
10963 fail:
10964 return NULL;
10965 }
10966
10967
10968 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10969 PyObject *resultobj;
10970 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10971 PyObject *arg2 = (PyObject *) 0 ;
10972 PyObject *arg3 = (PyObject *) 0 ;
10973 PyObject * obj0 = 0 ;
10974 PyObject * obj1 = 0 ;
10975 PyObject * obj2 = 0 ;
10976 char *kwnames[] = {
10977 (char *) "self",(char *) "self",(char *) "_class", NULL
10978 };
10979
10980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10982 if (SWIG_arg_fail(1)) SWIG_fail;
10983 arg2 = obj1;
10984 arg3 = obj2;
10985 {
10986 PyThreadState* __tstate = wxPyBeginAllowThreads();
10987 (arg1)->_setCallbackInfo(arg2,arg3);
10988
10989 wxPyEndAllowThreads(__tstate);
10990 if (PyErr_Occurred()) SWIG_fail;
10991 }
10992 Py_INCREF(Py_None); resultobj = Py_None;
10993 return resultobj;
10994 fail:
10995 return NULL;
10996 }
10997
10998
10999 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11000 PyObject *resultobj;
11001 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11002 int arg2 ;
11003 int arg3 ;
11004 PyObject * obj0 = 0 ;
11005 PyObject * obj1 = 0 ;
11006 PyObject * obj2 = 0 ;
11007 char *kwnames[] = {
11008 (char *) "self",(char *) "pid",(char *) "status", NULL
11009 };
11010
11011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11013 if (SWIG_arg_fail(1)) SWIG_fail;
11014 {
11015 arg2 = (int)(SWIG_As_int(obj1));
11016 if (SWIG_arg_fail(2)) SWIG_fail;
11017 }
11018 {
11019 arg3 = (int)(SWIG_As_int(obj2));
11020 if (SWIG_arg_fail(3)) SWIG_fail;
11021 }
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 (arg1)->base_OnTerminate(arg2,arg3);
11025
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 Py_INCREF(Py_None); resultobj = Py_None;
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11037 PyObject *resultobj;
11038 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11039 PyObject * obj0 = 0 ;
11040 char *kwnames[] = {
11041 (char *) "self", NULL
11042 };
11043
11044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11046 if (SWIG_arg_fail(1)) SWIG_fail;
11047 {
11048 PyThreadState* __tstate = wxPyBeginAllowThreads();
11049 (arg1)->Redirect();
11050
11051 wxPyEndAllowThreads(__tstate);
11052 if (PyErr_Occurred()) SWIG_fail;
11053 }
11054 Py_INCREF(Py_None); resultobj = Py_None;
11055 return resultobj;
11056 fail:
11057 return NULL;
11058 }
11059
11060
11061 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11062 PyObject *resultobj;
11063 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11064 bool result;
11065 PyObject * obj0 = 0 ;
11066 char *kwnames[] = {
11067 (char *) "self", NULL
11068 };
11069
11070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11072 if (SWIG_arg_fail(1)) SWIG_fail;
11073 {
11074 PyThreadState* __tstate = wxPyBeginAllowThreads();
11075 result = (bool)(arg1)->IsRedirected();
11076
11077 wxPyEndAllowThreads(__tstate);
11078 if (PyErr_Occurred()) SWIG_fail;
11079 }
11080 {
11081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11082 }
11083 return resultobj;
11084 fail:
11085 return NULL;
11086 }
11087
11088
11089 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11090 PyObject *resultobj;
11091 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11092 PyObject * obj0 = 0 ;
11093 char *kwnames[] = {
11094 (char *) "self", NULL
11095 };
11096
11097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11099 if (SWIG_arg_fail(1)) SWIG_fail;
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 (arg1)->Detach();
11103
11104 wxPyEndAllowThreads(__tstate);
11105 if (PyErr_Occurred()) SWIG_fail;
11106 }
11107 Py_INCREF(Py_None); resultobj = Py_None;
11108 return resultobj;
11109 fail:
11110 return NULL;
11111 }
11112
11113
11114 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11115 PyObject *resultobj;
11116 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11117 wxInputStream *result;
11118 PyObject * obj0 = 0 ;
11119 char *kwnames[] = {
11120 (char *) "self", NULL
11121 };
11122
11123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11125 if (SWIG_arg_fail(1)) SWIG_fail;
11126 {
11127 PyThreadState* __tstate = wxPyBeginAllowThreads();
11128 result = (wxInputStream *)(arg1)->GetInputStream();
11129
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 {
11134 wxPyInputStream * _ptr = NULL;
11135
11136 if (result) {
11137 _ptr = new wxPyInputStream(result);
11138 }
11139 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11140 }
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj;
11149 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11150 wxInputStream *result;
11151 PyObject * obj0 = 0 ;
11152 char *kwnames[] = {
11153 (char *) "self", NULL
11154 };
11155
11156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11158 if (SWIG_arg_fail(1)) SWIG_fail;
11159 {
11160 PyThreadState* __tstate = wxPyBeginAllowThreads();
11161 result = (wxInputStream *)(arg1)->GetErrorStream();
11162
11163 wxPyEndAllowThreads(__tstate);
11164 if (PyErr_Occurred()) SWIG_fail;
11165 }
11166 {
11167 wxPyInputStream * _ptr = NULL;
11168
11169 if (result) {
11170 _ptr = new wxPyInputStream(result);
11171 }
11172 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11173 }
11174 return resultobj;
11175 fail:
11176 return NULL;
11177 }
11178
11179
11180 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11181 PyObject *resultobj;
11182 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11183 wxOutputStream *result;
11184 PyObject * obj0 = 0 ;
11185 char *kwnames[] = {
11186 (char *) "self", NULL
11187 };
11188
11189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11191 if (SWIG_arg_fail(1)) SWIG_fail;
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (wxOutputStream *)(arg1)->GetOutputStream();
11195
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11200 return resultobj;
11201 fail:
11202 return NULL;
11203 }
11204
11205
11206 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj;
11208 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11209 PyObject * obj0 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "self", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11216 if (SWIG_arg_fail(1)) SWIG_fail;
11217 {
11218 PyThreadState* __tstate = wxPyBeginAllowThreads();
11219 (arg1)->CloseOutput();
11220
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 Py_INCREF(Py_None); resultobj = Py_None;
11225 return resultobj;
11226 fail:
11227 return NULL;
11228 }
11229
11230
11231 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11232 PyObject *resultobj;
11233 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11234 bool result;
11235 PyObject * obj0 = 0 ;
11236 char *kwnames[] = {
11237 (char *) "self", NULL
11238 };
11239
11240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11242 if (SWIG_arg_fail(1)) SWIG_fail;
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11246
11247 wxPyEndAllowThreads(__tstate);
11248 if (PyErr_Occurred()) SWIG_fail;
11249 }
11250 {
11251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11252 }
11253 return resultobj;
11254 fail:
11255 return NULL;
11256 }
11257
11258
11259 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj;
11261 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11262 bool result;
11263 PyObject * obj0 = 0 ;
11264 char *kwnames[] = {
11265 (char *) "self", NULL
11266 };
11267
11268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11270 if (SWIG_arg_fail(1)) SWIG_fail;
11271 {
11272 PyThreadState* __tstate = wxPyBeginAllowThreads();
11273 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11274
11275 wxPyEndAllowThreads(__tstate);
11276 if (PyErr_Occurred()) SWIG_fail;
11277 }
11278 {
11279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11280 }
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj;
11289 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11290 bool result;
11291 PyObject * obj0 = 0 ;
11292 char *kwnames[] = {
11293 (char *) "self", NULL
11294 };
11295
11296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11298 if (SWIG_arg_fail(1)) SWIG_fail;
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11302
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 {
11307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11308 }
11309 return resultobj;
11310 fail:
11311 return NULL;
11312 }
11313
11314
11315 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11316 PyObject *obj;
11317 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11318 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11319 Py_INCREF(obj);
11320 return Py_BuildValue((char *)"");
11321 }
11322 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11323 PyObject *resultobj;
11324 int arg1 = (int) 0 ;
11325 int arg2 = (int) 0 ;
11326 int arg3 = (int) 0 ;
11327 wxProcessEvent *result;
11328 PyObject * obj0 = 0 ;
11329 PyObject * obj1 = 0 ;
11330 PyObject * obj2 = 0 ;
11331 char *kwnames[] = {
11332 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11333 };
11334
11335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11336 if (obj0) {
11337 {
11338 arg1 = (int)(SWIG_As_int(obj0));
11339 if (SWIG_arg_fail(1)) SWIG_fail;
11340 }
11341 }
11342 if (obj1) {
11343 {
11344 arg2 = (int)(SWIG_As_int(obj1));
11345 if (SWIG_arg_fail(2)) SWIG_fail;
11346 }
11347 }
11348 if (obj2) {
11349 {
11350 arg3 = (int)(SWIG_As_int(obj2));
11351 if (SWIG_arg_fail(3)) SWIG_fail;
11352 }
11353 }
11354 {
11355 PyThreadState* __tstate = wxPyBeginAllowThreads();
11356 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11357
11358 wxPyEndAllowThreads(__tstate);
11359 if (PyErr_Occurred()) SWIG_fail;
11360 }
11361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11362 return resultobj;
11363 fail:
11364 return NULL;
11365 }
11366
11367
11368 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11369 PyObject *resultobj;
11370 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11371 int result;
11372 PyObject * obj0 = 0 ;
11373 char *kwnames[] = {
11374 (char *) "self", NULL
11375 };
11376
11377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11379 if (SWIG_arg_fail(1)) SWIG_fail;
11380 {
11381 PyThreadState* __tstate = wxPyBeginAllowThreads();
11382 result = (int)(arg1)->GetPid();
11383
11384 wxPyEndAllowThreads(__tstate);
11385 if (PyErr_Occurred()) SWIG_fail;
11386 }
11387 {
11388 resultobj = SWIG_From_int((int)(result));
11389 }
11390 return resultobj;
11391 fail:
11392 return NULL;
11393 }
11394
11395
11396 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11397 PyObject *resultobj;
11398 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11399 int result;
11400 PyObject * obj0 = 0 ;
11401 char *kwnames[] = {
11402 (char *) "self", NULL
11403 };
11404
11405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11407 if (SWIG_arg_fail(1)) SWIG_fail;
11408 {
11409 PyThreadState* __tstate = wxPyBeginAllowThreads();
11410 result = (int)(arg1)->GetExitCode();
11411
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 {
11416 resultobj = SWIG_From_int((int)(result));
11417 }
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj;
11426 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11427 int arg2 ;
11428 PyObject * obj0 = 0 ;
11429 PyObject * obj1 = 0 ;
11430 char *kwnames[] = {
11431 (char *) "self",(char *) "m_pid", NULL
11432 };
11433
11434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11436 if (SWIG_arg_fail(1)) SWIG_fail;
11437 {
11438 arg2 = (int)(SWIG_As_int(obj1));
11439 if (SWIG_arg_fail(2)) SWIG_fail;
11440 }
11441 if (arg1) (arg1)->m_pid = arg2;
11442
11443 Py_INCREF(Py_None); resultobj = Py_None;
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj;
11452 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11453 int result;
11454 PyObject * obj0 = 0 ;
11455 char *kwnames[] = {
11456 (char *) "self", NULL
11457 };
11458
11459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11461 if (SWIG_arg_fail(1)) SWIG_fail;
11462 result = (int) ((arg1)->m_pid);
11463
11464 {
11465 resultobj = SWIG_From_int((int)(result));
11466 }
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj;
11475 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11476 int arg2 ;
11477 PyObject * obj0 = 0 ;
11478 PyObject * obj1 = 0 ;
11479 char *kwnames[] = {
11480 (char *) "self",(char *) "m_exitcode", NULL
11481 };
11482
11483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11485 if (SWIG_arg_fail(1)) SWIG_fail;
11486 {
11487 arg2 = (int)(SWIG_As_int(obj1));
11488 if (SWIG_arg_fail(2)) SWIG_fail;
11489 }
11490 if (arg1) (arg1)->m_exitcode = arg2;
11491
11492 Py_INCREF(Py_None); resultobj = Py_None;
11493 return resultobj;
11494 fail:
11495 return NULL;
11496 }
11497
11498
11499 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj;
11501 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11502 int result;
11503 PyObject * obj0 = 0 ;
11504 char *kwnames[] = {
11505 (char *) "self", NULL
11506 };
11507
11508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11510 if (SWIG_arg_fail(1)) SWIG_fail;
11511 result = (int) ((arg1)->m_exitcode);
11512
11513 {
11514 resultobj = SWIG_From_int((int)(result));
11515 }
11516 return resultobj;
11517 fail:
11518 return NULL;
11519 }
11520
11521
11522 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11523 PyObject *obj;
11524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11525 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11526 Py_INCREF(obj);
11527 return Py_BuildValue((char *)"");
11528 }
11529 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj;
11531 wxString *arg1 = 0 ;
11532 int arg2 = (int) wxEXEC_ASYNC ;
11533 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11534 long result;
11535 bool temp1 = false ;
11536 PyObject * obj0 = 0 ;
11537 PyObject * obj1 = 0 ;
11538 PyObject * obj2 = 0 ;
11539 char *kwnames[] = {
11540 (char *) "command",(char *) "flags",(char *) "process", NULL
11541 };
11542
11543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11544 {
11545 arg1 = wxString_in_helper(obj0);
11546 if (arg1 == NULL) SWIG_fail;
11547 temp1 = true;
11548 }
11549 if (obj1) {
11550 {
11551 arg2 = (int)(SWIG_As_int(obj1));
11552 if (SWIG_arg_fail(2)) SWIG_fail;
11553 }
11554 }
11555 if (obj2) {
11556 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11557 if (SWIG_arg_fail(3)) SWIG_fail;
11558 }
11559 {
11560 if (!wxPyCheckForApp()) SWIG_fail;
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11563
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 {
11568 resultobj = SWIG_From_long((long)(result));
11569 }
11570 {
11571 if (temp1)
11572 delete arg1;
11573 }
11574 return resultobj;
11575 fail:
11576 {
11577 if (temp1)
11578 delete arg1;
11579 }
11580 return NULL;
11581 }
11582
11583
11584 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11585 PyObject *resultobj;
11586 long arg1 ;
11587 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11588 wxKillError *arg3 = (wxKillError *) 0 ;
11589 int arg4 = (int) wxKILL_NOCHILDREN ;
11590 int result;
11591 wxKillError temp3 ;
11592 PyObject * obj0 = 0 ;
11593 PyObject * obj1 = 0 ;
11594 PyObject * obj2 = 0 ;
11595 char *kwnames[] = {
11596 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11597 };
11598
11599 {
11600 arg3 = &temp3;
11601 }
11602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11603 {
11604 arg1 = (long)(SWIG_As_long(obj0));
11605 if (SWIG_arg_fail(1)) SWIG_fail;
11606 }
11607 if (obj1) {
11608 {
11609 arg2 = (wxSignal)(SWIG_As_int(obj1));
11610 if (SWIG_arg_fail(2)) SWIG_fail;
11611 }
11612 }
11613 if (obj2) {
11614 {
11615 arg4 = (int)(SWIG_As_int(obj2));
11616 if (SWIG_arg_fail(4)) SWIG_fail;
11617 }
11618 }
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11622
11623 wxPyEndAllowThreads(__tstate);
11624 if (PyErr_Occurred()) SWIG_fail;
11625 }
11626 {
11627 resultobj = SWIG_From_int((int)(result));
11628 }
11629 {
11630 PyObject* o;
11631 o = PyInt_FromLong((long) (*arg3));
11632 resultobj = t_output_helper(resultobj, o);
11633 }
11634 return resultobj;
11635 fail:
11636 return NULL;
11637 }
11638
11639
11640 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11641 PyObject *resultobj;
11642 int arg1 = (int) wxJOYSTICK1 ;
11643 wxJoystick *result;
11644 PyObject * obj0 = 0 ;
11645 char *kwnames[] = {
11646 (char *) "joystick", NULL
11647 };
11648
11649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11650 if (obj0) {
11651 {
11652 arg1 = (int)(SWIG_As_int(obj0));
11653 if (SWIG_arg_fail(1)) SWIG_fail;
11654 }
11655 }
11656 {
11657 if (!wxPyCheckForApp()) SWIG_fail;
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (wxJoystick *)new wxJoystick(arg1);
11660
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11665 return resultobj;
11666 fail:
11667 return NULL;
11668 }
11669
11670
11671 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11672 PyObject *resultobj;
11673 wxJoystick *arg1 = (wxJoystick *) 0 ;
11674 PyObject * obj0 = 0 ;
11675 char *kwnames[] = {
11676 (char *) "self", NULL
11677 };
11678
11679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11681 if (SWIG_arg_fail(1)) SWIG_fail;
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 delete arg1;
11685
11686 wxPyEndAllowThreads(__tstate);
11687 if (PyErr_Occurred()) SWIG_fail;
11688 }
11689 Py_INCREF(Py_None); resultobj = Py_None;
11690 return resultobj;
11691 fail:
11692 return NULL;
11693 }
11694
11695
11696 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11697 PyObject *resultobj;
11698 wxJoystick *arg1 = (wxJoystick *) 0 ;
11699 wxPoint result;
11700 PyObject * obj0 = 0 ;
11701 char *kwnames[] = {
11702 (char *) "self", NULL
11703 };
11704
11705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11707 if (SWIG_arg_fail(1)) SWIG_fail;
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = (arg1)->GetPosition();
11711
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 {
11716 wxPoint * resultptr;
11717 resultptr = new wxPoint((wxPoint &)(result));
11718 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11719 }
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11727 PyObject *resultobj;
11728 wxJoystick *arg1 = (wxJoystick *) 0 ;
11729 int result;
11730 PyObject * obj0 = 0 ;
11731 char *kwnames[] = {
11732 (char *) "self", NULL
11733 };
11734
11735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11737 if (SWIG_arg_fail(1)) SWIG_fail;
11738 {
11739 PyThreadState* __tstate = wxPyBeginAllowThreads();
11740 result = (int)(arg1)->GetZPosition();
11741
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 resultobj = SWIG_From_int((int)(result));
11747 }
11748 return resultobj;
11749 fail:
11750 return NULL;
11751 }
11752
11753
11754 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11755 PyObject *resultobj;
11756 wxJoystick *arg1 = (wxJoystick *) 0 ;
11757 int result;
11758 PyObject * obj0 = 0 ;
11759 char *kwnames[] = {
11760 (char *) "self", NULL
11761 };
11762
11763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11765 if (SWIG_arg_fail(1)) SWIG_fail;
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (int)(arg1)->GetButtonState();
11769
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 resultobj = SWIG_From_int((int)(result));
11775 }
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11783 PyObject *resultobj;
11784 wxJoystick *arg1 = (wxJoystick *) 0 ;
11785 int result;
11786 PyObject * obj0 = 0 ;
11787 char *kwnames[] = {
11788 (char *) "self", NULL
11789 };
11790
11791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11793 if (SWIG_arg_fail(1)) SWIG_fail;
11794 {
11795 PyThreadState* __tstate = wxPyBeginAllowThreads();
11796 result = (int)(arg1)->GetPOVPosition();
11797
11798 wxPyEndAllowThreads(__tstate);
11799 if (PyErr_Occurred()) SWIG_fail;
11800 }
11801 {
11802 resultobj = SWIG_From_int((int)(result));
11803 }
11804 return resultobj;
11805 fail:
11806 return NULL;
11807 }
11808
11809
11810 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj;
11812 wxJoystick *arg1 = (wxJoystick *) 0 ;
11813 int result;
11814 PyObject * obj0 = 0 ;
11815 char *kwnames[] = {
11816 (char *) "self", NULL
11817 };
11818
11819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11821 if (SWIG_arg_fail(1)) SWIG_fail;
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (int)(arg1)->GetPOVCTSPosition();
11825
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 {
11830 resultobj = SWIG_From_int((int)(result));
11831 }
11832 return resultobj;
11833 fail:
11834 return NULL;
11835 }
11836
11837
11838 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11839 PyObject *resultobj;
11840 wxJoystick *arg1 = (wxJoystick *) 0 ;
11841 int result;
11842 PyObject * obj0 = 0 ;
11843 char *kwnames[] = {
11844 (char *) "self", NULL
11845 };
11846
11847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11849 if (SWIG_arg_fail(1)) SWIG_fail;
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (int)(arg1)->GetRudderPosition();
11853
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 {
11858 resultobj = SWIG_From_int((int)(result));
11859 }
11860 return resultobj;
11861 fail:
11862 return NULL;
11863 }
11864
11865
11866 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11867 PyObject *resultobj;
11868 wxJoystick *arg1 = (wxJoystick *) 0 ;
11869 int result;
11870 PyObject * obj0 = 0 ;
11871 char *kwnames[] = {
11872 (char *) "self", NULL
11873 };
11874
11875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11877 if (SWIG_arg_fail(1)) SWIG_fail;
11878 {
11879 PyThreadState* __tstate = wxPyBeginAllowThreads();
11880 result = (int)(arg1)->GetUPosition();
11881
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 {
11886 resultobj = SWIG_From_int((int)(result));
11887 }
11888 return resultobj;
11889 fail:
11890 return NULL;
11891 }
11892
11893
11894 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11895 PyObject *resultobj;
11896 wxJoystick *arg1 = (wxJoystick *) 0 ;
11897 int result;
11898 PyObject * obj0 = 0 ;
11899 char *kwnames[] = {
11900 (char *) "self", NULL
11901 };
11902
11903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11905 if (SWIG_arg_fail(1)) SWIG_fail;
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 result = (int)(arg1)->GetVPosition();
11909
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 {
11914 resultobj = SWIG_From_int((int)(result));
11915 }
11916 return resultobj;
11917 fail:
11918 return NULL;
11919 }
11920
11921
11922 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11923 PyObject *resultobj;
11924 wxJoystick *arg1 = (wxJoystick *) 0 ;
11925 int result;
11926 PyObject * obj0 = 0 ;
11927 char *kwnames[] = {
11928 (char *) "self", NULL
11929 };
11930
11931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11933 if (SWIG_arg_fail(1)) SWIG_fail;
11934 {
11935 PyThreadState* __tstate = wxPyBeginAllowThreads();
11936 result = (int)(arg1)->GetMovementThreshold();
11937
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 {
11942 resultobj = SWIG_From_int((int)(result));
11943 }
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11951 PyObject *resultobj;
11952 wxJoystick *arg1 = (wxJoystick *) 0 ;
11953 int arg2 ;
11954 PyObject * obj0 = 0 ;
11955 PyObject * obj1 = 0 ;
11956 char *kwnames[] = {
11957 (char *) "self",(char *) "threshold", NULL
11958 };
11959
11960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11962 if (SWIG_arg_fail(1)) SWIG_fail;
11963 {
11964 arg2 = (int)(SWIG_As_int(obj1));
11965 if (SWIG_arg_fail(2)) SWIG_fail;
11966 }
11967 {
11968 PyThreadState* __tstate = wxPyBeginAllowThreads();
11969 (arg1)->SetMovementThreshold(arg2);
11970
11971 wxPyEndAllowThreads(__tstate);
11972 if (PyErr_Occurred()) SWIG_fail;
11973 }
11974 Py_INCREF(Py_None); resultobj = Py_None;
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11982 PyObject *resultobj;
11983 wxJoystick *arg1 = (wxJoystick *) 0 ;
11984 bool result;
11985 PyObject * obj0 = 0 ;
11986 char *kwnames[] = {
11987 (char *) "self", NULL
11988 };
11989
11990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11992 if (SWIG_arg_fail(1)) SWIG_fail;
11993 {
11994 PyThreadState* __tstate = wxPyBeginAllowThreads();
11995 result = (bool)(arg1)->IsOk();
11996
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 {
12001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12002 }
12003 return resultobj;
12004 fail:
12005 return NULL;
12006 }
12007
12008
12009 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12010 PyObject *resultobj;
12011 wxJoystick *arg1 = (wxJoystick *) 0 ;
12012 int result;
12013 PyObject * obj0 = 0 ;
12014 char *kwnames[] = {
12015 (char *) "self", NULL
12016 };
12017
12018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12020 if (SWIG_arg_fail(1)) SWIG_fail;
12021 {
12022 PyThreadState* __tstate = wxPyBeginAllowThreads();
12023 result = (int)(arg1)->GetNumberJoysticks();
12024
12025 wxPyEndAllowThreads(__tstate);
12026 if (PyErr_Occurred()) SWIG_fail;
12027 }
12028 {
12029 resultobj = SWIG_From_int((int)(result));
12030 }
12031 return resultobj;
12032 fail:
12033 return NULL;
12034 }
12035
12036
12037 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj;
12039 wxJoystick *arg1 = (wxJoystick *) 0 ;
12040 int result;
12041 PyObject * obj0 = 0 ;
12042 char *kwnames[] = {
12043 (char *) "self", NULL
12044 };
12045
12046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12048 if (SWIG_arg_fail(1)) SWIG_fail;
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 result = (int)(arg1)->GetManufacturerId();
12052
12053 wxPyEndAllowThreads(__tstate);
12054 if (PyErr_Occurred()) SWIG_fail;
12055 }
12056 {
12057 resultobj = SWIG_From_int((int)(result));
12058 }
12059 return resultobj;
12060 fail:
12061 return NULL;
12062 }
12063
12064
12065 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12066 PyObject *resultobj;
12067 wxJoystick *arg1 = (wxJoystick *) 0 ;
12068 int result;
12069 PyObject * obj0 = 0 ;
12070 char *kwnames[] = {
12071 (char *) "self", NULL
12072 };
12073
12074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12076 if (SWIG_arg_fail(1)) SWIG_fail;
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 result = (int)(arg1)->GetProductId();
12080
12081 wxPyEndAllowThreads(__tstate);
12082 if (PyErr_Occurred()) SWIG_fail;
12083 }
12084 {
12085 resultobj = SWIG_From_int((int)(result));
12086 }
12087 return resultobj;
12088 fail:
12089 return NULL;
12090 }
12091
12092
12093 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12094 PyObject *resultobj;
12095 wxJoystick *arg1 = (wxJoystick *) 0 ;
12096 wxString result;
12097 PyObject * obj0 = 0 ;
12098 char *kwnames[] = {
12099 (char *) "self", NULL
12100 };
12101
12102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12104 if (SWIG_arg_fail(1)) SWIG_fail;
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (arg1)->GetProductName();
12108
12109 wxPyEndAllowThreads(__tstate);
12110 if (PyErr_Occurred()) SWIG_fail;
12111 }
12112 {
12113 #if wxUSE_UNICODE
12114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12115 #else
12116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12117 #endif
12118 }
12119 return resultobj;
12120 fail:
12121 return NULL;
12122 }
12123
12124
12125 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12126 PyObject *resultobj;
12127 wxJoystick *arg1 = (wxJoystick *) 0 ;
12128 int result;
12129 PyObject * obj0 = 0 ;
12130 char *kwnames[] = {
12131 (char *) "self", NULL
12132 };
12133
12134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12136 if (SWIG_arg_fail(1)) SWIG_fail;
12137 {
12138 PyThreadState* __tstate = wxPyBeginAllowThreads();
12139 result = (int)(arg1)->GetXMin();
12140
12141 wxPyEndAllowThreads(__tstate);
12142 if (PyErr_Occurred()) SWIG_fail;
12143 }
12144 {
12145 resultobj = SWIG_From_int((int)(result));
12146 }
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12154 PyObject *resultobj;
12155 wxJoystick *arg1 = (wxJoystick *) 0 ;
12156 int result;
12157 PyObject * obj0 = 0 ;
12158 char *kwnames[] = {
12159 (char *) "self", NULL
12160 };
12161
12162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12164 if (SWIG_arg_fail(1)) SWIG_fail;
12165 {
12166 PyThreadState* __tstate = wxPyBeginAllowThreads();
12167 result = (int)(arg1)->GetYMin();
12168
12169 wxPyEndAllowThreads(__tstate);
12170 if (PyErr_Occurred()) SWIG_fail;
12171 }
12172 {
12173 resultobj = SWIG_From_int((int)(result));
12174 }
12175 return resultobj;
12176 fail:
12177 return NULL;
12178 }
12179
12180
12181 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12182 PyObject *resultobj;
12183 wxJoystick *arg1 = (wxJoystick *) 0 ;
12184 int result;
12185 PyObject * obj0 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "self", NULL
12188 };
12189
12190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 {
12194 PyThreadState* __tstate = wxPyBeginAllowThreads();
12195 result = (int)(arg1)->GetZMin();
12196
12197 wxPyEndAllowThreads(__tstate);
12198 if (PyErr_Occurred()) SWIG_fail;
12199 }
12200 {
12201 resultobj = SWIG_From_int((int)(result));
12202 }
12203 return resultobj;
12204 fail:
12205 return NULL;
12206 }
12207
12208
12209 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12210 PyObject *resultobj;
12211 wxJoystick *arg1 = (wxJoystick *) 0 ;
12212 int result;
12213 PyObject * obj0 = 0 ;
12214 char *kwnames[] = {
12215 (char *) "self", NULL
12216 };
12217
12218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12220 if (SWIG_arg_fail(1)) SWIG_fail;
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 result = (int)(arg1)->GetXMax();
12224
12225 wxPyEndAllowThreads(__tstate);
12226 if (PyErr_Occurred()) SWIG_fail;
12227 }
12228 {
12229 resultobj = SWIG_From_int((int)(result));
12230 }
12231 return resultobj;
12232 fail:
12233 return NULL;
12234 }
12235
12236
12237 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12238 PyObject *resultobj;
12239 wxJoystick *arg1 = (wxJoystick *) 0 ;
12240 int result;
12241 PyObject * obj0 = 0 ;
12242 char *kwnames[] = {
12243 (char *) "self", NULL
12244 };
12245
12246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12248 if (SWIG_arg_fail(1)) SWIG_fail;
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 result = (int)(arg1)->GetYMax();
12252
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 {
12257 resultobj = SWIG_From_int((int)(result));
12258 }
12259 return resultobj;
12260 fail:
12261 return NULL;
12262 }
12263
12264
12265 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12266 PyObject *resultobj;
12267 wxJoystick *arg1 = (wxJoystick *) 0 ;
12268 int result;
12269 PyObject * obj0 = 0 ;
12270 char *kwnames[] = {
12271 (char *) "self", NULL
12272 };
12273
12274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12276 if (SWIG_arg_fail(1)) SWIG_fail;
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 result = (int)(arg1)->GetZMax();
12280
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 {
12285 resultobj = SWIG_From_int((int)(result));
12286 }
12287 return resultobj;
12288 fail:
12289 return NULL;
12290 }
12291
12292
12293 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12294 PyObject *resultobj;
12295 wxJoystick *arg1 = (wxJoystick *) 0 ;
12296 int result;
12297 PyObject * obj0 = 0 ;
12298 char *kwnames[] = {
12299 (char *) "self", NULL
12300 };
12301
12302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12304 if (SWIG_arg_fail(1)) SWIG_fail;
12305 {
12306 PyThreadState* __tstate = wxPyBeginAllowThreads();
12307 result = (int)(arg1)->GetNumberButtons();
12308
12309 wxPyEndAllowThreads(__tstate);
12310 if (PyErr_Occurred()) SWIG_fail;
12311 }
12312 {
12313 resultobj = SWIG_From_int((int)(result));
12314 }
12315 return resultobj;
12316 fail:
12317 return NULL;
12318 }
12319
12320
12321 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12322 PyObject *resultobj;
12323 wxJoystick *arg1 = (wxJoystick *) 0 ;
12324 int result;
12325 PyObject * obj0 = 0 ;
12326 char *kwnames[] = {
12327 (char *) "self", NULL
12328 };
12329
12330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12332 if (SWIG_arg_fail(1)) SWIG_fail;
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 result = (int)(arg1)->GetNumberAxes();
12336
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 {
12341 resultobj = SWIG_From_int((int)(result));
12342 }
12343 return resultobj;
12344 fail:
12345 return NULL;
12346 }
12347
12348
12349 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12350 PyObject *resultobj;
12351 wxJoystick *arg1 = (wxJoystick *) 0 ;
12352 int result;
12353 PyObject * obj0 = 0 ;
12354 char *kwnames[] = {
12355 (char *) "self", NULL
12356 };
12357
12358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12360 if (SWIG_arg_fail(1)) SWIG_fail;
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 result = (int)(arg1)->GetMaxButtons();
12364
12365 wxPyEndAllowThreads(__tstate);
12366 if (PyErr_Occurred()) SWIG_fail;
12367 }
12368 {
12369 resultobj = SWIG_From_int((int)(result));
12370 }
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj;
12379 wxJoystick *arg1 = (wxJoystick *) 0 ;
12380 int result;
12381 PyObject * obj0 = 0 ;
12382 char *kwnames[] = {
12383 (char *) "self", NULL
12384 };
12385
12386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12388 if (SWIG_arg_fail(1)) SWIG_fail;
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 result = (int)(arg1)->GetMaxAxes();
12392
12393 wxPyEndAllowThreads(__tstate);
12394 if (PyErr_Occurred()) SWIG_fail;
12395 }
12396 {
12397 resultobj = SWIG_From_int((int)(result));
12398 }
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj;
12407 wxJoystick *arg1 = (wxJoystick *) 0 ;
12408 int result;
12409 PyObject * obj0 = 0 ;
12410 char *kwnames[] = {
12411 (char *) "self", NULL
12412 };
12413
12414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12416 if (SWIG_arg_fail(1)) SWIG_fail;
12417 {
12418 PyThreadState* __tstate = wxPyBeginAllowThreads();
12419 result = (int)(arg1)->GetPollingMin();
12420
12421 wxPyEndAllowThreads(__tstate);
12422 if (PyErr_Occurred()) SWIG_fail;
12423 }
12424 {
12425 resultobj = SWIG_From_int((int)(result));
12426 }
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj;
12435 wxJoystick *arg1 = (wxJoystick *) 0 ;
12436 int result;
12437 PyObject * obj0 = 0 ;
12438 char *kwnames[] = {
12439 (char *) "self", NULL
12440 };
12441
12442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12444 if (SWIG_arg_fail(1)) SWIG_fail;
12445 {
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 result = (int)(arg1)->GetPollingMax();
12448
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 {
12453 resultobj = SWIG_From_int((int)(result));
12454 }
12455 return resultobj;
12456 fail:
12457 return NULL;
12458 }
12459
12460
12461 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12462 PyObject *resultobj;
12463 wxJoystick *arg1 = (wxJoystick *) 0 ;
12464 int result;
12465 PyObject * obj0 = 0 ;
12466 char *kwnames[] = {
12467 (char *) "self", NULL
12468 };
12469
12470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12472 if (SWIG_arg_fail(1)) SWIG_fail;
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 result = (int)(arg1)->GetRudderMin();
12476
12477 wxPyEndAllowThreads(__tstate);
12478 if (PyErr_Occurred()) SWIG_fail;
12479 }
12480 {
12481 resultobj = SWIG_From_int((int)(result));
12482 }
12483 return resultobj;
12484 fail:
12485 return NULL;
12486 }
12487
12488
12489 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12490 PyObject *resultobj;
12491 wxJoystick *arg1 = (wxJoystick *) 0 ;
12492 int result;
12493 PyObject * obj0 = 0 ;
12494 char *kwnames[] = {
12495 (char *) "self", NULL
12496 };
12497
12498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12500 if (SWIG_arg_fail(1)) SWIG_fail;
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 result = (int)(arg1)->GetRudderMax();
12504
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 {
12509 resultobj = SWIG_From_int((int)(result));
12510 }
12511 return resultobj;
12512 fail:
12513 return NULL;
12514 }
12515
12516
12517 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12518 PyObject *resultobj;
12519 wxJoystick *arg1 = (wxJoystick *) 0 ;
12520 int result;
12521 PyObject * obj0 = 0 ;
12522 char *kwnames[] = {
12523 (char *) "self", NULL
12524 };
12525
12526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12528 if (SWIG_arg_fail(1)) SWIG_fail;
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 result = (int)(arg1)->GetUMin();
12532
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 {
12537 resultobj = SWIG_From_int((int)(result));
12538 }
12539 return resultobj;
12540 fail:
12541 return NULL;
12542 }
12543
12544
12545 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12546 PyObject *resultobj;
12547 wxJoystick *arg1 = (wxJoystick *) 0 ;
12548 int result;
12549 PyObject * obj0 = 0 ;
12550 char *kwnames[] = {
12551 (char *) "self", NULL
12552 };
12553
12554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12556 if (SWIG_arg_fail(1)) SWIG_fail;
12557 {
12558 PyThreadState* __tstate = wxPyBeginAllowThreads();
12559 result = (int)(arg1)->GetUMax();
12560
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 {
12565 resultobj = SWIG_From_int((int)(result));
12566 }
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12574 PyObject *resultobj;
12575 wxJoystick *arg1 = (wxJoystick *) 0 ;
12576 int result;
12577 PyObject * obj0 = 0 ;
12578 char *kwnames[] = {
12579 (char *) "self", NULL
12580 };
12581
12582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12584 if (SWIG_arg_fail(1)) SWIG_fail;
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 result = (int)(arg1)->GetVMin();
12588
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 {
12593 resultobj = SWIG_From_int((int)(result));
12594 }
12595 return resultobj;
12596 fail:
12597 return NULL;
12598 }
12599
12600
12601 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj;
12603 wxJoystick *arg1 = (wxJoystick *) 0 ;
12604 int result;
12605 PyObject * obj0 = 0 ;
12606 char *kwnames[] = {
12607 (char *) "self", NULL
12608 };
12609
12610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12612 if (SWIG_arg_fail(1)) SWIG_fail;
12613 {
12614 PyThreadState* __tstate = wxPyBeginAllowThreads();
12615 result = (int)(arg1)->GetVMax();
12616
12617 wxPyEndAllowThreads(__tstate);
12618 if (PyErr_Occurred()) SWIG_fail;
12619 }
12620 {
12621 resultobj = SWIG_From_int((int)(result));
12622 }
12623 return resultobj;
12624 fail:
12625 return NULL;
12626 }
12627
12628
12629 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12630 PyObject *resultobj;
12631 wxJoystick *arg1 = (wxJoystick *) 0 ;
12632 bool result;
12633 PyObject * obj0 = 0 ;
12634 char *kwnames[] = {
12635 (char *) "self", NULL
12636 };
12637
12638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12640 if (SWIG_arg_fail(1)) SWIG_fail;
12641 {
12642 PyThreadState* __tstate = wxPyBeginAllowThreads();
12643 result = (bool)(arg1)->HasRudder();
12644
12645 wxPyEndAllowThreads(__tstate);
12646 if (PyErr_Occurred()) SWIG_fail;
12647 }
12648 {
12649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12650 }
12651 return resultobj;
12652 fail:
12653 return NULL;
12654 }
12655
12656
12657 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12658 PyObject *resultobj;
12659 wxJoystick *arg1 = (wxJoystick *) 0 ;
12660 bool result;
12661 PyObject * obj0 = 0 ;
12662 char *kwnames[] = {
12663 (char *) "self", NULL
12664 };
12665
12666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12668 if (SWIG_arg_fail(1)) SWIG_fail;
12669 {
12670 PyThreadState* __tstate = wxPyBeginAllowThreads();
12671 result = (bool)(arg1)->HasZ();
12672
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 {
12677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12678 }
12679 return resultobj;
12680 fail:
12681 return NULL;
12682 }
12683
12684
12685 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12686 PyObject *resultobj;
12687 wxJoystick *arg1 = (wxJoystick *) 0 ;
12688 bool result;
12689 PyObject * obj0 = 0 ;
12690 char *kwnames[] = {
12691 (char *) "self", NULL
12692 };
12693
12694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12696 if (SWIG_arg_fail(1)) SWIG_fail;
12697 {
12698 PyThreadState* __tstate = wxPyBeginAllowThreads();
12699 result = (bool)(arg1)->HasU();
12700
12701 wxPyEndAllowThreads(__tstate);
12702 if (PyErr_Occurred()) SWIG_fail;
12703 }
12704 {
12705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12706 }
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12714 PyObject *resultobj;
12715 wxJoystick *arg1 = (wxJoystick *) 0 ;
12716 bool result;
12717 PyObject * obj0 = 0 ;
12718 char *kwnames[] = {
12719 (char *) "self", NULL
12720 };
12721
12722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12724 if (SWIG_arg_fail(1)) SWIG_fail;
12725 {
12726 PyThreadState* __tstate = wxPyBeginAllowThreads();
12727 result = (bool)(arg1)->HasV();
12728
12729 wxPyEndAllowThreads(__tstate);
12730 if (PyErr_Occurred()) SWIG_fail;
12731 }
12732 {
12733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12734 }
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12742 PyObject *resultobj;
12743 wxJoystick *arg1 = (wxJoystick *) 0 ;
12744 bool result;
12745 PyObject * obj0 = 0 ;
12746 char *kwnames[] = {
12747 (char *) "self", NULL
12748 };
12749
12750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12752 if (SWIG_arg_fail(1)) SWIG_fail;
12753 {
12754 PyThreadState* __tstate = wxPyBeginAllowThreads();
12755 result = (bool)(arg1)->HasPOV();
12756
12757 wxPyEndAllowThreads(__tstate);
12758 if (PyErr_Occurred()) SWIG_fail;
12759 }
12760 {
12761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12762 }
12763 return resultobj;
12764 fail:
12765 return NULL;
12766 }
12767
12768
12769 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12770 PyObject *resultobj;
12771 wxJoystick *arg1 = (wxJoystick *) 0 ;
12772 bool result;
12773 PyObject * obj0 = 0 ;
12774 char *kwnames[] = {
12775 (char *) "self", NULL
12776 };
12777
12778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12780 if (SWIG_arg_fail(1)) SWIG_fail;
12781 {
12782 PyThreadState* __tstate = wxPyBeginAllowThreads();
12783 result = (bool)(arg1)->HasPOV4Dir();
12784
12785 wxPyEndAllowThreads(__tstate);
12786 if (PyErr_Occurred()) SWIG_fail;
12787 }
12788 {
12789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12790 }
12791 return resultobj;
12792 fail:
12793 return NULL;
12794 }
12795
12796
12797 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12798 PyObject *resultobj;
12799 wxJoystick *arg1 = (wxJoystick *) 0 ;
12800 bool result;
12801 PyObject * obj0 = 0 ;
12802 char *kwnames[] = {
12803 (char *) "self", NULL
12804 };
12805
12806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12808 if (SWIG_arg_fail(1)) SWIG_fail;
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 result = (bool)(arg1)->HasPOVCTS();
12812
12813 wxPyEndAllowThreads(__tstate);
12814 if (PyErr_Occurred()) SWIG_fail;
12815 }
12816 {
12817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12818 }
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12826 PyObject *resultobj;
12827 wxJoystick *arg1 = (wxJoystick *) 0 ;
12828 wxWindow *arg2 = (wxWindow *) 0 ;
12829 int arg3 = (int) 0 ;
12830 bool result;
12831 PyObject * obj0 = 0 ;
12832 PyObject * obj1 = 0 ;
12833 PyObject * obj2 = 0 ;
12834 char *kwnames[] = {
12835 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12836 };
12837
12838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12840 if (SWIG_arg_fail(1)) SWIG_fail;
12841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12842 if (SWIG_arg_fail(2)) SWIG_fail;
12843 if (obj2) {
12844 {
12845 arg3 = (int)(SWIG_As_int(obj2));
12846 if (SWIG_arg_fail(3)) SWIG_fail;
12847 }
12848 }
12849 {
12850 PyThreadState* __tstate = wxPyBeginAllowThreads();
12851 result = (bool)(arg1)->SetCapture(arg2,arg3);
12852
12853 wxPyEndAllowThreads(__tstate);
12854 if (PyErr_Occurred()) SWIG_fail;
12855 }
12856 {
12857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12858 }
12859 return resultobj;
12860 fail:
12861 return NULL;
12862 }
12863
12864
12865 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12866 PyObject *resultobj;
12867 wxJoystick *arg1 = (wxJoystick *) 0 ;
12868 bool result;
12869 PyObject * obj0 = 0 ;
12870 char *kwnames[] = {
12871 (char *) "self", NULL
12872 };
12873
12874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12876 if (SWIG_arg_fail(1)) SWIG_fail;
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 result = (bool)(arg1)->ReleaseCapture();
12880
12881 wxPyEndAllowThreads(__tstate);
12882 if (PyErr_Occurred()) SWIG_fail;
12883 }
12884 {
12885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12886 }
12887 return resultobj;
12888 fail:
12889 return NULL;
12890 }
12891
12892
12893 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12894 PyObject *obj;
12895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12896 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12897 Py_INCREF(obj);
12898 return Py_BuildValue((char *)"");
12899 }
12900 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12901 PyObject *resultobj;
12902 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12903 int arg2 = (int) 0 ;
12904 int arg3 = (int) wxJOYSTICK1 ;
12905 int arg4 = (int) 0 ;
12906 wxJoystickEvent *result;
12907 PyObject * obj0 = 0 ;
12908 PyObject * obj1 = 0 ;
12909 PyObject * obj2 = 0 ;
12910 PyObject * obj3 = 0 ;
12911 char *kwnames[] = {
12912 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12913 };
12914
12915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12916 if (obj0) {
12917 {
12918 arg1 = (wxEventType)(SWIG_As_int(obj0));
12919 if (SWIG_arg_fail(1)) SWIG_fail;
12920 }
12921 }
12922 if (obj1) {
12923 {
12924 arg2 = (int)(SWIG_As_int(obj1));
12925 if (SWIG_arg_fail(2)) SWIG_fail;
12926 }
12927 }
12928 if (obj2) {
12929 {
12930 arg3 = (int)(SWIG_As_int(obj2));
12931 if (SWIG_arg_fail(3)) SWIG_fail;
12932 }
12933 }
12934 if (obj3) {
12935 {
12936 arg4 = (int)(SWIG_As_int(obj3));
12937 if (SWIG_arg_fail(4)) SWIG_fail;
12938 }
12939 }
12940 {
12941 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12943
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12948 return resultobj;
12949 fail:
12950 return NULL;
12951 }
12952
12953
12954 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12955 PyObject *resultobj;
12956 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12957 wxPoint result;
12958 PyObject * obj0 = 0 ;
12959 char *kwnames[] = {
12960 (char *) "self", NULL
12961 };
12962
12963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12965 if (SWIG_arg_fail(1)) SWIG_fail;
12966 {
12967 PyThreadState* __tstate = wxPyBeginAllowThreads();
12968 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12969
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 {
12974 wxPoint * resultptr;
12975 resultptr = new wxPoint((wxPoint &)(result));
12976 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12977 }
12978 return resultobj;
12979 fail:
12980 return NULL;
12981 }
12982
12983
12984 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12985 PyObject *resultobj;
12986 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12987 int result;
12988 PyObject * obj0 = 0 ;
12989 char *kwnames[] = {
12990 (char *) "self", NULL
12991 };
12992
12993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12995 if (SWIG_arg_fail(1)) SWIG_fail;
12996 {
12997 PyThreadState* __tstate = wxPyBeginAllowThreads();
12998 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12999
13000 wxPyEndAllowThreads(__tstate);
13001 if (PyErr_Occurred()) SWIG_fail;
13002 }
13003 {
13004 resultobj = SWIG_From_int((int)(result));
13005 }
13006 return resultobj;
13007 fail:
13008 return NULL;
13009 }
13010
13011
13012 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13013 PyObject *resultobj;
13014 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13015 int result;
13016 PyObject * obj0 = 0 ;
13017 char *kwnames[] = {
13018 (char *) "self", NULL
13019 };
13020
13021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13023 if (SWIG_arg_fail(1)) SWIG_fail;
13024 {
13025 PyThreadState* __tstate = wxPyBeginAllowThreads();
13026 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13027
13028 wxPyEndAllowThreads(__tstate);
13029 if (PyErr_Occurred()) SWIG_fail;
13030 }
13031 {
13032 resultobj = SWIG_From_int((int)(result));
13033 }
13034 return resultobj;
13035 fail:
13036 return NULL;
13037 }
13038
13039
13040 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13041 PyObject *resultobj;
13042 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13043 int result;
13044 PyObject * obj0 = 0 ;
13045 char *kwnames[] = {
13046 (char *) "self", NULL
13047 };
13048
13049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13051 if (SWIG_arg_fail(1)) SWIG_fail;
13052 {
13053 PyThreadState* __tstate = wxPyBeginAllowThreads();
13054 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13055
13056 wxPyEndAllowThreads(__tstate);
13057 if (PyErr_Occurred()) SWIG_fail;
13058 }
13059 {
13060 resultobj = SWIG_From_int((int)(result));
13061 }
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13069 PyObject *resultobj;
13070 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13071 int result;
13072 PyObject * obj0 = 0 ;
13073 char *kwnames[] = {
13074 (char *) "self", NULL
13075 };
13076
13077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13079 if (SWIG_arg_fail(1)) SWIG_fail;
13080 {
13081 PyThreadState* __tstate = wxPyBeginAllowThreads();
13082 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13083
13084 wxPyEndAllowThreads(__tstate);
13085 if (PyErr_Occurred()) SWIG_fail;
13086 }
13087 {
13088 resultobj = SWIG_From_int((int)(result));
13089 }
13090 return resultobj;
13091 fail:
13092 return NULL;
13093 }
13094
13095
13096 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13097 PyObject *resultobj;
13098 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13099 int arg2 ;
13100 PyObject * obj0 = 0 ;
13101 PyObject * obj1 = 0 ;
13102 char *kwnames[] = {
13103 (char *) "self",(char *) "stick", NULL
13104 };
13105
13106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13108 if (SWIG_arg_fail(1)) SWIG_fail;
13109 {
13110 arg2 = (int)(SWIG_As_int(obj1));
13111 if (SWIG_arg_fail(2)) SWIG_fail;
13112 }
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 (arg1)->SetJoystick(arg2);
13116
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 Py_INCREF(Py_None); resultobj = Py_None;
13121 return resultobj;
13122 fail:
13123 return NULL;
13124 }
13125
13126
13127 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13128 PyObject *resultobj;
13129 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13130 int arg2 ;
13131 PyObject * obj0 = 0 ;
13132 PyObject * obj1 = 0 ;
13133 char *kwnames[] = {
13134 (char *) "self",(char *) "state", NULL
13135 };
13136
13137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13139 if (SWIG_arg_fail(1)) SWIG_fail;
13140 {
13141 arg2 = (int)(SWIG_As_int(obj1));
13142 if (SWIG_arg_fail(2)) SWIG_fail;
13143 }
13144 {
13145 PyThreadState* __tstate = wxPyBeginAllowThreads();
13146 (arg1)->SetButtonState(arg2);
13147
13148 wxPyEndAllowThreads(__tstate);
13149 if (PyErr_Occurred()) SWIG_fail;
13150 }
13151 Py_INCREF(Py_None); resultobj = Py_None;
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13159 PyObject *resultobj;
13160 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13161 int arg2 ;
13162 PyObject * obj0 = 0 ;
13163 PyObject * obj1 = 0 ;
13164 char *kwnames[] = {
13165 (char *) "self",(char *) "change", NULL
13166 };
13167
13168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13170 if (SWIG_arg_fail(1)) SWIG_fail;
13171 {
13172 arg2 = (int)(SWIG_As_int(obj1));
13173 if (SWIG_arg_fail(2)) SWIG_fail;
13174 }
13175 {
13176 PyThreadState* __tstate = wxPyBeginAllowThreads();
13177 (arg1)->SetButtonChange(arg2);
13178
13179 wxPyEndAllowThreads(__tstate);
13180 if (PyErr_Occurred()) SWIG_fail;
13181 }
13182 Py_INCREF(Py_None); resultobj = Py_None;
13183 return resultobj;
13184 fail:
13185 return NULL;
13186 }
13187
13188
13189 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13190 PyObject *resultobj;
13191 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13192 wxPoint *arg2 = 0 ;
13193 wxPoint temp2 ;
13194 PyObject * obj0 = 0 ;
13195 PyObject * obj1 = 0 ;
13196 char *kwnames[] = {
13197 (char *) "self",(char *) "pos", NULL
13198 };
13199
13200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13202 if (SWIG_arg_fail(1)) SWIG_fail;
13203 {
13204 arg2 = &temp2;
13205 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13206 }
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 (arg1)->SetPosition((wxPoint const &)*arg2);
13210
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 Py_INCREF(Py_None); resultobj = Py_None;
13215 return resultobj;
13216 fail:
13217 return NULL;
13218 }
13219
13220
13221 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13222 PyObject *resultobj;
13223 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13224 int arg2 ;
13225 PyObject * obj0 = 0 ;
13226 PyObject * obj1 = 0 ;
13227 char *kwnames[] = {
13228 (char *) "self",(char *) "zPos", NULL
13229 };
13230
13231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13233 if (SWIG_arg_fail(1)) SWIG_fail;
13234 {
13235 arg2 = (int)(SWIG_As_int(obj1));
13236 if (SWIG_arg_fail(2)) SWIG_fail;
13237 }
13238 {
13239 PyThreadState* __tstate = wxPyBeginAllowThreads();
13240 (arg1)->SetZPosition(arg2);
13241
13242 wxPyEndAllowThreads(__tstate);
13243 if (PyErr_Occurred()) SWIG_fail;
13244 }
13245 Py_INCREF(Py_None); resultobj = Py_None;
13246 return resultobj;
13247 fail:
13248 return NULL;
13249 }
13250
13251
13252 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13253 PyObject *resultobj;
13254 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13255 bool result;
13256 PyObject * obj0 = 0 ;
13257 char *kwnames[] = {
13258 (char *) "self", NULL
13259 };
13260
13261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13263 if (SWIG_arg_fail(1)) SWIG_fail;
13264 {
13265 PyThreadState* __tstate = wxPyBeginAllowThreads();
13266 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13267
13268 wxPyEndAllowThreads(__tstate);
13269 if (PyErr_Occurred()) SWIG_fail;
13270 }
13271 {
13272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13273 }
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj;
13282 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13283 bool result;
13284 PyObject * obj0 = 0 ;
13285 char *kwnames[] = {
13286 (char *) "self", NULL
13287 };
13288
13289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13291 if (SWIG_arg_fail(1)) SWIG_fail;
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13295
13296 wxPyEndAllowThreads(__tstate);
13297 if (PyErr_Occurred()) SWIG_fail;
13298 }
13299 {
13300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13301 }
13302 return resultobj;
13303 fail:
13304 return NULL;
13305 }
13306
13307
13308 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13309 PyObject *resultobj;
13310 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13311 bool result;
13312 PyObject * obj0 = 0 ;
13313 char *kwnames[] = {
13314 (char *) "self", NULL
13315 };
13316
13317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13319 if (SWIG_arg_fail(1)) SWIG_fail;
13320 {
13321 PyThreadState* __tstate = wxPyBeginAllowThreads();
13322 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13323
13324 wxPyEndAllowThreads(__tstate);
13325 if (PyErr_Occurred()) SWIG_fail;
13326 }
13327 {
13328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13329 }
13330 return resultobj;
13331 fail:
13332 return NULL;
13333 }
13334
13335
13336 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13337 PyObject *resultobj;
13338 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13339 int arg2 = (int) wxJOY_BUTTON_ANY ;
13340 bool result;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 char *kwnames[] = {
13344 (char *) "self",(char *) "but", NULL
13345 };
13346
13347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13349 if (SWIG_arg_fail(1)) SWIG_fail;
13350 if (obj1) {
13351 {
13352 arg2 = (int)(SWIG_As_int(obj1));
13353 if (SWIG_arg_fail(2)) SWIG_fail;
13354 }
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13359
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 {
13364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13365 }
13366 return resultobj;
13367 fail:
13368 return NULL;
13369 }
13370
13371
13372 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj;
13374 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13375 int arg2 = (int) wxJOY_BUTTON_ANY ;
13376 bool result;
13377 PyObject * obj0 = 0 ;
13378 PyObject * obj1 = 0 ;
13379 char *kwnames[] = {
13380 (char *) "self",(char *) "but", NULL
13381 };
13382
13383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13385 if (SWIG_arg_fail(1)) SWIG_fail;
13386 if (obj1) {
13387 {
13388 arg2 = (int)(SWIG_As_int(obj1));
13389 if (SWIG_arg_fail(2)) SWIG_fail;
13390 }
13391 }
13392 {
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13395
13396 wxPyEndAllowThreads(__tstate);
13397 if (PyErr_Occurred()) SWIG_fail;
13398 }
13399 {
13400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13401 }
13402 return resultobj;
13403 fail:
13404 return NULL;
13405 }
13406
13407
13408 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13409 PyObject *resultobj;
13410 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13411 int arg2 = (int) wxJOY_BUTTON_ANY ;
13412 bool result;
13413 PyObject * obj0 = 0 ;
13414 PyObject * obj1 = 0 ;
13415 char *kwnames[] = {
13416 (char *) "self",(char *) "but", NULL
13417 };
13418
13419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13421 if (SWIG_arg_fail(1)) SWIG_fail;
13422 if (obj1) {
13423 {
13424 arg2 = (int)(SWIG_As_int(obj1));
13425 if (SWIG_arg_fail(2)) SWIG_fail;
13426 }
13427 }
13428 {
13429 PyThreadState* __tstate = wxPyBeginAllowThreads();
13430 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13431
13432 wxPyEndAllowThreads(__tstate);
13433 if (PyErr_Occurred()) SWIG_fail;
13434 }
13435 {
13436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13437 }
13438 return resultobj;
13439 fail:
13440 return NULL;
13441 }
13442
13443
13444 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13445 PyObject *obj;
13446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13447 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13448 Py_INCREF(obj);
13449 return Py_BuildValue((char *)"");
13450 }
13451 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13452 PyObject *resultobj;
13453 wxString const &arg1_defvalue = wxPyEmptyString ;
13454 wxString *arg1 = (wxString *) &arg1_defvalue ;
13455 wxSound *result;
13456 bool temp1 = false ;
13457 PyObject * obj0 = 0 ;
13458 char *kwnames[] = {
13459 (char *) "fileName", NULL
13460 };
13461
13462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13463 if (obj0) {
13464 {
13465 arg1 = wxString_in_helper(obj0);
13466 if (arg1 == NULL) SWIG_fail;
13467 temp1 = true;
13468 }
13469 }
13470 {
13471 if (!wxPyCheckForApp()) SWIG_fail;
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13474
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13479 {
13480 if (temp1)
13481 delete arg1;
13482 }
13483 return resultobj;
13484 fail:
13485 {
13486 if (temp1)
13487 delete arg1;
13488 }
13489 return NULL;
13490 }
13491
13492
13493 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj;
13495 PyObject *arg1 = (PyObject *) 0 ;
13496 wxSound *result;
13497 PyObject * obj0 = 0 ;
13498 char *kwnames[] = {
13499 (char *) "data", NULL
13500 };
13501
13502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13503 arg1 = obj0;
13504 {
13505 if (!wxPyCheckForApp()) SWIG_fail;
13506 PyThreadState* __tstate = wxPyBeginAllowThreads();
13507 result = (wxSound *)new_wxSound(arg1);
13508
13509 wxPyEndAllowThreads(__tstate);
13510 if (PyErr_Occurred()) SWIG_fail;
13511 }
13512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13513 return resultobj;
13514 fail:
13515 return NULL;
13516 }
13517
13518
13519 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13520 PyObject *resultobj;
13521 wxSound *arg1 = (wxSound *) 0 ;
13522 PyObject * obj0 = 0 ;
13523 char *kwnames[] = {
13524 (char *) "self", NULL
13525 };
13526
13527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13529 if (SWIG_arg_fail(1)) SWIG_fail;
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 delete arg1;
13533
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 Py_INCREF(Py_None); resultobj = Py_None;
13538 return resultobj;
13539 fail:
13540 return NULL;
13541 }
13542
13543
13544 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13545 PyObject *resultobj;
13546 wxSound *arg1 = (wxSound *) 0 ;
13547 wxString *arg2 = 0 ;
13548 bool result;
13549 bool temp2 = false ;
13550 PyObject * obj0 = 0 ;
13551 PyObject * obj1 = 0 ;
13552 char *kwnames[] = {
13553 (char *) "self",(char *) "fileName", NULL
13554 };
13555
13556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13558 if (SWIG_arg_fail(1)) SWIG_fail;
13559 {
13560 arg2 = wxString_in_helper(obj1);
13561 if (arg2 == NULL) SWIG_fail;
13562 temp2 = true;
13563 }
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 result = (bool)(arg1)->Create((wxString const &)*arg2);
13567
13568 wxPyEndAllowThreads(__tstate);
13569 if (PyErr_Occurred()) SWIG_fail;
13570 }
13571 {
13572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13573 }
13574 {
13575 if (temp2)
13576 delete arg2;
13577 }
13578 return resultobj;
13579 fail:
13580 {
13581 if (temp2)
13582 delete arg2;
13583 }
13584 return NULL;
13585 }
13586
13587
13588 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13589 PyObject *resultobj;
13590 wxSound *arg1 = (wxSound *) 0 ;
13591 PyObject *arg2 = (PyObject *) 0 ;
13592 bool result;
13593 PyObject * obj0 = 0 ;
13594 PyObject * obj1 = 0 ;
13595 char *kwnames[] = {
13596 (char *) "self",(char *) "data", NULL
13597 };
13598
13599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13601 if (SWIG_arg_fail(1)) SWIG_fail;
13602 arg2 = obj1;
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 result = (bool)wxSound_CreateFromData(arg1,arg2);
13606
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 {
13611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13612 }
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj;
13621 wxSound *arg1 = (wxSound *) 0 ;
13622 bool result;
13623 PyObject * obj0 = 0 ;
13624 char *kwnames[] = {
13625 (char *) "self", NULL
13626 };
13627
13628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13630 if (SWIG_arg_fail(1)) SWIG_fail;
13631 {
13632 PyThreadState* __tstate = wxPyBeginAllowThreads();
13633 result = (bool)(arg1)->IsOk();
13634
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 {
13639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13640 }
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj;
13649 wxSound *arg1 = (wxSound *) 0 ;
13650 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13651 bool result;
13652 PyObject * obj0 = 0 ;
13653 PyObject * obj1 = 0 ;
13654 char *kwnames[] = {
13655 (char *) "self",(char *) "flags", NULL
13656 };
13657
13658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13660 if (SWIG_arg_fail(1)) SWIG_fail;
13661 if (obj1) {
13662 {
13663 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13664 if (SWIG_arg_fail(2)) SWIG_fail;
13665 }
13666 }
13667 {
13668 if (!wxPyCheckForApp()) SWIG_fail;
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 result = (bool)((wxSound const *)arg1)->Play(arg2);
13671
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 {
13676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13677 }
13678 return resultobj;
13679 fail:
13680 return NULL;
13681 }
13682
13683
13684 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj;
13686 wxString *arg1 = 0 ;
13687 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13688 bool result;
13689 bool temp1 = false ;
13690 PyObject * obj0 = 0 ;
13691 PyObject * obj1 = 0 ;
13692 char *kwnames[] = {
13693 (char *) "filename",(char *) "flags", NULL
13694 };
13695
13696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13697 {
13698 arg1 = wxString_in_helper(obj0);
13699 if (arg1 == NULL) SWIG_fail;
13700 temp1 = true;
13701 }
13702 if (obj1) {
13703 {
13704 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13705 if (SWIG_arg_fail(2)) SWIG_fail;
13706 }
13707 }
13708 {
13709 if (!wxPyCheckForApp()) SWIG_fail;
13710 PyThreadState* __tstate = wxPyBeginAllowThreads();
13711 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13712
13713 wxPyEndAllowThreads(__tstate);
13714 if (PyErr_Occurred()) SWIG_fail;
13715 }
13716 {
13717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13718 }
13719 {
13720 if (temp1)
13721 delete arg1;
13722 }
13723 return resultobj;
13724 fail:
13725 {
13726 if (temp1)
13727 delete arg1;
13728 }
13729 return NULL;
13730 }
13731
13732
13733 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj;
13735 char *kwnames[] = {
13736 NULL
13737 };
13738
13739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13740 {
13741 if (!wxPyCheckForApp()) SWIG_fail;
13742 PyThreadState* __tstate = wxPyBeginAllowThreads();
13743 wxSound::Stop();
13744
13745 wxPyEndAllowThreads(__tstate);
13746 if (PyErr_Occurred()) SWIG_fail;
13747 }
13748 Py_INCREF(Py_None); resultobj = Py_None;
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13756 PyObject *obj;
13757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13758 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13759 Py_INCREF(obj);
13760 return Py_BuildValue((char *)"");
13761 }
13762 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13763 PyObject *resultobj;
13764 wxString *arg1 = 0 ;
13765 wxString *arg2 = 0 ;
13766 wxString *arg3 = 0 ;
13767 wxString *arg4 = 0 ;
13768 wxFileTypeInfo *result;
13769 bool temp1 = false ;
13770 bool temp2 = false ;
13771 bool temp3 = false ;
13772 bool temp4 = false ;
13773 PyObject * obj0 = 0 ;
13774 PyObject * obj1 = 0 ;
13775 PyObject * obj2 = 0 ;
13776 PyObject * obj3 = 0 ;
13777 char *kwnames[] = {
13778 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13779 };
13780
13781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13782 {
13783 arg1 = wxString_in_helper(obj0);
13784 if (arg1 == NULL) SWIG_fail;
13785 temp1 = true;
13786 }
13787 {
13788 arg2 = wxString_in_helper(obj1);
13789 if (arg2 == NULL) SWIG_fail;
13790 temp2 = true;
13791 }
13792 {
13793 arg3 = wxString_in_helper(obj2);
13794 if (arg3 == NULL) SWIG_fail;
13795 temp3 = true;
13796 }
13797 {
13798 arg4 = wxString_in_helper(obj3);
13799 if (arg4 == NULL) SWIG_fail;
13800 temp4 = true;
13801 }
13802 {
13803 PyThreadState* __tstate = wxPyBeginAllowThreads();
13804 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13805
13806 wxPyEndAllowThreads(__tstate);
13807 if (PyErr_Occurred()) SWIG_fail;
13808 }
13809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
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 resultobj;
13827 fail:
13828 {
13829 if (temp1)
13830 delete arg1;
13831 }
13832 {
13833 if (temp2)
13834 delete arg2;
13835 }
13836 {
13837 if (temp3)
13838 delete arg3;
13839 }
13840 {
13841 if (temp4)
13842 delete arg4;
13843 }
13844 return NULL;
13845 }
13846
13847
13848 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13849 PyObject *resultobj;
13850 wxArrayString *arg1 = 0 ;
13851 wxFileTypeInfo *result;
13852 bool temp1 = false ;
13853 PyObject * obj0 = 0 ;
13854 char *kwnames[] = {
13855 (char *) "sArray", NULL
13856 };
13857
13858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13859 {
13860 if (! PySequence_Check(obj0)) {
13861 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13862 SWIG_fail;
13863 }
13864 arg1 = new wxArrayString;
13865 temp1 = true;
13866 int i, len=PySequence_Length(obj0);
13867 for (i=0; i<len; i++) {
13868 PyObject* item = PySequence_GetItem(obj0, i);
13869 wxString* s = wxString_in_helper(item);
13870 if (PyErr_Occurred()) SWIG_fail;
13871 arg1->Add(*s);
13872 delete s;
13873 Py_DECREF(item);
13874 }
13875 }
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13879
13880 wxPyEndAllowThreads(__tstate);
13881 if (PyErr_Occurred()) SWIG_fail;
13882 }
13883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13884 {
13885 if (temp1) delete arg1;
13886 }
13887 return resultobj;
13888 fail:
13889 {
13890 if (temp1) delete arg1;
13891 }
13892 return NULL;
13893 }
13894
13895
13896 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13897 PyObject *resultobj;
13898 wxFileTypeInfo *result;
13899 char *kwnames[] = {
13900 NULL
13901 };
13902
13903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13904 {
13905 PyThreadState* __tstate = wxPyBeginAllowThreads();
13906 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13907
13908 wxPyEndAllowThreads(__tstate);
13909 if (PyErr_Occurred()) SWIG_fail;
13910 }
13911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13912 return resultobj;
13913 fail:
13914 return NULL;
13915 }
13916
13917
13918 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj;
13920 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13921 bool result;
13922 PyObject * obj0 = 0 ;
13923 char *kwnames[] = {
13924 (char *) "self", NULL
13925 };
13926
13927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13929 if (SWIG_arg_fail(1)) SWIG_fail;
13930 {
13931 PyThreadState* __tstate = wxPyBeginAllowThreads();
13932 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13933
13934 wxPyEndAllowThreads(__tstate);
13935 if (PyErr_Occurred()) SWIG_fail;
13936 }
13937 {
13938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13939 }
13940 return resultobj;
13941 fail:
13942 return NULL;
13943 }
13944
13945
13946 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13947 PyObject *resultobj;
13948 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13949 wxString *arg2 = 0 ;
13950 int arg3 = (int) 0 ;
13951 bool temp2 = false ;
13952 PyObject * obj0 = 0 ;
13953 PyObject * obj1 = 0 ;
13954 PyObject * obj2 = 0 ;
13955 char *kwnames[] = {
13956 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13957 };
13958
13959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13961 if (SWIG_arg_fail(1)) SWIG_fail;
13962 {
13963 arg2 = wxString_in_helper(obj1);
13964 if (arg2 == NULL) SWIG_fail;
13965 temp2 = true;
13966 }
13967 if (obj2) {
13968 {
13969 arg3 = (int)(SWIG_As_int(obj2));
13970 if (SWIG_arg_fail(3)) SWIG_fail;
13971 }
13972 }
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13976
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 Py_INCREF(Py_None); resultobj = Py_None;
13981 {
13982 if (temp2)
13983 delete arg2;
13984 }
13985 return resultobj;
13986 fail:
13987 {
13988 if (temp2)
13989 delete arg2;
13990 }
13991 return NULL;
13992 }
13993
13994
13995 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13996 PyObject *resultobj;
13997 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13998 wxString *arg2 = 0 ;
13999 bool temp2 = false ;
14000 PyObject * obj0 = 0 ;
14001 PyObject * obj1 = 0 ;
14002 char *kwnames[] = {
14003 (char *) "self",(char *) "shortDesc", NULL
14004 };
14005
14006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14008 if (SWIG_arg_fail(1)) SWIG_fail;
14009 {
14010 arg2 = wxString_in_helper(obj1);
14011 if (arg2 == NULL) SWIG_fail;
14012 temp2 = true;
14013 }
14014 {
14015 PyThreadState* __tstate = wxPyBeginAllowThreads();
14016 (arg1)->SetShortDesc((wxString const &)*arg2);
14017
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 Py_INCREF(Py_None); resultobj = Py_None;
14022 {
14023 if (temp2)
14024 delete arg2;
14025 }
14026 return resultobj;
14027 fail:
14028 {
14029 if (temp2)
14030 delete arg2;
14031 }
14032 return NULL;
14033 }
14034
14035
14036 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj;
14038 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14039 wxString *result;
14040 PyObject * obj0 = 0 ;
14041 char *kwnames[] = {
14042 (char *) "self", NULL
14043 };
14044
14045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14047 if (SWIG_arg_fail(1)) SWIG_fail;
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 {
14051 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14052 result = (wxString *) &_result_ref;
14053 }
14054
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 {
14059 #if wxUSE_UNICODE
14060 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14061 #else
14062 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14063 #endif
14064 }
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj;
14073 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14074 wxString *result;
14075 PyObject * obj0 = 0 ;
14076 char *kwnames[] = {
14077 (char *) "self", NULL
14078 };
14079
14080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14082 if (SWIG_arg_fail(1)) SWIG_fail;
14083 {
14084 PyThreadState* __tstate = wxPyBeginAllowThreads();
14085 {
14086 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14087 result = (wxString *) &_result_ref;
14088 }
14089
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 {
14094 #if wxUSE_UNICODE
14095 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14096 #else
14097 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14098 #endif
14099 }
14100 return resultobj;
14101 fail:
14102 return NULL;
14103 }
14104
14105
14106 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14107 PyObject *resultobj;
14108 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14109 wxString *result;
14110 PyObject * obj0 = 0 ;
14111 char *kwnames[] = {
14112 (char *) "self", NULL
14113 };
14114
14115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14117 if (SWIG_arg_fail(1)) SWIG_fail;
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 {
14121 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14122 result = (wxString *) &_result_ref;
14123 }
14124
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 {
14129 #if wxUSE_UNICODE
14130 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14131 #else
14132 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14133 #endif
14134 }
14135 return resultobj;
14136 fail:
14137 return NULL;
14138 }
14139
14140
14141 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14142 PyObject *resultobj;
14143 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14144 wxString *result;
14145 PyObject * obj0 = 0 ;
14146 char *kwnames[] = {
14147 (char *) "self", NULL
14148 };
14149
14150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14152 if (SWIG_arg_fail(1)) SWIG_fail;
14153 {
14154 PyThreadState* __tstate = wxPyBeginAllowThreads();
14155 {
14156 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14157 result = (wxString *) &_result_ref;
14158 }
14159
14160 wxPyEndAllowThreads(__tstate);
14161 if (PyErr_Occurred()) SWIG_fail;
14162 }
14163 {
14164 #if wxUSE_UNICODE
14165 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14166 #else
14167 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14168 #endif
14169 }
14170 return resultobj;
14171 fail:
14172 return NULL;
14173 }
14174
14175
14176 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14177 PyObject *resultobj;
14178 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14179 wxString *result;
14180 PyObject * obj0 = 0 ;
14181 char *kwnames[] = {
14182 (char *) "self", NULL
14183 };
14184
14185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14187 if (SWIG_arg_fail(1)) SWIG_fail;
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 {
14191 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14192 result = (wxString *) &_result_ref;
14193 }
14194
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 {
14199 #if wxUSE_UNICODE
14200 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14201 #else
14202 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14203 #endif
14204 }
14205 return resultobj;
14206 fail:
14207 return NULL;
14208 }
14209
14210
14211 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14212 PyObject *resultobj;
14213 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14214 wxArrayString *result;
14215 PyObject * obj0 = 0 ;
14216 char *kwnames[] = {
14217 (char *) "self", NULL
14218 };
14219
14220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14222 if (SWIG_arg_fail(1)) SWIG_fail;
14223 {
14224 PyThreadState* __tstate = wxPyBeginAllowThreads();
14225 {
14226 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14227 result = (wxArrayString *) &_result_ref;
14228 }
14229
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 {
14234 resultobj = wxArrayString2PyList_helper(*result);
14235 }
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj;
14244 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14245 int result;
14246 PyObject * obj0 = 0 ;
14247 char *kwnames[] = {
14248 (char *) "self", NULL
14249 };
14250
14251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14253 if (SWIG_arg_fail(1)) SWIG_fail;
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14257
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 {
14262 resultobj = SWIG_From_int((int)(result));
14263 }
14264 return resultobj;
14265 fail:
14266 return NULL;
14267 }
14268
14269
14270 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14271 PyObject *resultobj;
14272 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14273 wxString *result;
14274 PyObject * obj0 = 0 ;
14275 char *kwnames[] = {
14276 (char *) "self", NULL
14277 };
14278
14279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14281 if (SWIG_arg_fail(1)) SWIG_fail;
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 {
14285 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14286 result = (wxString *) &_result_ref;
14287 }
14288
14289 wxPyEndAllowThreads(__tstate);
14290 if (PyErr_Occurred()) SWIG_fail;
14291 }
14292 {
14293 #if wxUSE_UNICODE
14294 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14295 #else
14296 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14297 #endif
14298 }
14299 return resultobj;
14300 fail:
14301 return NULL;
14302 }
14303
14304
14305 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14306 PyObject *resultobj;
14307 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14308 int result;
14309 PyObject * obj0 = 0 ;
14310 char *kwnames[] = {
14311 (char *) "self", NULL
14312 };
14313
14314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14316 if (SWIG_arg_fail(1)) SWIG_fail;
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14320
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 {
14325 resultobj = SWIG_From_int((int)(result));
14326 }
14327 return resultobj;
14328 fail:
14329 return NULL;
14330 }
14331
14332
14333 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14334 PyObject *obj;
14335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14336 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14337 Py_INCREF(obj);
14338 return Py_BuildValue((char *)"");
14339 }
14340 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj;
14342 wxFileTypeInfo *arg1 = 0 ;
14343 wxFileType *result;
14344 PyObject * obj0 = 0 ;
14345 char *kwnames[] = {
14346 (char *) "ftInfo", NULL
14347 };
14348
14349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14350 {
14351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14352 if (SWIG_arg_fail(1)) SWIG_fail;
14353 if (arg1 == NULL) {
14354 SWIG_null_ref("wxFileTypeInfo");
14355 }
14356 if (SWIG_arg_fail(1)) SWIG_fail;
14357 }
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14361
14362 wxPyEndAllowThreads(__tstate);
14363 if (PyErr_Occurred()) SWIG_fail;
14364 }
14365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj;
14374 wxFileType *arg1 = (wxFileType *) 0 ;
14375 PyObject * obj0 = 0 ;
14376 char *kwnames[] = {
14377 (char *) "self", NULL
14378 };
14379
14380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14382 if (SWIG_arg_fail(1)) SWIG_fail;
14383 {
14384 PyThreadState* __tstate = wxPyBeginAllowThreads();
14385 delete arg1;
14386
14387 wxPyEndAllowThreads(__tstate);
14388 if (PyErr_Occurred()) SWIG_fail;
14389 }
14390 Py_INCREF(Py_None); resultobj = Py_None;
14391 return resultobj;
14392 fail:
14393 return NULL;
14394 }
14395
14396
14397 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14398 PyObject *resultobj;
14399 wxFileType *arg1 = (wxFileType *) 0 ;
14400 PyObject *result;
14401 PyObject * obj0 = 0 ;
14402 char *kwnames[] = {
14403 (char *) "self", NULL
14404 };
14405
14406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14408 if (SWIG_arg_fail(1)) SWIG_fail;
14409 {
14410 PyThreadState* __tstate = wxPyBeginAllowThreads();
14411 result = (PyObject *)wxFileType_GetMimeType(arg1);
14412
14413 wxPyEndAllowThreads(__tstate);
14414 if (PyErr_Occurred()) SWIG_fail;
14415 }
14416 resultobj = result;
14417 return resultobj;
14418 fail:
14419 return NULL;
14420 }
14421
14422
14423 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14424 PyObject *resultobj;
14425 wxFileType *arg1 = (wxFileType *) 0 ;
14426 PyObject *result;
14427 PyObject * obj0 = 0 ;
14428 char *kwnames[] = {
14429 (char *) "self", NULL
14430 };
14431
14432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14434 if (SWIG_arg_fail(1)) SWIG_fail;
14435 {
14436 PyThreadState* __tstate = wxPyBeginAllowThreads();
14437 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14438
14439 wxPyEndAllowThreads(__tstate);
14440 if (PyErr_Occurred()) SWIG_fail;
14441 }
14442 resultobj = result;
14443 return resultobj;
14444 fail:
14445 return NULL;
14446 }
14447
14448
14449 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj;
14451 wxFileType *arg1 = (wxFileType *) 0 ;
14452 PyObject *result;
14453 PyObject * obj0 = 0 ;
14454 char *kwnames[] = {
14455 (char *) "self", NULL
14456 };
14457
14458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14460 if (SWIG_arg_fail(1)) SWIG_fail;
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (PyObject *)wxFileType_GetExtensions(arg1);
14464
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 resultobj = result;
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj;
14477 wxFileType *arg1 = (wxFileType *) 0 ;
14478 wxIcon *result;
14479 PyObject * obj0 = 0 ;
14480 char *kwnames[] = {
14481 (char *) "self", NULL
14482 };
14483
14484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14486 if (SWIG_arg_fail(1)) SWIG_fail;
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 result = (wxIcon *)wxFileType_GetIcon(arg1);
14490
14491 wxPyEndAllowThreads(__tstate);
14492 if (PyErr_Occurred()) SWIG_fail;
14493 }
14494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14495 return resultobj;
14496 fail:
14497 return NULL;
14498 }
14499
14500
14501 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14502 PyObject *resultobj;
14503 wxFileType *arg1 = (wxFileType *) 0 ;
14504 PyObject *result;
14505 PyObject * obj0 = 0 ;
14506 char *kwnames[] = {
14507 (char *) "self", NULL
14508 };
14509
14510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14512 if (SWIG_arg_fail(1)) SWIG_fail;
14513 {
14514 PyThreadState* __tstate = wxPyBeginAllowThreads();
14515 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14516
14517 wxPyEndAllowThreads(__tstate);
14518 if (PyErr_Occurred()) SWIG_fail;
14519 }
14520 resultobj = result;
14521 return resultobj;
14522 fail:
14523 return NULL;
14524 }
14525
14526
14527 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14528 PyObject *resultobj;
14529 wxFileType *arg1 = (wxFileType *) 0 ;
14530 PyObject *result;
14531 PyObject * obj0 = 0 ;
14532 char *kwnames[] = {
14533 (char *) "self", NULL
14534 };
14535
14536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14538 if (SWIG_arg_fail(1)) SWIG_fail;
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 result = (PyObject *)wxFileType_GetDescription(arg1);
14542
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 resultobj = result;
14547 return resultobj;
14548 fail:
14549 return NULL;
14550 }
14551
14552
14553 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj;
14555 wxFileType *arg1 = (wxFileType *) 0 ;
14556 wxString *arg2 = 0 ;
14557 wxString const &arg3_defvalue = wxPyEmptyString ;
14558 wxString *arg3 = (wxString *) &arg3_defvalue ;
14559 PyObject *result;
14560 bool temp2 = false ;
14561 bool temp3 = false ;
14562 PyObject * obj0 = 0 ;
14563 PyObject * obj1 = 0 ;
14564 PyObject * obj2 = 0 ;
14565 char *kwnames[] = {
14566 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14567 };
14568
14569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14571 if (SWIG_arg_fail(1)) SWIG_fail;
14572 {
14573 arg2 = wxString_in_helper(obj1);
14574 if (arg2 == NULL) SWIG_fail;
14575 temp2 = true;
14576 }
14577 if (obj2) {
14578 {
14579 arg3 = wxString_in_helper(obj2);
14580 if (arg3 == NULL) SWIG_fail;
14581 temp3 = true;
14582 }
14583 }
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14587
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 resultobj = result;
14592 {
14593 if (temp2)
14594 delete arg2;
14595 }
14596 {
14597 if (temp3)
14598 delete arg3;
14599 }
14600 return resultobj;
14601 fail:
14602 {
14603 if (temp2)
14604 delete arg2;
14605 }
14606 {
14607 if (temp3)
14608 delete arg3;
14609 }
14610 return NULL;
14611 }
14612
14613
14614 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj;
14616 wxFileType *arg1 = (wxFileType *) 0 ;
14617 wxString *arg2 = 0 ;
14618 wxString const &arg3_defvalue = wxPyEmptyString ;
14619 wxString *arg3 = (wxString *) &arg3_defvalue ;
14620 PyObject *result;
14621 bool temp2 = false ;
14622 bool temp3 = false ;
14623 PyObject * obj0 = 0 ;
14624 PyObject * obj1 = 0 ;
14625 PyObject * obj2 = 0 ;
14626 char *kwnames[] = {
14627 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14628 };
14629
14630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14632 if (SWIG_arg_fail(1)) SWIG_fail;
14633 {
14634 arg2 = wxString_in_helper(obj1);
14635 if (arg2 == NULL) SWIG_fail;
14636 temp2 = true;
14637 }
14638 if (obj2) {
14639 {
14640 arg3 = wxString_in_helper(obj2);
14641 if (arg3 == NULL) SWIG_fail;
14642 temp3 = true;
14643 }
14644 }
14645 {
14646 PyThreadState* __tstate = wxPyBeginAllowThreads();
14647 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14648
14649 wxPyEndAllowThreads(__tstate);
14650 if (PyErr_Occurred()) SWIG_fail;
14651 }
14652 resultobj = result;
14653 {
14654 if (temp2)
14655 delete arg2;
14656 }
14657 {
14658 if (temp3)
14659 delete arg3;
14660 }
14661 return resultobj;
14662 fail:
14663 {
14664 if (temp2)
14665 delete arg2;
14666 }
14667 {
14668 if (temp3)
14669 delete arg3;
14670 }
14671 return NULL;
14672 }
14673
14674
14675 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14676 PyObject *resultobj;
14677 wxFileType *arg1 = (wxFileType *) 0 ;
14678 wxString *arg2 = 0 ;
14679 wxString const &arg3_defvalue = wxPyEmptyString ;
14680 wxString *arg3 = (wxString *) &arg3_defvalue ;
14681 PyObject *result;
14682 bool temp2 = false ;
14683 bool temp3 = false ;
14684 PyObject * obj0 = 0 ;
14685 PyObject * obj1 = 0 ;
14686 PyObject * obj2 = 0 ;
14687 char *kwnames[] = {
14688 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14689 };
14690
14691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14693 if (SWIG_arg_fail(1)) SWIG_fail;
14694 {
14695 arg2 = wxString_in_helper(obj1);
14696 if (arg2 == NULL) SWIG_fail;
14697 temp2 = true;
14698 }
14699 if (obj2) {
14700 {
14701 arg3 = wxString_in_helper(obj2);
14702 if (arg3 == NULL) SWIG_fail;
14703 temp3 = true;
14704 }
14705 }
14706 {
14707 PyThreadState* __tstate = wxPyBeginAllowThreads();
14708 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14709
14710 wxPyEndAllowThreads(__tstate);
14711 if (PyErr_Occurred()) SWIG_fail;
14712 }
14713 resultobj = result;
14714 {
14715 if (temp2)
14716 delete arg2;
14717 }
14718 {
14719 if (temp3)
14720 delete arg3;
14721 }
14722 return resultobj;
14723 fail:
14724 {
14725 if (temp2)
14726 delete arg2;
14727 }
14728 {
14729 if (temp3)
14730 delete arg3;
14731 }
14732 return NULL;
14733 }
14734
14735
14736 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14737 PyObject *resultobj;
14738 wxFileType *arg1 = (wxFileType *) 0 ;
14739 wxString *arg2 = 0 ;
14740 wxString *arg3 = 0 ;
14741 bool arg4 = (bool) true ;
14742 bool result;
14743 bool temp2 = false ;
14744 bool temp3 = false ;
14745 PyObject * obj0 = 0 ;
14746 PyObject * obj1 = 0 ;
14747 PyObject * obj2 = 0 ;
14748 PyObject * obj3 = 0 ;
14749 char *kwnames[] = {
14750 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14751 };
14752
14753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14755 if (SWIG_arg_fail(1)) SWIG_fail;
14756 {
14757 arg2 = wxString_in_helper(obj1);
14758 if (arg2 == NULL) SWIG_fail;
14759 temp2 = true;
14760 }
14761 {
14762 arg3 = wxString_in_helper(obj2);
14763 if (arg3 == NULL) SWIG_fail;
14764 temp3 = true;
14765 }
14766 if (obj3) {
14767 {
14768 arg4 = (bool)(SWIG_As_bool(obj3));
14769 if (SWIG_arg_fail(4)) SWIG_fail;
14770 }
14771 }
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14775
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 {
14780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14781 }
14782 {
14783 if (temp2)
14784 delete arg2;
14785 }
14786 {
14787 if (temp3)
14788 delete arg3;
14789 }
14790 return resultobj;
14791 fail:
14792 {
14793 if (temp2)
14794 delete arg2;
14795 }
14796 {
14797 if (temp3)
14798 delete arg3;
14799 }
14800 return NULL;
14801 }
14802
14803
14804 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj;
14806 wxFileType *arg1 = (wxFileType *) 0 ;
14807 wxString const &arg2_defvalue = wxPyEmptyString ;
14808 wxString *arg2 = (wxString *) &arg2_defvalue ;
14809 int arg3 = (int) 0 ;
14810 bool result;
14811 bool temp2 = false ;
14812 PyObject * obj0 = 0 ;
14813 PyObject * obj1 = 0 ;
14814 PyObject * obj2 = 0 ;
14815 char *kwnames[] = {
14816 (char *) "self",(char *) "cmd",(char *) "index", NULL
14817 };
14818
14819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14821 if (SWIG_arg_fail(1)) SWIG_fail;
14822 if (obj1) {
14823 {
14824 arg2 = wxString_in_helper(obj1);
14825 if (arg2 == NULL) SWIG_fail;
14826 temp2 = true;
14827 }
14828 }
14829 if (obj2) {
14830 {
14831 arg3 = (int)(SWIG_As_int(obj2));
14832 if (SWIG_arg_fail(3)) SWIG_fail;
14833 }
14834 }
14835 {
14836 PyThreadState* __tstate = wxPyBeginAllowThreads();
14837 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14838
14839 wxPyEndAllowThreads(__tstate);
14840 if (PyErr_Occurred()) SWIG_fail;
14841 }
14842 {
14843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14844 }
14845 {
14846 if (temp2)
14847 delete arg2;
14848 }
14849 return resultobj;
14850 fail:
14851 {
14852 if (temp2)
14853 delete arg2;
14854 }
14855 return NULL;
14856 }
14857
14858
14859 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14860 PyObject *resultobj;
14861 wxFileType *arg1 = (wxFileType *) 0 ;
14862 bool result;
14863 PyObject * obj0 = 0 ;
14864 char *kwnames[] = {
14865 (char *) "self", NULL
14866 };
14867
14868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14870 if (SWIG_arg_fail(1)) SWIG_fail;
14871 {
14872 PyThreadState* __tstate = wxPyBeginAllowThreads();
14873 result = (bool)(arg1)->Unassociate();
14874
14875 wxPyEndAllowThreads(__tstate);
14876 if (PyErr_Occurred()) SWIG_fail;
14877 }
14878 {
14879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14880 }
14881 return resultobj;
14882 fail:
14883 return NULL;
14884 }
14885
14886
14887 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14888 PyObject *resultobj;
14889 wxString *arg1 = 0 ;
14890 wxString *arg2 = 0 ;
14891 wxString const &arg3_defvalue = wxPyEmptyString ;
14892 wxString *arg3 = (wxString *) &arg3_defvalue ;
14893 wxString result;
14894 bool temp1 = false ;
14895 bool temp2 = false ;
14896 bool temp3 = false ;
14897 PyObject * obj0 = 0 ;
14898 PyObject * obj1 = 0 ;
14899 PyObject * obj2 = 0 ;
14900 char *kwnames[] = {
14901 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14902 };
14903
14904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14905 {
14906 arg1 = wxString_in_helper(obj0);
14907 if (arg1 == NULL) SWIG_fail;
14908 temp1 = true;
14909 }
14910 {
14911 arg2 = wxString_in_helper(obj1);
14912 if (arg2 == NULL) SWIG_fail;
14913 temp2 = true;
14914 }
14915 if (obj2) {
14916 {
14917 arg3 = wxString_in_helper(obj2);
14918 if (arg3 == NULL) SWIG_fail;
14919 temp3 = true;
14920 }
14921 }
14922 {
14923 PyThreadState* __tstate = wxPyBeginAllowThreads();
14924 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14925
14926 wxPyEndAllowThreads(__tstate);
14927 if (PyErr_Occurred()) SWIG_fail;
14928 }
14929 {
14930 #if wxUSE_UNICODE
14931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14932 #else
14933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14934 #endif
14935 }
14936 {
14937 if (temp1)
14938 delete arg1;
14939 }
14940 {
14941 if (temp2)
14942 delete arg2;
14943 }
14944 {
14945 if (temp3)
14946 delete arg3;
14947 }
14948 return resultobj;
14949 fail:
14950 {
14951 if (temp1)
14952 delete arg1;
14953 }
14954 {
14955 if (temp2)
14956 delete arg2;
14957 }
14958 {
14959 if (temp3)
14960 delete arg3;
14961 }
14962 return NULL;
14963 }
14964
14965
14966 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14967 PyObject *obj;
14968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14969 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14970 Py_INCREF(obj);
14971 return Py_BuildValue((char *)"");
14972 }
14973 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14974 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14975 return 1;
14976 }
14977
14978
14979 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14980 PyObject *pyobj;
14981
14982 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14983 return pyobj;
14984 }
14985
14986
14987 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj;
14989 wxString *arg1 = 0 ;
14990 wxString *arg2 = 0 ;
14991 bool result;
14992 bool temp1 = false ;
14993 bool temp2 = false ;
14994 PyObject * obj0 = 0 ;
14995 PyObject * obj1 = 0 ;
14996 char *kwnames[] = {
14997 (char *) "mimeType",(char *) "wildcard", NULL
14998 };
14999
15000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15001 {
15002 arg1 = wxString_in_helper(obj0);
15003 if (arg1 == NULL) SWIG_fail;
15004 temp1 = true;
15005 }
15006 {
15007 arg2 = wxString_in_helper(obj1);
15008 if (arg2 == NULL) SWIG_fail;
15009 temp2 = true;
15010 }
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15014
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 {
15019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15020 }
15021 {
15022 if (temp1)
15023 delete arg1;
15024 }
15025 {
15026 if (temp2)
15027 delete arg2;
15028 }
15029 return resultobj;
15030 fail:
15031 {
15032 if (temp1)
15033 delete arg1;
15034 }
15035 {
15036 if (temp2)
15037 delete arg2;
15038 }
15039 return NULL;
15040 }
15041
15042
15043 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15044 PyObject *resultobj;
15045 wxMimeTypesManager *result;
15046 char *kwnames[] = {
15047 NULL
15048 };
15049
15050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15051 {
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15054
15055 wxPyEndAllowThreads(__tstate);
15056 if (PyErr_Occurred()) SWIG_fail;
15057 }
15058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15059 return resultobj;
15060 fail:
15061 return NULL;
15062 }
15063
15064
15065 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15066 PyObject *resultobj;
15067 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15068 int arg2 = (int) wxMAILCAP_ALL ;
15069 wxString const &arg3_defvalue = wxPyEmptyString ;
15070 wxString *arg3 = (wxString *) &arg3_defvalue ;
15071 bool temp3 = false ;
15072 PyObject * obj0 = 0 ;
15073 PyObject * obj1 = 0 ;
15074 PyObject * obj2 = 0 ;
15075 char *kwnames[] = {
15076 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15077 };
15078
15079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15081 if (SWIG_arg_fail(1)) SWIG_fail;
15082 if (obj1) {
15083 {
15084 arg2 = (int)(SWIG_As_int(obj1));
15085 if (SWIG_arg_fail(2)) SWIG_fail;
15086 }
15087 }
15088 if (obj2) {
15089 {
15090 arg3 = wxString_in_helper(obj2);
15091 if (arg3 == NULL) SWIG_fail;
15092 temp3 = true;
15093 }
15094 }
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15098
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 Py_INCREF(Py_None); resultobj = Py_None;
15103 {
15104 if (temp3)
15105 delete arg3;
15106 }
15107 return resultobj;
15108 fail:
15109 {
15110 if (temp3)
15111 delete arg3;
15112 }
15113 return NULL;
15114 }
15115
15116
15117 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15118 PyObject *resultobj;
15119 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15120 PyObject * obj0 = 0 ;
15121 char *kwnames[] = {
15122 (char *) "self", NULL
15123 };
15124
15125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15127 if (SWIG_arg_fail(1)) SWIG_fail;
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 (arg1)->ClearData();
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 Py_INCREF(Py_None); resultobj = Py_None;
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15143 PyObject *resultobj;
15144 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15145 wxString *arg2 = 0 ;
15146 wxFileType *result;
15147 bool temp2 = false ;
15148 PyObject * obj0 = 0 ;
15149 PyObject * obj1 = 0 ;
15150 char *kwnames[] = {
15151 (char *) "self",(char *) "ext", NULL
15152 };
15153
15154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15156 if (SWIG_arg_fail(1)) SWIG_fail;
15157 {
15158 arg2 = wxString_in_helper(obj1);
15159 if (arg2 == NULL) SWIG_fail;
15160 temp2 = true;
15161 }
15162 {
15163 PyThreadState* __tstate = wxPyBeginAllowThreads();
15164 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15165
15166 wxPyEndAllowThreads(__tstate);
15167 if (PyErr_Occurred()) SWIG_fail;
15168 }
15169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15170 {
15171 if (temp2)
15172 delete arg2;
15173 }
15174 return resultobj;
15175 fail:
15176 {
15177 if (temp2)
15178 delete arg2;
15179 }
15180 return NULL;
15181 }
15182
15183
15184 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15185 PyObject *resultobj;
15186 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15187 wxString *arg2 = 0 ;
15188 wxFileType *result;
15189 bool temp2 = false ;
15190 PyObject * obj0 = 0 ;
15191 PyObject * obj1 = 0 ;
15192 char *kwnames[] = {
15193 (char *) "self",(char *) "mimeType", NULL
15194 };
15195
15196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15198 if (SWIG_arg_fail(1)) SWIG_fail;
15199 {
15200 arg2 = wxString_in_helper(obj1);
15201 if (arg2 == NULL) SWIG_fail;
15202 temp2 = true;
15203 }
15204 {
15205 PyThreadState* __tstate = wxPyBeginAllowThreads();
15206 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15207
15208 wxPyEndAllowThreads(__tstate);
15209 if (PyErr_Occurred()) SWIG_fail;
15210 }
15211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15212 {
15213 if (temp2)
15214 delete arg2;
15215 }
15216 return resultobj;
15217 fail:
15218 {
15219 if (temp2)
15220 delete arg2;
15221 }
15222 return NULL;
15223 }
15224
15225
15226 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15227 PyObject *resultobj;
15228 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15229 wxString *arg2 = 0 ;
15230 bool arg3 = (bool) false ;
15231 bool result;
15232 bool temp2 = false ;
15233 PyObject * obj0 = 0 ;
15234 PyObject * obj1 = 0 ;
15235 PyObject * obj2 = 0 ;
15236 char *kwnames[] = {
15237 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15238 };
15239
15240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15242 if (SWIG_arg_fail(1)) SWIG_fail;
15243 {
15244 arg2 = wxString_in_helper(obj1);
15245 if (arg2 == NULL) SWIG_fail;
15246 temp2 = true;
15247 }
15248 if (obj2) {
15249 {
15250 arg3 = (bool)(SWIG_As_bool(obj2));
15251 if (SWIG_arg_fail(3)) SWIG_fail;
15252 }
15253 }
15254 {
15255 PyThreadState* __tstate = wxPyBeginAllowThreads();
15256 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15257
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 {
15262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15263 }
15264 {
15265 if (temp2)
15266 delete arg2;
15267 }
15268 return resultobj;
15269 fail:
15270 {
15271 if (temp2)
15272 delete arg2;
15273 }
15274 return NULL;
15275 }
15276
15277
15278 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15279 PyObject *resultobj;
15280 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15281 wxString *arg2 = 0 ;
15282 bool result;
15283 bool temp2 = false ;
15284 PyObject * obj0 = 0 ;
15285 PyObject * obj1 = 0 ;
15286 char *kwnames[] = {
15287 (char *) "self",(char *) "filename", NULL
15288 };
15289
15290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15292 if (SWIG_arg_fail(1)) SWIG_fail;
15293 {
15294 arg2 = wxString_in_helper(obj1);
15295 if (arg2 == NULL) SWIG_fail;
15296 temp2 = true;
15297 }
15298 {
15299 PyThreadState* __tstate = wxPyBeginAllowThreads();
15300 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15301
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 {
15306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15307 }
15308 {
15309 if (temp2)
15310 delete arg2;
15311 }
15312 return resultobj;
15313 fail:
15314 {
15315 if (temp2)
15316 delete arg2;
15317 }
15318 return NULL;
15319 }
15320
15321
15322 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15323 PyObject *resultobj;
15324 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15325 PyObject *result;
15326 PyObject * obj0 = 0 ;
15327 char *kwnames[] = {
15328 (char *) "self", NULL
15329 };
15330
15331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15333 if (SWIG_arg_fail(1)) SWIG_fail;
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15337
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 resultobj = result;
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj;
15350 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15351 wxFileTypeInfo *arg2 = 0 ;
15352 PyObject * obj0 = 0 ;
15353 PyObject * obj1 = 0 ;
15354 char *kwnames[] = {
15355 (char *) "self",(char *) "ft", NULL
15356 };
15357
15358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15360 if (SWIG_arg_fail(1)) SWIG_fail;
15361 {
15362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15363 if (SWIG_arg_fail(2)) SWIG_fail;
15364 if (arg2 == NULL) {
15365 SWIG_null_ref("wxFileTypeInfo");
15366 }
15367 if (SWIG_arg_fail(2)) SWIG_fail;
15368 }
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15372
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 Py_INCREF(Py_None); resultobj = Py_None;
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15384 PyObject *resultobj;
15385 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15386 wxFileTypeInfo *arg2 = 0 ;
15387 wxFileType *result;
15388 PyObject * obj0 = 0 ;
15389 PyObject * obj1 = 0 ;
15390 char *kwnames[] = {
15391 (char *) "self",(char *) "ftInfo", NULL
15392 };
15393
15394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15396 if (SWIG_arg_fail(1)) SWIG_fail;
15397 {
15398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15399 if (SWIG_arg_fail(2)) SWIG_fail;
15400 if (arg2 == NULL) {
15401 SWIG_null_ref("wxFileTypeInfo");
15402 }
15403 if (SWIG_arg_fail(2)) SWIG_fail;
15404 }
15405 {
15406 PyThreadState* __tstate = wxPyBeginAllowThreads();
15407 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15408
15409 wxPyEndAllowThreads(__tstate);
15410 if (PyErr_Occurred()) SWIG_fail;
15411 }
15412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15413 return resultobj;
15414 fail:
15415 return NULL;
15416 }
15417
15418
15419 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15420 PyObject *resultobj;
15421 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15422 wxFileType *arg2 = (wxFileType *) 0 ;
15423 bool result;
15424 PyObject * obj0 = 0 ;
15425 PyObject * obj1 = 0 ;
15426 char *kwnames[] = {
15427 (char *) "self",(char *) "ft", NULL
15428 };
15429
15430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15432 if (SWIG_arg_fail(1)) SWIG_fail;
15433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15434 if (SWIG_arg_fail(2)) SWIG_fail;
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 result = (bool)(arg1)->Unassociate(arg2);
15438
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 {
15443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15444 }
15445 return resultobj;
15446 fail:
15447 return NULL;
15448 }
15449
15450
15451 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15452 PyObject *resultobj;
15453 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15454 PyObject * obj0 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "self", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15461 if (SWIG_arg_fail(1)) SWIG_fail;
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 delete arg1;
15465
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 Py_INCREF(Py_None); resultobj = Py_None;
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15477 PyObject *obj;
15478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15479 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15480 Py_INCREF(obj);
15481 return Py_BuildValue((char *)"");
15482 }
15483 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15484 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15485 return 1;
15486 }
15487
15488
15489 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15490 PyObject *pyobj;
15491
15492 {
15493 #if wxUSE_UNICODE
15494 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15495 #else
15496 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15497 #endif
15498 }
15499 return pyobj;
15500 }
15501
15502
15503 static int _wrap_ART_MENU_set(PyObject *) {
15504 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15505 return 1;
15506 }
15507
15508
15509 static PyObject *_wrap_ART_MENU_get(void) {
15510 PyObject *pyobj;
15511
15512 {
15513 #if wxUSE_UNICODE
15514 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15515 #else
15516 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15517 #endif
15518 }
15519 return pyobj;
15520 }
15521
15522
15523 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15524 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15525 return 1;
15526 }
15527
15528
15529 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15530 PyObject *pyobj;
15531
15532 {
15533 #if wxUSE_UNICODE
15534 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15535 #else
15536 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15537 #endif
15538 }
15539 return pyobj;
15540 }
15541
15542
15543 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15544 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15545 return 1;
15546 }
15547
15548
15549 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15550 PyObject *pyobj;
15551
15552 {
15553 #if wxUSE_UNICODE
15554 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15555 #else
15556 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15557 #endif
15558 }
15559 return pyobj;
15560 }
15561
15562
15563 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15564 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15565 return 1;
15566 }
15567
15568
15569 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15570 PyObject *pyobj;
15571
15572 {
15573 #if wxUSE_UNICODE
15574 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15575 #else
15576 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15577 #endif
15578 }
15579 return pyobj;
15580 }
15581
15582
15583 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15584 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15585 return 1;
15586 }
15587
15588
15589 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15590 PyObject *pyobj;
15591
15592 {
15593 #if wxUSE_UNICODE
15594 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15595 #else
15596 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15597 #endif
15598 }
15599 return pyobj;
15600 }
15601
15602
15603 static int _wrap_ART_BUTTON_set(PyObject *) {
15604 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15605 return 1;
15606 }
15607
15608
15609 static PyObject *_wrap_ART_BUTTON_get(void) {
15610 PyObject *pyobj;
15611
15612 {
15613 #if wxUSE_UNICODE
15614 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15615 #else
15616 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15617 #endif
15618 }
15619 return pyobj;
15620 }
15621
15622
15623 static int _wrap_ART_OTHER_set(PyObject *) {
15624 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15625 return 1;
15626 }
15627
15628
15629 static PyObject *_wrap_ART_OTHER_get(void) {
15630 PyObject *pyobj;
15631
15632 {
15633 #if wxUSE_UNICODE
15634 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15635 #else
15636 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15637 #endif
15638 }
15639 return pyobj;
15640 }
15641
15642
15643 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15644 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15645 return 1;
15646 }
15647
15648
15649 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15650 PyObject *pyobj;
15651
15652 {
15653 #if wxUSE_UNICODE
15654 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15655 #else
15656 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15657 #endif
15658 }
15659 return pyobj;
15660 }
15661
15662
15663 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15664 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15665 return 1;
15666 }
15667
15668
15669 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15670 PyObject *pyobj;
15671
15672 {
15673 #if wxUSE_UNICODE
15674 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15675 #else
15676 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15677 #endif
15678 }
15679 return pyobj;
15680 }
15681
15682
15683 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15684 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15685 return 1;
15686 }
15687
15688
15689 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15690 PyObject *pyobj;
15691
15692 {
15693 #if wxUSE_UNICODE
15694 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15695 #else
15696 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15697 #endif
15698 }
15699 return pyobj;
15700 }
15701
15702
15703 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15704 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15705 return 1;
15706 }
15707
15708
15709 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15710 PyObject *pyobj;
15711
15712 {
15713 #if wxUSE_UNICODE
15714 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15715 #else
15716 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15717 #endif
15718 }
15719 return pyobj;
15720 }
15721
15722
15723 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15724 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15725 return 1;
15726 }
15727
15728
15729 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15730 PyObject *pyobj;
15731
15732 {
15733 #if wxUSE_UNICODE
15734 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15735 #else
15736 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15737 #endif
15738 }
15739 return pyobj;
15740 }
15741
15742
15743 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15744 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15745 return 1;
15746 }
15747
15748
15749 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15750 PyObject *pyobj;
15751
15752 {
15753 #if wxUSE_UNICODE
15754 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15755 #else
15756 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15757 #endif
15758 }
15759 return pyobj;
15760 }
15761
15762
15763 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15764 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15765 return 1;
15766 }
15767
15768
15769 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15770 PyObject *pyobj;
15771
15772 {
15773 #if wxUSE_UNICODE
15774 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15775 #else
15776 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15777 #endif
15778 }
15779 return pyobj;
15780 }
15781
15782
15783 static int _wrap_ART_GO_BACK_set(PyObject *) {
15784 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15785 return 1;
15786 }
15787
15788
15789 static PyObject *_wrap_ART_GO_BACK_get(void) {
15790 PyObject *pyobj;
15791
15792 {
15793 #if wxUSE_UNICODE
15794 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15795 #else
15796 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15797 #endif
15798 }
15799 return pyobj;
15800 }
15801
15802
15803 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15804 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15805 return 1;
15806 }
15807
15808
15809 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15810 PyObject *pyobj;
15811
15812 {
15813 #if wxUSE_UNICODE
15814 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15815 #else
15816 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15817 #endif
15818 }
15819 return pyobj;
15820 }
15821
15822
15823 static int _wrap_ART_GO_UP_set(PyObject *) {
15824 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15825 return 1;
15826 }
15827
15828
15829 static PyObject *_wrap_ART_GO_UP_get(void) {
15830 PyObject *pyobj;
15831
15832 {
15833 #if wxUSE_UNICODE
15834 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15835 #else
15836 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15837 #endif
15838 }
15839 return pyobj;
15840 }
15841
15842
15843 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15844 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15845 return 1;
15846 }
15847
15848
15849 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15850 PyObject *pyobj;
15851
15852 {
15853 #if wxUSE_UNICODE
15854 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15855 #else
15856 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15857 #endif
15858 }
15859 return pyobj;
15860 }
15861
15862
15863 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15864 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15865 return 1;
15866 }
15867
15868
15869 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15870 PyObject *pyobj;
15871
15872 {
15873 #if wxUSE_UNICODE
15874 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15875 #else
15876 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15877 #endif
15878 }
15879 return pyobj;
15880 }
15881
15882
15883 static int _wrap_ART_GO_HOME_set(PyObject *) {
15884 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15885 return 1;
15886 }
15887
15888
15889 static PyObject *_wrap_ART_GO_HOME_get(void) {
15890 PyObject *pyobj;
15891
15892 {
15893 #if wxUSE_UNICODE
15894 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15895 #else
15896 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15897 #endif
15898 }
15899 return pyobj;
15900 }
15901
15902
15903 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15904 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15905 return 1;
15906 }
15907
15908
15909 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15910 PyObject *pyobj;
15911
15912 {
15913 #if wxUSE_UNICODE
15914 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15915 #else
15916 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15917 #endif
15918 }
15919 return pyobj;
15920 }
15921
15922
15923 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15924 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15925 return 1;
15926 }
15927
15928
15929 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15930 PyObject *pyobj;
15931
15932 {
15933 #if wxUSE_UNICODE
15934 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15935 #else
15936 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15937 #endif
15938 }
15939 return pyobj;
15940 }
15941
15942
15943 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15944 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15945 return 1;
15946 }
15947
15948
15949 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15950 PyObject *pyobj;
15951
15952 {
15953 #if wxUSE_UNICODE
15954 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15955 #else
15956 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15957 #endif
15958 }
15959 return pyobj;
15960 }
15961
15962
15963 static int _wrap_ART_PRINT_set(PyObject *) {
15964 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15965 return 1;
15966 }
15967
15968
15969 static PyObject *_wrap_ART_PRINT_get(void) {
15970 PyObject *pyobj;
15971
15972 {
15973 #if wxUSE_UNICODE
15974 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15975 #else
15976 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15977 #endif
15978 }
15979 return pyobj;
15980 }
15981
15982
15983 static int _wrap_ART_HELP_set(PyObject *) {
15984 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15985 return 1;
15986 }
15987
15988
15989 static PyObject *_wrap_ART_HELP_get(void) {
15990 PyObject *pyobj;
15991
15992 {
15993 #if wxUSE_UNICODE
15994 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15995 #else
15996 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15997 #endif
15998 }
15999 return pyobj;
16000 }
16001
16002
16003 static int _wrap_ART_TIP_set(PyObject *) {
16004 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16005 return 1;
16006 }
16007
16008
16009 static PyObject *_wrap_ART_TIP_get(void) {
16010 PyObject *pyobj;
16011
16012 {
16013 #if wxUSE_UNICODE
16014 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16015 #else
16016 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16017 #endif
16018 }
16019 return pyobj;
16020 }
16021
16022
16023 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16024 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16025 return 1;
16026 }
16027
16028
16029 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16030 PyObject *pyobj;
16031
16032 {
16033 #if wxUSE_UNICODE
16034 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16035 #else
16036 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16037 #endif
16038 }
16039 return pyobj;
16040 }
16041
16042
16043 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16044 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16045 return 1;
16046 }
16047
16048
16049 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16050 PyObject *pyobj;
16051
16052 {
16053 #if wxUSE_UNICODE
16054 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16055 #else
16056 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16057 #endif
16058 }
16059 return pyobj;
16060 }
16061
16062
16063 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16064 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16065 return 1;
16066 }
16067
16068
16069 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16070 PyObject *pyobj;
16071
16072 {
16073 #if wxUSE_UNICODE
16074 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16075 #else
16076 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16077 #endif
16078 }
16079 return pyobj;
16080 }
16081
16082
16083 static int _wrap_ART_HARDDISK_set(PyObject *) {
16084 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16085 return 1;
16086 }
16087
16088
16089 static PyObject *_wrap_ART_HARDDISK_get(void) {
16090 PyObject *pyobj;
16091
16092 {
16093 #if wxUSE_UNICODE
16094 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16095 #else
16096 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16097 #endif
16098 }
16099 return pyobj;
16100 }
16101
16102
16103 static int _wrap_ART_FLOPPY_set(PyObject *) {
16104 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16105 return 1;
16106 }
16107
16108
16109 static PyObject *_wrap_ART_FLOPPY_get(void) {
16110 PyObject *pyobj;
16111
16112 {
16113 #if wxUSE_UNICODE
16114 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16115 #else
16116 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16117 #endif
16118 }
16119 return pyobj;
16120 }
16121
16122
16123 static int _wrap_ART_CDROM_set(PyObject *) {
16124 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16125 return 1;
16126 }
16127
16128
16129 static PyObject *_wrap_ART_CDROM_get(void) {
16130 PyObject *pyobj;
16131
16132 {
16133 #if wxUSE_UNICODE
16134 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16135 #else
16136 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16137 #endif
16138 }
16139 return pyobj;
16140 }
16141
16142
16143 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16144 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16145 return 1;
16146 }
16147
16148
16149 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16150 PyObject *pyobj;
16151
16152 {
16153 #if wxUSE_UNICODE
16154 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16155 #else
16156 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16157 #endif
16158 }
16159 return pyobj;
16160 }
16161
16162
16163 static int _wrap_ART_FOLDER_set(PyObject *) {
16164 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16165 return 1;
16166 }
16167
16168
16169 static PyObject *_wrap_ART_FOLDER_get(void) {
16170 PyObject *pyobj;
16171
16172 {
16173 #if wxUSE_UNICODE
16174 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16175 #else
16176 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16177 #endif
16178 }
16179 return pyobj;
16180 }
16181
16182
16183 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16184 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16185 return 1;
16186 }
16187
16188
16189 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16190 PyObject *pyobj;
16191
16192 {
16193 #if wxUSE_UNICODE
16194 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16195 #else
16196 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16197 #endif
16198 }
16199 return pyobj;
16200 }
16201
16202
16203 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16204 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16205 return 1;
16206 }
16207
16208
16209 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16210 PyObject *pyobj;
16211
16212 {
16213 #if wxUSE_UNICODE
16214 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16215 #else
16216 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16217 #endif
16218 }
16219 return pyobj;
16220 }
16221
16222
16223 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16224 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16225 return 1;
16226 }
16227
16228
16229 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16230 PyObject *pyobj;
16231
16232 {
16233 #if wxUSE_UNICODE
16234 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16235 #else
16236 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16237 #endif
16238 }
16239 return pyobj;
16240 }
16241
16242
16243 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16244 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16245 return 1;
16246 }
16247
16248
16249 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16250 PyObject *pyobj;
16251
16252 {
16253 #if wxUSE_UNICODE
16254 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16255 #else
16256 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16257 #endif
16258 }
16259 return pyobj;
16260 }
16261
16262
16263 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16264 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16265 return 1;
16266 }
16267
16268
16269 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16270 PyObject *pyobj;
16271
16272 {
16273 #if wxUSE_UNICODE
16274 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16275 #else
16276 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16277 #endif
16278 }
16279 return pyobj;
16280 }
16281
16282
16283 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16284 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16285 return 1;
16286 }
16287
16288
16289 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16290 PyObject *pyobj;
16291
16292 {
16293 #if wxUSE_UNICODE
16294 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16295 #else
16296 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16297 #endif
16298 }
16299 return pyobj;
16300 }
16301
16302
16303 static int _wrap_ART_ERROR_set(PyObject *) {
16304 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16305 return 1;
16306 }
16307
16308
16309 static PyObject *_wrap_ART_ERROR_get(void) {
16310 PyObject *pyobj;
16311
16312 {
16313 #if wxUSE_UNICODE
16314 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16315 #else
16316 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16317 #endif
16318 }
16319 return pyobj;
16320 }
16321
16322
16323 static int _wrap_ART_QUESTION_set(PyObject *) {
16324 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16325 return 1;
16326 }
16327
16328
16329 static PyObject *_wrap_ART_QUESTION_get(void) {
16330 PyObject *pyobj;
16331
16332 {
16333 #if wxUSE_UNICODE
16334 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16335 #else
16336 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16337 #endif
16338 }
16339 return pyobj;
16340 }
16341
16342
16343 static int _wrap_ART_WARNING_set(PyObject *) {
16344 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16345 return 1;
16346 }
16347
16348
16349 static PyObject *_wrap_ART_WARNING_get(void) {
16350 PyObject *pyobj;
16351
16352 {
16353 #if wxUSE_UNICODE
16354 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16355 #else
16356 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16357 #endif
16358 }
16359 return pyobj;
16360 }
16361
16362
16363 static int _wrap_ART_INFORMATION_set(PyObject *) {
16364 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16365 return 1;
16366 }
16367
16368
16369 static PyObject *_wrap_ART_INFORMATION_get(void) {
16370 PyObject *pyobj;
16371
16372 {
16373 #if wxUSE_UNICODE
16374 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16375 #else
16376 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16377 #endif
16378 }
16379 return pyobj;
16380 }
16381
16382
16383 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16384 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16385 return 1;
16386 }
16387
16388
16389 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16390 PyObject *pyobj;
16391
16392 {
16393 #if wxUSE_UNICODE
16394 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16395 #else
16396 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16397 #endif
16398 }
16399 return pyobj;
16400 }
16401
16402
16403 static int _wrap_ART_COPY_set(PyObject *) {
16404 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16405 return 1;
16406 }
16407
16408
16409 static PyObject *_wrap_ART_COPY_get(void) {
16410 PyObject *pyobj;
16411
16412 {
16413 #if wxUSE_UNICODE
16414 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16415 #else
16416 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16417 #endif
16418 }
16419 return pyobj;
16420 }
16421
16422
16423 static int _wrap_ART_CUT_set(PyObject *) {
16424 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16425 return 1;
16426 }
16427
16428
16429 static PyObject *_wrap_ART_CUT_get(void) {
16430 PyObject *pyobj;
16431
16432 {
16433 #if wxUSE_UNICODE
16434 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16435 #else
16436 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16437 #endif
16438 }
16439 return pyobj;
16440 }
16441
16442
16443 static int _wrap_ART_PASTE_set(PyObject *) {
16444 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16445 return 1;
16446 }
16447
16448
16449 static PyObject *_wrap_ART_PASTE_get(void) {
16450 PyObject *pyobj;
16451
16452 {
16453 #if wxUSE_UNICODE
16454 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16455 #else
16456 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16457 #endif
16458 }
16459 return pyobj;
16460 }
16461
16462
16463 static int _wrap_ART_DELETE_set(PyObject *) {
16464 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16465 return 1;
16466 }
16467
16468
16469 static PyObject *_wrap_ART_DELETE_get(void) {
16470 PyObject *pyobj;
16471
16472 {
16473 #if wxUSE_UNICODE
16474 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16475 #else
16476 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16477 #endif
16478 }
16479 return pyobj;
16480 }
16481
16482
16483 static int _wrap_ART_UNDO_set(PyObject *) {
16484 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16485 return 1;
16486 }
16487
16488
16489 static PyObject *_wrap_ART_UNDO_get(void) {
16490 PyObject *pyobj;
16491
16492 {
16493 #if wxUSE_UNICODE
16494 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16495 #else
16496 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16497 #endif
16498 }
16499 return pyobj;
16500 }
16501
16502
16503 static int _wrap_ART_REDO_set(PyObject *) {
16504 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16505 return 1;
16506 }
16507
16508
16509 static PyObject *_wrap_ART_REDO_get(void) {
16510 PyObject *pyobj;
16511
16512 {
16513 #if wxUSE_UNICODE
16514 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16515 #else
16516 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16517 #endif
16518 }
16519 return pyobj;
16520 }
16521
16522
16523 static int _wrap_ART_QUIT_set(PyObject *) {
16524 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16525 return 1;
16526 }
16527
16528
16529 static PyObject *_wrap_ART_QUIT_get(void) {
16530 PyObject *pyobj;
16531
16532 {
16533 #if wxUSE_UNICODE
16534 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16535 #else
16536 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16537 #endif
16538 }
16539 return pyobj;
16540 }
16541
16542
16543 static int _wrap_ART_FIND_set(PyObject *) {
16544 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16545 return 1;
16546 }
16547
16548
16549 static PyObject *_wrap_ART_FIND_get(void) {
16550 PyObject *pyobj;
16551
16552 {
16553 #if wxUSE_UNICODE
16554 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16555 #else
16556 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16557 #endif
16558 }
16559 return pyobj;
16560 }
16561
16562
16563 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16564 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16565 return 1;
16566 }
16567
16568
16569 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16570 PyObject *pyobj;
16571
16572 {
16573 #if wxUSE_UNICODE
16574 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16575 #else
16576 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16577 #endif
16578 }
16579 return pyobj;
16580 }
16581
16582
16583 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16584 PyObject *resultobj;
16585 wxPyArtProvider *result;
16586 char *kwnames[] = {
16587 NULL
16588 };
16589
16590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16591 {
16592 if (!wxPyCheckForApp()) SWIG_fail;
16593 PyThreadState* __tstate = wxPyBeginAllowThreads();
16594 result = (wxPyArtProvider *)new wxPyArtProvider();
16595
16596 wxPyEndAllowThreads(__tstate);
16597 if (PyErr_Occurred()) SWIG_fail;
16598 }
16599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16600 return resultobj;
16601 fail:
16602 return NULL;
16603 }
16604
16605
16606 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16607 PyObject *resultobj;
16608 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16609 PyObject *arg2 = (PyObject *) 0 ;
16610 PyObject *arg3 = (PyObject *) 0 ;
16611 PyObject * obj0 = 0 ;
16612 PyObject * obj1 = 0 ;
16613 PyObject * obj2 = 0 ;
16614 char *kwnames[] = {
16615 (char *) "self",(char *) "self",(char *) "_class", NULL
16616 };
16617
16618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16620 if (SWIG_arg_fail(1)) SWIG_fail;
16621 arg2 = obj1;
16622 arg3 = obj2;
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 (arg1)->_setCallbackInfo(arg2,arg3);
16626
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 Py_INCREF(Py_None); resultobj = Py_None;
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16638 PyObject *resultobj;
16639 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16640 PyObject * obj0 = 0 ;
16641 char *kwnames[] = {
16642 (char *) "provider", NULL
16643 };
16644
16645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16647 if (SWIG_arg_fail(1)) SWIG_fail;
16648 {
16649 PyThreadState* __tstate = wxPyBeginAllowThreads();
16650 wxPyArtProvider::PushProvider(arg1);
16651
16652 wxPyEndAllowThreads(__tstate);
16653 if (PyErr_Occurred()) SWIG_fail;
16654 }
16655 Py_INCREF(Py_None); resultobj = Py_None;
16656 return resultobj;
16657 fail:
16658 return NULL;
16659 }
16660
16661
16662 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16663 PyObject *resultobj;
16664 bool result;
16665 char *kwnames[] = {
16666 NULL
16667 };
16668
16669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16670 {
16671 PyThreadState* __tstate = wxPyBeginAllowThreads();
16672 result = (bool)wxPyArtProvider::PopProvider();
16673
16674 wxPyEndAllowThreads(__tstate);
16675 if (PyErr_Occurred()) SWIG_fail;
16676 }
16677 {
16678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16679 }
16680 return resultobj;
16681 fail:
16682 return NULL;
16683 }
16684
16685
16686 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16687 PyObject *resultobj;
16688 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16689 bool result;
16690 PyObject * obj0 = 0 ;
16691 char *kwnames[] = {
16692 (char *) "provider", NULL
16693 };
16694
16695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16697 if (SWIG_arg_fail(1)) SWIG_fail;
16698 {
16699 PyThreadState* __tstate = wxPyBeginAllowThreads();
16700 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16701
16702 wxPyEndAllowThreads(__tstate);
16703 if (PyErr_Occurred()) SWIG_fail;
16704 }
16705 {
16706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16707 }
16708 return resultobj;
16709 fail:
16710 return NULL;
16711 }
16712
16713
16714 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16715 PyObject *resultobj;
16716 wxString *arg1 = 0 ;
16717 wxString const &arg2_defvalue = wxPyART_OTHER ;
16718 wxString *arg2 = (wxString *) &arg2_defvalue ;
16719 wxSize const &arg3_defvalue = wxDefaultSize ;
16720 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16721 wxBitmap result;
16722 bool temp1 = false ;
16723 bool temp2 = false ;
16724 wxSize temp3 ;
16725 PyObject * obj0 = 0 ;
16726 PyObject * obj1 = 0 ;
16727 PyObject * obj2 = 0 ;
16728 char *kwnames[] = {
16729 (char *) "id",(char *) "client",(char *) "size", NULL
16730 };
16731
16732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16733 {
16734 arg1 = wxString_in_helper(obj0);
16735 if (arg1 == NULL) SWIG_fail;
16736 temp1 = true;
16737 }
16738 if (obj1) {
16739 {
16740 arg2 = wxString_in_helper(obj1);
16741 if (arg2 == NULL) SWIG_fail;
16742 temp2 = true;
16743 }
16744 }
16745 if (obj2) {
16746 {
16747 arg3 = &temp3;
16748 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16749 }
16750 }
16751 {
16752 if (!wxPyCheckForApp()) SWIG_fail;
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16755
16756 wxPyEndAllowThreads(__tstate);
16757 if (PyErr_Occurred()) SWIG_fail;
16758 }
16759 {
16760 wxBitmap * resultptr;
16761 resultptr = new wxBitmap((wxBitmap &)(result));
16762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16763 }
16764 {
16765 if (temp1)
16766 delete arg1;
16767 }
16768 {
16769 if (temp2)
16770 delete arg2;
16771 }
16772 return resultobj;
16773 fail:
16774 {
16775 if (temp1)
16776 delete arg1;
16777 }
16778 {
16779 if (temp2)
16780 delete arg2;
16781 }
16782 return NULL;
16783 }
16784
16785
16786 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16787 PyObject *resultobj;
16788 wxString *arg1 = 0 ;
16789 wxString const &arg2_defvalue = wxPyART_OTHER ;
16790 wxString *arg2 = (wxString *) &arg2_defvalue ;
16791 wxSize const &arg3_defvalue = wxDefaultSize ;
16792 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16793 wxIcon result;
16794 bool temp1 = false ;
16795 bool temp2 = false ;
16796 wxSize temp3 ;
16797 PyObject * obj0 = 0 ;
16798 PyObject * obj1 = 0 ;
16799 PyObject * obj2 = 0 ;
16800 char *kwnames[] = {
16801 (char *) "id",(char *) "client",(char *) "size", NULL
16802 };
16803
16804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16805 {
16806 arg1 = wxString_in_helper(obj0);
16807 if (arg1 == NULL) SWIG_fail;
16808 temp1 = true;
16809 }
16810 if (obj1) {
16811 {
16812 arg2 = wxString_in_helper(obj1);
16813 if (arg2 == NULL) SWIG_fail;
16814 temp2 = true;
16815 }
16816 }
16817 if (obj2) {
16818 {
16819 arg3 = &temp3;
16820 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16821 }
16822 }
16823 {
16824 if (!wxPyCheckForApp()) SWIG_fail;
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16827
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 {
16832 wxIcon * resultptr;
16833 resultptr = new wxIcon((wxIcon &)(result));
16834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16835 }
16836 {
16837 if (temp1)
16838 delete arg1;
16839 }
16840 {
16841 if (temp2)
16842 delete arg2;
16843 }
16844 return resultobj;
16845 fail:
16846 {
16847 if (temp1)
16848 delete arg1;
16849 }
16850 {
16851 if (temp2)
16852 delete arg2;
16853 }
16854 return NULL;
16855 }
16856
16857
16858 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16859 PyObject *resultobj;
16860 wxString *arg1 = 0 ;
16861 bool arg2 = (bool) false ;
16862 wxSize result;
16863 bool temp1 = false ;
16864 PyObject * obj0 = 0 ;
16865 PyObject * obj1 = 0 ;
16866 char *kwnames[] = {
16867 (char *) "client",(char *) "platform_dependent", NULL
16868 };
16869
16870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16871 {
16872 arg1 = wxString_in_helper(obj0);
16873 if (arg1 == NULL) SWIG_fail;
16874 temp1 = true;
16875 }
16876 if (obj1) {
16877 {
16878 arg2 = (bool)(SWIG_As_bool(obj1));
16879 if (SWIG_arg_fail(2)) SWIG_fail;
16880 }
16881 }
16882 {
16883 PyThreadState* __tstate = wxPyBeginAllowThreads();
16884 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16885
16886 wxPyEndAllowThreads(__tstate);
16887 if (PyErr_Occurred()) SWIG_fail;
16888 }
16889 {
16890 wxSize * resultptr;
16891 resultptr = new wxSize((wxSize &)(result));
16892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16893 }
16894 {
16895 if (temp1)
16896 delete arg1;
16897 }
16898 return resultobj;
16899 fail:
16900 {
16901 if (temp1)
16902 delete arg1;
16903 }
16904 return NULL;
16905 }
16906
16907
16908 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16909 PyObject *resultobj;
16910 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16911 PyObject * obj0 = 0 ;
16912 char *kwnames[] = {
16913 (char *) "self", NULL
16914 };
16915
16916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16918 if (SWIG_arg_fail(1)) SWIG_fail;
16919 {
16920 PyThreadState* __tstate = wxPyBeginAllowThreads();
16921 wxPyArtProvider_Destroy(arg1);
16922
16923 wxPyEndAllowThreads(__tstate);
16924 if (PyErr_Occurred()) SWIG_fail;
16925 }
16926 Py_INCREF(Py_None); resultobj = Py_None;
16927 return resultobj;
16928 fail:
16929 return NULL;
16930 }
16931
16932
16933 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16934 PyObject *obj;
16935 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16936 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16937 Py_INCREF(obj);
16938 return Py_BuildValue((char *)"");
16939 }
16940 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16941 PyObject *resultobj;
16942 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16943 PyObject * obj0 = 0 ;
16944 char *kwnames[] = {
16945 (char *) "self", NULL
16946 };
16947
16948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16950 if (SWIG_arg_fail(1)) SWIG_fail;
16951 {
16952 PyThreadState* __tstate = wxPyBeginAllowThreads();
16953 delete arg1;
16954
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 Py_INCREF(Py_None); resultobj = Py_None;
16959 return resultobj;
16960 fail:
16961 return NULL;
16962 }
16963
16964
16965 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj;
16967 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16968 wxConfigBase *result;
16969 PyObject * obj0 = 0 ;
16970 char *kwnames[] = {
16971 (char *) "config", NULL
16972 };
16973
16974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16976 if (SWIG_arg_fail(1)) SWIG_fail;
16977 {
16978 PyThreadState* __tstate = wxPyBeginAllowThreads();
16979 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16980
16981 wxPyEndAllowThreads(__tstate);
16982 if (PyErr_Occurred()) SWIG_fail;
16983 }
16984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16985 return resultobj;
16986 fail:
16987 return NULL;
16988 }
16989
16990
16991 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16992 PyObject *resultobj;
16993 bool arg1 = (bool) true ;
16994 wxConfigBase *result;
16995 PyObject * obj0 = 0 ;
16996 char *kwnames[] = {
16997 (char *) "createOnDemand", NULL
16998 };
16999
17000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17001 if (obj0) {
17002 {
17003 arg1 = (bool)(SWIG_As_bool(obj0));
17004 if (SWIG_arg_fail(1)) SWIG_fail;
17005 }
17006 }
17007 {
17008 PyThreadState* __tstate = wxPyBeginAllowThreads();
17009 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17010
17011 wxPyEndAllowThreads(__tstate);
17012 if (PyErr_Occurred()) SWIG_fail;
17013 }
17014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17015 return resultobj;
17016 fail:
17017 return NULL;
17018 }
17019
17020
17021 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17022 PyObject *resultobj;
17023 wxConfigBase *result;
17024 char *kwnames[] = {
17025 NULL
17026 };
17027
17028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17029 {
17030 PyThreadState* __tstate = wxPyBeginAllowThreads();
17031 result = (wxConfigBase *)wxConfigBase::Create();
17032
17033 wxPyEndAllowThreads(__tstate);
17034 if (PyErr_Occurred()) SWIG_fail;
17035 }
17036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17037 return resultobj;
17038 fail:
17039 return NULL;
17040 }
17041
17042
17043 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17044 PyObject *resultobj;
17045 char *kwnames[] = {
17046 NULL
17047 };
17048
17049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17050 {
17051 PyThreadState* __tstate = wxPyBeginAllowThreads();
17052 wxConfigBase::DontCreateOnDemand();
17053
17054 wxPyEndAllowThreads(__tstate);
17055 if (PyErr_Occurred()) SWIG_fail;
17056 }
17057 Py_INCREF(Py_None); resultobj = Py_None;
17058 return resultobj;
17059 fail:
17060 return NULL;
17061 }
17062
17063
17064 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17065 PyObject *resultobj;
17066 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17067 wxString *arg2 = 0 ;
17068 bool temp2 = false ;
17069 PyObject * obj0 = 0 ;
17070 PyObject * obj1 = 0 ;
17071 char *kwnames[] = {
17072 (char *) "self",(char *) "path", NULL
17073 };
17074
17075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17077 if (SWIG_arg_fail(1)) SWIG_fail;
17078 {
17079 arg2 = wxString_in_helper(obj1);
17080 if (arg2 == NULL) SWIG_fail;
17081 temp2 = true;
17082 }
17083 {
17084 PyThreadState* __tstate = wxPyBeginAllowThreads();
17085 (arg1)->SetPath((wxString const &)*arg2);
17086
17087 wxPyEndAllowThreads(__tstate);
17088 if (PyErr_Occurred()) SWIG_fail;
17089 }
17090 Py_INCREF(Py_None); resultobj = Py_None;
17091 {
17092 if (temp2)
17093 delete arg2;
17094 }
17095 return resultobj;
17096 fail:
17097 {
17098 if (temp2)
17099 delete arg2;
17100 }
17101 return NULL;
17102 }
17103
17104
17105 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17106 PyObject *resultobj;
17107 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17108 wxString *result;
17109 PyObject * obj0 = 0 ;
17110 char *kwnames[] = {
17111 (char *) "self", NULL
17112 };
17113
17114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17116 if (SWIG_arg_fail(1)) SWIG_fail;
17117 {
17118 PyThreadState* __tstate = wxPyBeginAllowThreads();
17119 {
17120 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17121 result = (wxString *) &_result_ref;
17122 }
17123
17124 wxPyEndAllowThreads(__tstate);
17125 if (PyErr_Occurred()) SWIG_fail;
17126 }
17127 {
17128 #if wxUSE_UNICODE
17129 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17130 #else
17131 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17132 #endif
17133 }
17134 return resultobj;
17135 fail:
17136 return NULL;
17137 }
17138
17139
17140 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj;
17142 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17143 PyObject *result;
17144 PyObject * obj0 = 0 ;
17145 char *kwnames[] = {
17146 (char *) "self", NULL
17147 };
17148
17149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17151 if (SWIG_arg_fail(1)) SWIG_fail;
17152 {
17153 PyThreadState* __tstate = wxPyBeginAllowThreads();
17154 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17155
17156 wxPyEndAllowThreads(__tstate);
17157 if (PyErr_Occurred()) SWIG_fail;
17158 }
17159 resultobj = result;
17160 return resultobj;
17161 fail:
17162 return NULL;
17163 }
17164
17165
17166 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17167 PyObject *resultobj;
17168 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17169 long arg2 ;
17170 PyObject *result;
17171 PyObject * obj0 = 0 ;
17172 PyObject * obj1 = 0 ;
17173 char *kwnames[] = {
17174 (char *) "self",(char *) "index", NULL
17175 };
17176
17177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17179 if (SWIG_arg_fail(1)) SWIG_fail;
17180 {
17181 arg2 = (long)(SWIG_As_long(obj1));
17182 if (SWIG_arg_fail(2)) SWIG_fail;
17183 }
17184 {
17185 PyThreadState* __tstate = wxPyBeginAllowThreads();
17186 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17187
17188 wxPyEndAllowThreads(__tstate);
17189 if (PyErr_Occurred()) SWIG_fail;
17190 }
17191 resultobj = result;
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj;
17200 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17201 PyObject *result;
17202 PyObject * obj0 = 0 ;
17203 char *kwnames[] = {
17204 (char *) "self", NULL
17205 };
17206
17207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17209 if (SWIG_arg_fail(1)) SWIG_fail;
17210 {
17211 PyThreadState* __tstate = wxPyBeginAllowThreads();
17212 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17213
17214 wxPyEndAllowThreads(__tstate);
17215 if (PyErr_Occurred()) SWIG_fail;
17216 }
17217 resultobj = result;
17218 return resultobj;
17219 fail:
17220 return NULL;
17221 }
17222
17223
17224 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17225 PyObject *resultobj;
17226 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17227 long arg2 ;
17228 PyObject *result;
17229 PyObject * obj0 = 0 ;
17230 PyObject * obj1 = 0 ;
17231 char *kwnames[] = {
17232 (char *) "self",(char *) "index", NULL
17233 };
17234
17235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17237 if (SWIG_arg_fail(1)) SWIG_fail;
17238 {
17239 arg2 = (long)(SWIG_As_long(obj1));
17240 if (SWIG_arg_fail(2)) SWIG_fail;
17241 }
17242 {
17243 PyThreadState* __tstate = wxPyBeginAllowThreads();
17244 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17245
17246 wxPyEndAllowThreads(__tstate);
17247 if (PyErr_Occurred()) SWIG_fail;
17248 }
17249 resultobj = result;
17250 return resultobj;
17251 fail:
17252 return NULL;
17253 }
17254
17255
17256 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17257 PyObject *resultobj;
17258 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17259 bool arg2 = (bool) false ;
17260 size_t result;
17261 PyObject * obj0 = 0 ;
17262 PyObject * obj1 = 0 ;
17263 char *kwnames[] = {
17264 (char *) "self",(char *) "recursive", NULL
17265 };
17266
17267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17269 if (SWIG_arg_fail(1)) SWIG_fail;
17270 if (obj1) {
17271 {
17272 arg2 = (bool)(SWIG_As_bool(obj1));
17273 if (SWIG_arg_fail(2)) SWIG_fail;
17274 }
17275 }
17276 {
17277 PyThreadState* __tstate = wxPyBeginAllowThreads();
17278 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17279
17280 wxPyEndAllowThreads(__tstate);
17281 if (PyErr_Occurred()) SWIG_fail;
17282 }
17283 {
17284 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17285 }
17286 return resultobj;
17287 fail:
17288 return NULL;
17289 }
17290
17291
17292 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17293 PyObject *resultobj;
17294 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17295 bool arg2 = (bool) false ;
17296 size_t result;
17297 PyObject * obj0 = 0 ;
17298 PyObject * obj1 = 0 ;
17299 char *kwnames[] = {
17300 (char *) "self",(char *) "recursive", NULL
17301 };
17302
17303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17305 if (SWIG_arg_fail(1)) SWIG_fail;
17306 if (obj1) {
17307 {
17308 arg2 = (bool)(SWIG_As_bool(obj1));
17309 if (SWIG_arg_fail(2)) SWIG_fail;
17310 }
17311 }
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17315
17316 wxPyEndAllowThreads(__tstate);
17317 if (PyErr_Occurred()) SWIG_fail;
17318 }
17319 {
17320 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17321 }
17322 return resultobj;
17323 fail:
17324 return NULL;
17325 }
17326
17327
17328 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17329 PyObject *resultobj;
17330 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17331 wxString *arg2 = 0 ;
17332 bool result;
17333 bool temp2 = false ;
17334 PyObject * obj0 = 0 ;
17335 PyObject * obj1 = 0 ;
17336 char *kwnames[] = {
17337 (char *) "self",(char *) "name", NULL
17338 };
17339
17340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17342 if (SWIG_arg_fail(1)) SWIG_fail;
17343 {
17344 arg2 = wxString_in_helper(obj1);
17345 if (arg2 == NULL) SWIG_fail;
17346 temp2 = true;
17347 }
17348 {
17349 PyThreadState* __tstate = wxPyBeginAllowThreads();
17350 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17351
17352 wxPyEndAllowThreads(__tstate);
17353 if (PyErr_Occurred()) SWIG_fail;
17354 }
17355 {
17356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17357 }
17358 {
17359 if (temp2)
17360 delete arg2;
17361 }
17362 return resultobj;
17363 fail:
17364 {
17365 if (temp2)
17366 delete arg2;
17367 }
17368 return NULL;
17369 }
17370
17371
17372 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17373 PyObject *resultobj;
17374 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17375 wxString *arg2 = 0 ;
17376 bool result;
17377 bool temp2 = false ;
17378 PyObject * obj0 = 0 ;
17379 PyObject * obj1 = 0 ;
17380 char *kwnames[] = {
17381 (char *) "self",(char *) "name", NULL
17382 };
17383
17384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17386 if (SWIG_arg_fail(1)) SWIG_fail;
17387 {
17388 arg2 = wxString_in_helper(obj1);
17389 if (arg2 == NULL) SWIG_fail;
17390 temp2 = true;
17391 }
17392 {
17393 PyThreadState* __tstate = wxPyBeginAllowThreads();
17394 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17395
17396 wxPyEndAllowThreads(__tstate);
17397 if (PyErr_Occurred()) SWIG_fail;
17398 }
17399 {
17400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17401 }
17402 {
17403 if (temp2)
17404 delete arg2;
17405 }
17406 return resultobj;
17407 fail:
17408 {
17409 if (temp2)
17410 delete arg2;
17411 }
17412 return NULL;
17413 }
17414
17415
17416 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17417 PyObject *resultobj;
17418 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17419 wxString *arg2 = 0 ;
17420 bool result;
17421 bool temp2 = false ;
17422 PyObject * obj0 = 0 ;
17423 PyObject * obj1 = 0 ;
17424 char *kwnames[] = {
17425 (char *) "self",(char *) "name", NULL
17426 };
17427
17428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17430 if (SWIG_arg_fail(1)) SWIG_fail;
17431 {
17432 arg2 = wxString_in_helper(obj1);
17433 if (arg2 == NULL) SWIG_fail;
17434 temp2 = true;
17435 }
17436 {
17437 PyThreadState* __tstate = wxPyBeginAllowThreads();
17438 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17439
17440 wxPyEndAllowThreads(__tstate);
17441 if (PyErr_Occurred()) SWIG_fail;
17442 }
17443 {
17444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17445 }
17446 {
17447 if (temp2)
17448 delete arg2;
17449 }
17450 return resultobj;
17451 fail:
17452 {
17453 if (temp2)
17454 delete arg2;
17455 }
17456 return NULL;
17457 }
17458
17459
17460 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17461 PyObject *resultobj;
17462 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17463 wxString *arg2 = 0 ;
17464 wxConfigBase::EntryType result;
17465 bool temp2 = false ;
17466 PyObject * obj0 = 0 ;
17467 PyObject * obj1 = 0 ;
17468 char *kwnames[] = {
17469 (char *) "self",(char *) "name", NULL
17470 };
17471
17472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17474 if (SWIG_arg_fail(1)) SWIG_fail;
17475 {
17476 arg2 = wxString_in_helper(obj1);
17477 if (arg2 == NULL) SWIG_fail;
17478 temp2 = true;
17479 }
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17483
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 resultobj = SWIG_From_int((result));
17488 {
17489 if (temp2)
17490 delete arg2;
17491 }
17492 return resultobj;
17493 fail:
17494 {
17495 if (temp2)
17496 delete arg2;
17497 }
17498 return NULL;
17499 }
17500
17501
17502 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17503 PyObject *resultobj;
17504 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17505 wxString *arg2 = 0 ;
17506 wxString const &arg3_defvalue = wxPyEmptyString ;
17507 wxString *arg3 = (wxString *) &arg3_defvalue ;
17508 wxString result;
17509 bool temp2 = false ;
17510 bool temp3 = false ;
17511 PyObject * obj0 = 0 ;
17512 PyObject * obj1 = 0 ;
17513 PyObject * obj2 = 0 ;
17514 char *kwnames[] = {
17515 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17516 };
17517
17518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17520 if (SWIG_arg_fail(1)) SWIG_fail;
17521 {
17522 arg2 = wxString_in_helper(obj1);
17523 if (arg2 == NULL) SWIG_fail;
17524 temp2 = true;
17525 }
17526 if (obj2) {
17527 {
17528 arg3 = wxString_in_helper(obj2);
17529 if (arg3 == NULL) SWIG_fail;
17530 temp3 = true;
17531 }
17532 }
17533 {
17534 PyThreadState* __tstate = wxPyBeginAllowThreads();
17535 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17536
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 {
17541 #if wxUSE_UNICODE
17542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17543 #else
17544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17545 #endif
17546 }
17547 {
17548 if (temp2)
17549 delete arg2;
17550 }
17551 {
17552 if (temp3)
17553 delete arg3;
17554 }
17555 return resultobj;
17556 fail:
17557 {
17558 if (temp2)
17559 delete arg2;
17560 }
17561 {
17562 if (temp3)
17563 delete arg3;
17564 }
17565 return NULL;
17566 }
17567
17568
17569 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17570 PyObject *resultobj;
17571 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17572 wxString *arg2 = 0 ;
17573 long arg3 = (long) 0 ;
17574 long result;
17575 bool temp2 = false ;
17576 PyObject * obj0 = 0 ;
17577 PyObject * obj1 = 0 ;
17578 PyObject * obj2 = 0 ;
17579 char *kwnames[] = {
17580 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17581 };
17582
17583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17585 if (SWIG_arg_fail(1)) SWIG_fail;
17586 {
17587 arg2 = wxString_in_helper(obj1);
17588 if (arg2 == NULL) SWIG_fail;
17589 temp2 = true;
17590 }
17591 if (obj2) {
17592 {
17593 arg3 = (long)(SWIG_As_long(obj2));
17594 if (SWIG_arg_fail(3)) SWIG_fail;
17595 }
17596 }
17597 {
17598 PyThreadState* __tstate = wxPyBeginAllowThreads();
17599 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17600
17601 wxPyEndAllowThreads(__tstate);
17602 if (PyErr_Occurred()) SWIG_fail;
17603 }
17604 {
17605 resultobj = SWIG_From_long((long)(result));
17606 }
17607 {
17608 if (temp2)
17609 delete arg2;
17610 }
17611 return resultobj;
17612 fail:
17613 {
17614 if (temp2)
17615 delete arg2;
17616 }
17617 return NULL;
17618 }
17619
17620
17621 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17622 PyObject *resultobj;
17623 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17624 wxString *arg2 = 0 ;
17625 double arg3 = (double) 0.0 ;
17626 double result;
17627 bool temp2 = false ;
17628 PyObject * obj0 = 0 ;
17629 PyObject * obj1 = 0 ;
17630 PyObject * obj2 = 0 ;
17631 char *kwnames[] = {
17632 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17633 };
17634
17635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17637 if (SWIG_arg_fail(1)) SWIG_fail;
17638 {
17639 arg2 = wxString_in_helper(obj1);
17640 if (arg2 == NULL) SWIG_fail;
17641 temp2 = true;
17642 }
17643 if (obj2) {
17644 {
17645 arg3 = (double)(SWIG_As_double(obj2));
17646 if (SWIG_arg_fail(3)) SWIG_fail;
17647 }
17648 }
17649 {
17650 PyThreadState* __tstate = wxPyBeginAllowThreads();
17651 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17652
17653 wxPyEndAllowThreads(__tstate);
17654 if (PyErr_Occurred()) SWIG_fail;
17655 }
17656 {
17657 resultobj = SWIG_From_double((double)(result));
17658 }
17659 {
17660 if (temp2)
17661 delete arg2;
17662 }
17663 return resultobj;
17664 fail:
17665 {
17666 if (temp2)
17667 delete arg2;
17668 }
17669 return NULL;
17670 }
17671
17672
17673 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17674 PyObject *resultobj;
17675 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17676 wxString *arg2 = 0 ;
17677 bool arg3 = (bool) false ;
17678 bool result;
17679 bool temp2 = false ;
17680 PyObject * obj0 = 0 ;
17681 PyObject * obj1 = 0 ;
17682 PyObject * obj2 = 0 ;
17683 char *kwnames[] = {
17684 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17685 };
17686
17687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17689 if (SWIG_arg_fail(1)) SWIG_fail;
17690 {
17691 arg2 = wxString_in_helper(obj1);
17692 if (arg2 == NULL) SWIG_fail;
17693 temp2 = true;
17694 }
17695 if (obj2) {
17696 {
17697 arg3 = (bool)(SWIG_As_bool(obj2));
17698 if (SWIG_arg_fail(3)) SWIG_fail;
17699 }
17700 }
17701 {
17702 PyThreadState* __tstate = wxPyBeginAllowThreads();
17703 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17704
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 {
17709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17710 }
17711 {
17712 if (temp2)
17713 delete arg2;
17714 }
17715 return resultobj;
17716 fail:
17717 {
17718 if (temp2)
17719 delete arg2;
17720 }
17721 return NULL;
17722 }
17723
17724
17725 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17726 PyObject *resultobj;
17727 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17728 wxString *arg2 = 0 ;
17729 wxString *arg3 = 0 ;
17730 bool result;
17731 bool temp2 = false ;
17732 bool temp3 = false ;
17733 PyObject * obj0 = 0 ;
17734 PyObject * obj1 = 0 ;
17735 PyObject * obj2 = 0 ;
17736 char *kwnames[] = {
17737 (char *) "self",(char *) "key",(char *) "value", NULL
17738 };
17739
17740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17742 if (SWIG_arg_fail(1)) SWIG_fail;
17743 {
17744 arg2 = wxString_in_helper(obj1);
17745 if (arg2 == NULL) SWIG_fail;
17746 temp2 = true;
17747 }
17748 {
17749 arg3 = wxString_in_helper(obj2);
17750 if (arg3 == NULL) SWIG_fail;
17751 temp3 = true;
17752 }
17753 {
17754 PyThreadState* __tstate = wxPyBeginAllowThreads();
17755 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17756
17757 wxPyEndAllowThreads(__tstate);
17758 if (PyErr_Occurred()) SWIG_fail;
17759 }
17760 {
17761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17762 }
17763 {
17764 if (temp2)
17765 delete arg2;
17766 }
17767 {
17768 if (temp3)
17769 delete arg3;
17770 }
17771 return resultobj;
17772 fail:
17773 {
17774 if (temp2)
17775 delete arg2;
17776 }
17777 {
17778 if (temp3)
17779 delete arg3;
17780 }
17781 return NULL;
17782 }
17783
17784
17785 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17786 PyObject *resultobj;
17787 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17788 wxString *arg2 = 0 ;
17789 long arg3 ;
17790 bool result;
17791 bool temp2 = false ;
17792 PyObject * obj0 = 0 ;
17793 PyObject * obj1 = 0 ;
17794 PyObject * obj2 = 0 ;
17795 char *kwnames[] = {
17796 (char *) "self",(char *) "key",(char *) "value", NULL
17797 };
17798
17799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17801 if (SWIG_arg_fail(1)) SWIG_fail;
17802 {
17803 arg2 = wxString_in_helper(obj1);
17804 if (arg2 == NULL) SWIG_fail;
17805 temp2 = true;
17806 }
17807 {
17808 arg3 = (long)(SWIG_As_long(obj2));
17809 if (SWIG_arg_fail(3)) SWIG_fail;
17810 }
17811 {
17812 PyThreadState* __tstate = wxPyBeginAllowThreads();
17813 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17814
17815 wxPyEndAllowThreads(__tstate);
17816 if (PyErr_Occurred()) SWIG_fail;
17817 }
17818 {
17819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17820 }
17821 {
17822 if (temp2)
17823 delete arg2;
17824 }
17825 return resultobj;
17826 fail:
17827 {
17828 if (temp2)
17829 delete arg2;
17830 }
17831 return NULL;
17832 }
17833
17834
17835 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj;
17837 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17838 wxString *arg2 = 0 ;
17839 double arg3 ;
17840 bool result;
17841 bool temp2 = false ;
17842 PyObject * obj0 = 0 ;
17843 PyObject * obj1 = 0 ;
17844 PyObject * obj2 = 0 ;
17845 char *kwnames[] = {
17846 (char *) "self",(char *) "key",(char *) "value", NULL
17847 };
17848
17849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17851 if (SWIG_arg_fail(1)) SWIG_fail;
17852 {
17853 arg2 = wxString_in_helper(obj1);
17854 if (arg2 == NULL) SWIG_fail;
17855 temp2 = true;
17856 }
17857 {
17858 arg3 = (double)(SWIG_As_double(obj2));
17859 if (SWIG_arg_fail(3)) SWIG_fail;
17860 }
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17864
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 {
17869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17870 }
17871 {
17872 if (temp2)
17873 delete arg2;
17874 }
17875 return resultobj;
17876 fail:
17877 {
17878 if (temp2)
17879 delete arg2;
17880 }
17881 return NULL;
17882 }
17883
17884
17885 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17886 PyObject *resultobj;
17887 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17888 wxString *arg2 = 0 ;
17889 bool arg3 ;
17890 bool result;
17891 bool temp2 = false ;
17892 PyObject * obj0 = 0 ;
17893 PyObject * obj1 = 0 ;
17894 PyObject * obj2 = 0 ;
17895 char *kwnames[] = {
17896 (char *) "self",(char *) "key",(char *) "value", NULL
17897 };
17898
17899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17901 if (SWIG_arg_fail(1)) SWIG_fail;
17902 {
17903 arg2 = wxString_in_helper(obj1);
17904 if (arg2 == NULL) SWIG_fail;
17905 temp2 = true;
17906 }
17907 {
17908 arg3 = (bool)(SWIG_As_bool(obj2));
17909 if (SWIG_arg_fail(3)) SWIG_fail;
17910 }
17911 {
17912 PyThreadState* __tstate = wxPyBeginAllowThreads();
17913 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17914
17915 wxPyEndAllowThreads(__tstate);
17916 if (PyErr_Occurred()) SWIG_fail;
17917 }
17918 {
17919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17920 }
17921 {
17922 if (temp2)
17923 delete arg2;
17924 }
17925 return resultobj;
17926 fail:
17927 {
17928 if (temp2)
17929 delete arg2;
17930 }
17931 return NULL;
17932 }
17933
17934
17935 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17936 PyObject *resultobj;
17937 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17938 bool arg2 = (bool) false ;
17939 bool result;
17940 PyObject * obj0 = 0 ;
17941 PyObject * obj1 = 0 ;
17942 char *kwnames[] = {
17943 (char *) "self",(char *) "currentOnly", NULL
17944 };
17945
17946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17948 if (SWIG_arg_fail(1)) SWIG_fail;
17949 if (obj1) {
17950 {
17951 arg2 = (bool)(SWIG_As_bool(obj1));
17952 if (SWIG_arg_fail(2)) SWIG_fail;
17953 }
17954 }
17955 {
17956 PyThreadState* __tstate = wxPyBeginAllowThreads();
17957 result = (bool)(arg1)->Flush(arg2);
17958
17959 wxPyEndAllowThreads(__tstate);
17960 if (PyErr_Occurred()) SWIG_fail;
17961 }
17962 {
17963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17964 }
17965 return resultobj;
17966 fail:
17967 return NULL;
17968 }
17969
17970
17971 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17972 PyObject *resultobj;
17973 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17974 wxString *arg2 = 0 ;
17975 wxString *arg3 = 0 ;
17976 bool result;
17977 bool temp2 = false ;
17978 bool temp3 = false ;
17979 PyObject * obj0 = 0 ;
17980 PyObject * obj1 = 0 ;
17981 PyObject * obj2 = 0 ;
17982 char *kwnames[] = {
17983 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17984 };
17985
17986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17988 if (SWIG_arg_fail(1)) SWIG_fail;
17989 {
17990 arg2 = wxString_in_helper(obj1);
17991 if (arg2 == NULL) SWIG_fail;
17992 temp2 = true;
17993 }
17994 {
17995 arg3 = wxString_in_helper(obj2);
17996 if (arg3 == NULL) SWIG_fail;
17997 temp3 = true;
17998 }
17999 {
18000 PyThreadState* __tstate = wxPyBeginAllowThreads();
18001 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18002
18003 wxPyEndAllowThreads(__tstate);
18004 if (PyErr_Occurred()) SWIG_fail;
18005 }
18006 {
18007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18008 }
18009 {
18010 if (temp2)
18011 delete arg2;
18012 }
18013 {
18014 if (temp3)
18015 delete arg3;
18016 }
18017 return resultobj;
18018 fail:
18019 {
18020 if (temp2)
18021 delete arg2;
18022 }
18023 {
18024 if (temp3)
18025 delete arg3;
18026 }
18027 return NULL;
18028 }
18029
18030
18031 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj;
18033 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18034 wxString *arg2 = 0 ;
18035 wxString *arg3 = 0 ;
18036 bool result;
18037 bool temp2 = false ;
18038 bool temp3 = false ;
18039 PyObject * obj0 = 0 ;
18040 PyObject * obj1 = 0 ;
18041 PyObject * obj2 = 0 ;
18042 char *kwnames[] = {
18043 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18044 };
18045
18046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18048 if (SWIG_arg_fail(1)) SWIG_fail;
18049 {
18050 arg2 = wxString_in_helper(obj1);
18051 if (arg2 == NULL) SWIG_fail;
18052 temp2 = true;
18053 }
18054 {
18055 arg3 = wxString_in_helper(obj2);
18056 if (arg3 == NULL) SWIG_fail;
18057 temp3 = true;
18058 }
18059 {
18060 PyThreadState* __tstate = wxPyBeginAllowThreads();
18061 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18062
18063 wxPyEndAllowThreads(__tstate);
18064 if (PyErr_Occurred()) SWIG_fail;
18065 }
18066 {
18067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18068 }
18069 {
18070 if (temp2)
18071 delete arg2;
18072 }
18073 {
18074 if (temp3)
18075 delete arg3;
18076 }
18077 return resultobj;
18078 fail:
18079 {
18080 if (temp2)
18081 delete arg2;
18082 }
18083 {
18084 if (temp3)
18085 delete arg3;
18086 }
18087 return NULL;
18088 }
18089
18090
18091 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18092 PyObject *resultobj;
18093 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18094 wxString *arg2 = 0 ;
18095 bool arg3 = (bool) true ;
18096 bool result;
18097 bool temp2 = false ;
18098 PyObject * obj0 = 0 ;
18099 PyObject * obj1 = 0 ;
18100 PyObject * obj2 = 0 ;
18101 char *kwnames[] = {
18102 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18103 };
18104
18105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18107 if (SWIG_arg_fail(1)) SWIG_fail;
18108 {
18109 arg2 = wxString_in_helper(obj1);
18110 if (arg2 == NULL) SWIG_fail;
18111 temp2 = true;
18112 }
18113 if (obj2) {
18114 {
18115 arg3 = (bool)(SWIG_As_bool(obj2));
18116 if (SWIG_arg_fail(3)) SWIG_fail;
18117 }
18118 }
18119 {
18120 PyThreadState* __tstate = wxPyBeginAllowThreads();
18121 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18122
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 {
18127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18128 }
18129 {
18130 if (temp2)
18131 delete arg2;
18132 }
18133 return resultobj;
18134 fail:
18135 {
18136 if (temp2)
18137 delete arg2;
18138 }
18139 return NULL;
18140 }
18141
18142
18143 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18144 PyObject *resultobj;
18145 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18146 wxString *arg2 = 0 ;
18147 bool result;
18148 bool temp2 = false ;
18149 PyObject * obj0 = 0 ;
18150 PyObject * obj1 = 0 ;
18151 char *kwnames[] = {
18152 (char *) "self",(char *) "key", NULL
18153 };
18154
18155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18157 if (SWIG_arg_fail(1)) SWIG_fail;
18158 {
18159 arg2 = wxString_in_helper(obj1);
18160 if (arg2 == NULL) SWIG_fail;
18161 temp2 = true;
18162 }
18163 {
18164 PyThreadState* __tstate = wxPyBeginAllowThreads();
18165 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18166
18167 wxPyEndAllowThreads(__tstate);
18168 if (PyErr_Occurred()) SWIG_fail;
18169 }
18170 {
18171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18172 }
18173 {
18174 if (temp2)
18175 delete arg2;
18176 }
18177 return resultobj;
18178 fail:
18179 {
18180 if (temp2)
18181 delete arg2;
18182 }
18183 return NULL;
18184 }
18185
18186
18187 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18188 PyObject *resultobj;
18189 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18190 bool result;
18191 PyObject * obj0 = 0 ;
18192 char *kwnames[] = {
18193 (char *) "self", NULL
18194 };
18195
18196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18198 if (SWIG_arg_fail(1)) SWIG_fail;
18199 {
18200 PyThreadState* __tstate = wxPyBeginAllowThreads();
18201 result = (bool)(arg1)->DeleteAll();
18202
18203 wxPyEndAllowThreads(__tstate);
18204 if (PyErr_Occurred()) SWIG_fail;
18205 }
18206 {
18207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18208 }
18209 return resultobj;
18210 fail:
18211 return NULL;
18212 }
18213
18214
18215 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18216 PyObject *resultobj;
18217 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18218 bool arg2 = (bool) true ;
18219 PyObject * obj0 = 0 ;
18220 PyObject * obj1 = 0 ;
18221 char *kwnames[] = {
18222 (char *) "self",(char *) "doIt", NULL
18223 };
18224
18225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18227 if (SWIG_arg_fail(1)) SWIG_fail;
18228 if (obj1) {
18229 {
18230 arg2 = (bool)(SWIG_As_bool(obj1));
18231 if (SWIG_arg_fail(2)) SWIG_fail;
18232 }
18233 }
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 (arg1)->SetExpandEnvVars(arg2);
18237
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 Py_INCREF(Py_None); resultobj = Py_None;
18242 return resultobj;
18243 fail:
18244 return NULL;
18245 }
18246
18247
18248 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18249 PyObject *resultobj;
18250 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18251 bool result;
18252 PyObject * obj0 = 0 ;
18253 char *kwnames[] = {
18254 (char *) "self", NULL
18255 };
18256
18257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18259 if (SWIG_arg_fail(1)) SWIG_fail;
18260 {
18261 PyThreadState* __tstate = wxPyBeginAllowThreads();
18262 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18263
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 {
18268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18269 }
18270 return resultobj;
18271 fail:
18272 return NULL;
18273 }
18274
18275
18276 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18277 PyObject *resultobj;
18278 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18279 bool arg2 = (bool) true ;
18280 PyObject * obj0 = 0 ;
18281 PyObject * obj1 = 0 ;
18282 char *kwnames[] = {
18283 (char *) "self",(char *) "doIt", NULL
18284 };
18285
18286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18288 if (SWIG_arg_fail(1)) SWIG_fail;
18289 if (obj1) {
18290 {
18291 arg2 = (bool)(SWIG_As_bool(obj1));
18292 if (SWIG_arg_fail(2)) SWIG_fail;
18293 }
18294 }
18295 {
18296 PyThreadState* __tstate = wxPyBeginAllowThreads();
18297 (arg1)->SetRecordDefaults(arg2);
18298
18299 wxPyEndAllowThreads(__tstate);
18300 if (PyErr_Occurred()) SWIG_fail;
18301 }
18302 Py_INCREF(Py_None); resultobj = Py_None;
18303 return resultobj;
18304 fail:
18305 return NULL;
18306 }
18307
18308
18309 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18310 PyObject *resultobj;
18311 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18312 bool result;
18313 PyObject * obj0 = 0 ;
18314 char *kwnames[] = {
18315 (char *) "self", NULL
18316 };
18317
18318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18320 if (SWIG_arg_fail(1)) SWIG_fail;
18321 {
18322 PyThreadState* __tstate = wxPyBeginAllowThreads();
18323 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18324
18325 wxPyEndAllowThreads(__tstate);
18326 if (PyErr_Occurred()) SWIG_fail;
18327 }
18328 {
18329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18330 }
18331 return resultobj;
18332 fail:
18333 return NULL;
18334 }
18335
18336
18337 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18338 PyObject *resultobj;
18339 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18340 wxString *arg2 = 0 ;
18341 wxString result;
18342 bool temp2 = false ;
18343 PyObject * obj0 = 0 ;
18344 PyObject * obj1 = 0 ;
18345 char *kwnames[] = {
18346 (char *) "self",(char *) "str", NULL
18347 };
18348
18349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18351 if (SWIG_arg_fail(1)) SWIG_fail;
18352 {
18353 arg2 = wxString_in_helper(obj1);
18354 if (arg2 == NULL) SWIG_fail;
18355 temp2 = true;
18356 }
18357 {
18358 PyThreadState* __tstate = wxPyBeginAllowThreads();
18359 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18360
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 {
18365 #if wxUSE_UNICODE
18366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18367 #else
18368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18369 #endif
18370 }
18371 {
18372 if (temp2)
18373 delete arg2;
18374 }
18375 return resultobj;
18376 fail:
18377 {
18378 if (temp2)
18379 delete arg2;
18380 }
18381 return NULL;
18382 }
18383
18384
18385 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18386 PyObject *resultobj;
18387 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18388 wxString result;
18389 PyObject * obj0 = 0 ;
18390 char *kwnames[] = {
18391 (char *) "self", NULL
18392 };
18393
18394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18396 if (SWIG_arg_fail(1)) SWIG_fail;
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 result = ((wxConfigBase const *)arg1)->GetAppName();
18400
18401 wxPyEndAllowThreads(__tstate);
18402 if (PyErr_Occurred()) SWIG_fail;
18403 }
18404 {
18405 #if wxUSE_UNICODE
18406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18407 #else
18408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18409 #endif
18410 }
18411 return resultobj;
18412 fail:
18413 return NULL;
18414 }
18415
18416
18417 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18418 PyObject *resultobj;
18419 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18420 wxString result;
18421 PyObject * obj0 = 0 ;
18422 char *kwnames[] = {
18423 (char *) "self", NULL
18424 };
18425
18426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18428 if (SWIG_arg_fail(1)) SWIG_fail;
18429 {
18430 PyThreadState* __tstate = wxPyBeginAllowThreads();
18431 result = ((wxConfigBase const *)arg1)->GetVendorName();
18432
18433 wxPyEndAllowThreads(__tstate);
18434 if (PyErr_Occurred()) SWIG_fail;
18435 }
18436 {
18437 #if wxUSE_UNICODE
18438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18439 #else
18440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18441 #endif
18442 }
18443 return resultobj;
18444 fail:
18445 return NULL;
18446 }
18447
18448
18449 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18450 PyObject *resultobj;
18451 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18452 wxString *arg2 = 0 ;
18453 bool temp2 = false ;
18454 PyObject * obj0 = 0 ;
18455 PyObject * obj1 = 0 ;
18456 char *kwnames[] = {
18457 (char *) "self",(char *) "appName", NULL
18458 };
18459
18460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18462 if (SWIG_arg_fail(1)) SWIG_fail;
18463 {
18464 arg2 = wxString_in_helper(obj1);
18465 if (arg2 == NULL) SWIG_fail;
18466 temp2 = true;
18467 }
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 (arg1)->SetAppName((wxString const &)*arg2);
18471
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 Py_INCREF(Py_None); resultobj = Py_None;
18476 {
18477 if (temp2)
18478 delete arg2;
18479 }
18480 return resultobj;
18481 fail:
18482 {
18483 if (temp2)
18484 delete arg2;
18485 }
18486 return NULL;
18487 }
18488
18489
18490 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18491 PyObject *resultobj;
18492 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18493 wxString *arg2 = 0 ;
18494 bool temp2 = false ;
18495 PyObject * obj0 = 0 ;
18496 PyObject * obj1 = 0 ;
18497 char *kwnames[] = {
18498 (char *) "self",(char *) "vendorName", NULL
18499 };
18500
18501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18503 if (SWIG_arg_fail(1)) SWIG_fail;
18504 {
18505 arg2 = wxString_in_helper(obj1);
18506 if (arg2 == NULL) SWIG_fail;
18507 temp2 = true;
18508 }
18509 {
18510 PyThreadState* __tstate = wxPyBeginAllowThreads();
18511 (arg1)->SetVendorName((wxString const &)*arg2);
18512
18513 wxPyEndAllowThreads(__tstate);
18514 if (PyErr_Occurred()) SWIG_fail;
18515 }
18516 Py_INCREF(Py_None); resultobj = Py_None;
18517 {
18518 if (temp2)
18519 delete arg2;
18520 }
18521 return resultobj;
18522 fail:
18523 {
18524 if (temp2)
18525 delete arg2;
18526 }
18527 return NULL;
18528 }
18529
18530
18531 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18532 PyObject *resultobj;
18533 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18534 long arg2 ;
18535 PyObject * obj0 = 0 ;
18536 PyObject * obj1 = 0 ;
18537 char *kwnames[] = {
18538 (char *) "self",(char *) "style", NULL
18539 };
18540
18541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18543 if (SWIG_arg_fail(1)) SWIG_fail;
18544 {
18545 arg2 = (long)(SWIG_As_long(obj1));
18546 if (SWIG_arg_fail(2)) SWIG_fail;
18547 }
18548 {
18549 PyThreadState* __tstate = wxPyBeginAllowThreads();
18550 (arg1)->SetStyle(arg2);
18551
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 Py_INCREF(Py_None); resultobj = Py_None;
18556 return resultobj;
18557 fail:
18558 return NULL;
18559 }
18560
18561
18562 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18563 PyObject *resultobj;
18564 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18565 long result;
18566 PyObject * obj0 = 0 ;
18567 char *kwnames[] = {
18568 (char *) "self", NULL
18569 };
18570
18571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18573 if (SWIG_arg_fail(1)) SWIG_fail;
18574 {
18575 PyThreadState* __tstate = wxPyBeginAllowThreads();
18576 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18577
18578 wxPyEndAllowThreads(__tstate);
18579 if (PyErr_Occurred()) SWIG_fail;
18580 }
18581 {
18582 resultobj = SWIG_From_long((long)(result));
18583 }
18584 return resultobj;
18585 fail:
18586 return NULL;
18587 }
18588
18589
18590 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18591 PyObject *obj;
18592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18593 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18594 Py_INCREF(obj);
18595 return Py_BuildValue((char *)"");
18596 }
18597 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj;
18599 wxString const &arg1_defvalue = wxPyEmptyString ;
18600 wxString *arg1 = (wxString *) &arg1_defvalue ;
18601 wxString const &arg2_defvalue = wxPyEmptyString ;
18602 wxString *arg2 = (wxString *) &arg2_defvalue ;
18603 wxString const &arg3_defvalue = wxPyEmptyString ;
18604 wxString *arg3 = (wxString *) &arg3_defvalue ;
18605 wxString const &arg4_defvalue = wxPyEmptyString ;
18606 wxString *arg4 = (wxString *) &arg4_defvalue ;
18607 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18608 wxConfig *result;
18609 bool temp1 = false ;
18610 bool temp2 = false ;
18611 bool temp3 = false ;
18612 bool temp4 = false ;
18613 PyObject * obj0 = 0 ;
18614 PyObject * obj1 = 0 ;
18615 PyObject * obj2 = 0 ;
18616 PyObject * obj3 = 0 ;
18617 PyObject * obj4 = 0 ;
18618 char *kwnames[] = {
18619 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18620 };
18621
18622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18623 if (obj0) {
18624 {
18625 arg1 = wxString_in_helper(obj0);
18626 if (arg1 == NULL) SWIG_fail;
18627 temp1 = true;
18628 }
18629 }
18630 if (obj1) {
18631 {
18632 arg2 = wxString_in_helper(obj1);
18633 if (arg2 == NULL) SWIG_fail;
18634 temp2 = true;
18635 }
18636 }
18637 if (obj2) {
18638 {
18639 arg3 = wxString_in_helper(obj2);
18640 if (arg3 == NULL) SWIG_fail;
18641 temp3 = true;
18642 }
18643 }
18644 if (obj3) {
18645 {
18646 arg4 = wxString_in_helper(obj3);
18647 if (arg4 == NULL) SWIG_fail;
18648 temp4 = true;
18649 }
18650 }
18651 if (obj4) {
18652 {
18653 arg5 = (long)(SWIG_As_long(obj4));
18654 if (SWIG_arg_fail(5)) SWIG_fail;
18655 }
18656 }
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18660
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18665 {
18666 if (temp1)
18667 delete arg1;
18668 }
18669 {
18670 if (temp2)
18671 delete arg2;
18672 }
18673 {
18674 if (temp3)
18675 delete arg3;
18676 }
18677 {
18678 if (temp4)
18679 delete arg4;
18680 }
18681 return resultobj;
18682 fail:
18683 {
18684 if (temp1)
18685 delete arg1;
18686 }
18687 {
18688 if (temp2)
18689 delete arg2;
18690 }
18691 {
18692 if (temp3)
18693 delete arg3;
18694 }
18695 {
18696 if (temp4)
18697 delete arg4;
18698 }
18699 return NULL;
18700 }
18701
18702
18703 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18704 PyObject *resultobj;
18705 wxConfig *arg1 = (wxConfig *) 0 ;
18706 PyObject * obj0 = 0 ;
18707 char *kwnames[] = {
18708 (char *) "self", NULL
18709 };
18710
18711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18713 if (SWIG_arg_fail(1)) SWIG_fail;
18714 {
18715 PyThreadState* __tstate = wxPyBeginAllowThreads();
18716 delete arg1;
18717
18718 wxPyEndAllowThreads(__tstate);
18719 if (PyErr_Occurred()) SWIG_fail;
18720 }
18721 Py_INCREF(Py_None); resultobj = Py_None;
18722 return resultobj;
18723 fail:
18724 return NULL;
18725 }
18726
18727
18728 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18729 PyObject *obj;
18730 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18731 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18732 Py_INCREF(obj);
18733 return Py_BuildValue((char *)"");
18734 }
18735 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18736 PyObject *resultobj;
18737 wxString const &arg1_defvalue = wxPyEmptyString ;
18738 wxString *arg1 = (wxString *) &arg1_defvalue ;
18739 wxString const &arg2_defvalue = wxPyEmptyString ;
18740 wxString *arg2 = (wxString *) &arg2_defvalue ;
18741 wxString const &arg3_defvalue = wxPyEmptyString ;
18742 wxString *arg3 = (wxString *) &arg3_defvalue ;
18743 wxString const &arg4_defvalue = wxPyEmptyString ;
18744 wxString *arg4 = (wxString *) &arg4_defvalue ;
18745 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18746 wxFileConfig *result;
18747 bool temp1 = false ;
18748 bool temp2 = false ;
18749 bool temp3 = false ;
18750 bool temp4 = false ;
18751 PyObject * obj0 = 0 ;
18752 PyObject * obj1 = 0 ;
18753 PyObject * obj2 = 0 ;
18754 PyObject * obj3 = 0 ;
18755 PyObject * obj4 = 0 ;
18756 char *kwnames[] = {
18757 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18758 };
18759
18760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18761 if (obj0) {
18762 {
18763 arg1 = wxString_in_helper(obj0);
18764 if (arg1 == NULL) SWIG_fail;
18765 temp1 = true;
18766 }
18767 }
18768 if (obj1) {
18769 {
18770 arg2 = wxString_in_helper(obj1);
18771 if (arg2 == NULL) SWIG_fail;
18772 temp2 = true;
18773 }
18774 }
18775 if (obj2) {
18776 {
18777 arg3 = wxString_in_helper(obj2);
18778 if (arg3 == NULL) SWIG_fail;
18779 temp3 = true;
18780 }
18781 }
18782 if (obj3) {
18783 {
18784 arg4 = wxString_in_helper(obj3);
18785 if (arg4 == NULL) SWIG_fail;
18786 temp4 = true;
18787 }
18788 }
18789 if (obj4) {
18790 {
18791 arg5 = (long)(SWIG_As_long(obj4));
18792 if (SWIG_arg_fail(5)) SWIG_fail;
18793 }
18794 }
18795 {
18796 PyThreadState* __tstate = wxPyBeginAllowThreads();
18797 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18798
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18803 {
18804 if (temp1)
18805 delete arg1;
18806 }
18807 {
18808 if (temp2)
18809 delete arg2;
18810 }
18811 {
18812 if (temp3)
18813 delete arg3;
18814 }
18815 {
18816 if (temp4)
18817 delete arg4;
18818 }
18819 return resultobj;
18820 fail:
18821 {
18822 if (temp1)
18823 delete arg1;
18824 }
18825 {
18826 if (temp2)
18827 delete arg2;
18828 }
18829 {
18830 if (temp3)
18831 delete arg3;
18832 }
18833 {
18834 if (temp4)
18835 delete arg4;
18836 }
18837 return NULL;
18838 }
18839
18840
18841 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18842 PyObject *resultobj;
18843 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18844 PyObject * obj0 = 0 ;
18845 char *kwnames[] = {
18846 (char *) "self", NULL
18847 };
18848
18849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18851 if (SWIG_arg_fail(1)) SWIG_fail;
18852 {
18853 PyThreadState* __tstate = wxPyBeginAllowThreads();
18854 delete arg1;
18855
18856 wxPyEndAllowThreads(__tstate);
18857 if (PyErr_Occurred()) SWIG_fail;
18858 }
18859 Py_INCREF(Py_None); resultobj = Py_None;
18860 return resultobj;
18861 fail:
18862 return NULL;
18863 }
18864
18865
18866 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18867 PyObject *obj;
18868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18869 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18870 Py_INCREF(obj);
18871 return Py_BuildValue((char *)"");
18872 }
18873 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18874 PyObject *resultobj;
18875 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18876 wxString *arg2 = 0 ;
18877 wxConfigPathChanger *result;
18878 bool temp2 = false ;
18879 PyObject * obj0 = 0 ;
18880 PyObject * obj1 = 0 ;
18881 char *kwnames[] = {
18882 (char *) "config",(char *) "entry", NULL
18883 };
18884
18885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18887 if (SWIG_arg_fail(1)) SWIG_fail;
18888 {
18889 arg2 = wxString_in_helper(obj1);
18890 if (arg2 == NULL) SWIG_fail;
18891 temp2 = true;
18892 }
18893 {
18894 PyThreadState* __tstate = wxPyBeginAllowThreads();
18895 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18896
18897 wxPyEndAllowThreads(__tstate);
18898 if (PyErr_Occurred()) SWIG_fail;
18899 }
18900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18901 {
18902 if (temp2)
18903 delete arg2;
18904 }
18905 return resultobj;
18906 fail:
18907 {
18908 if (temp2)
18909 delete arg2;
18910 }
18911 return NULL;
18912 }
18913
18914
18915 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18916 PyObject *resultobj;
18917 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18918 PyObject * obj0 = 0 ;
18919 char *kwnames[] = {
18920 (char *) "self", NULL
18921 };
18922
18923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18925 if (SWIG_arg_fail(1)) SWIG_fail;
18926 {
18927 PyThreadState* __tstate = wxPyBeginAllowThreads();
18928 delete arg1;
18929
18930 wxPyEndAllowThreads(__tstate);
18931 if (PyErr_Occurred()) SWIG_fail;
18932 }
18933 Py_INCREF(Py_None); resultobj = Py_None;
18934 return resultobj;
18935 fail:
18936 return NULL;
18937 }
18938
18939
18940 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18941 PyObject *resultobj;
18942 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18943 wxString *result;
18944 PyObject * obj0 = 0 ;
18945 char *kwnames[] = {
18946 (char *) "self", NULL
18947 };
18948
18949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18951 if (SWIG_arg_fail(1)) SWIG_fail;
18952 {
18953 PyThreadState* __tstate = wxPyBeginAllowThreads();
18954 {
18955 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18956 result = (wxString *) &_result_ref;
18957 }
18958
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 {
18963 #if wxUSE_UNICODE
18964 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18965 #else
18966 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18967 #endif
18968 }
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18976 PyObject *obj;
18977 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18978 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18979 Py_INCREF(obj);
18980 return Py_BuildValue((char *)"");
18981 }
18982 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18983 PyObject *resultobj;
18984 wxString *arg1 = 0 ;
18985 wxString result;
18986 bool temp1 = false ;
18987 PyObject * obj0 = 0 ;
18988 char *kwnames[] = {
18989 (char *) "sz", NULL
18990 };
18991
18992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18993 {
18994 arg1 = wxString_in_helper(obj0);
18995 if (arg1 == NULL) SWIG_fail;
18996 temp1 = true;
18997 }
18998 {
18999 PyThreadState* __tstate = wxPyBeginAllowThreads();
19000 result = wxExpandEnvVars((wxString const &)*arg1);
19001
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 {
19006 #if wxUSE_UNICODE
19007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19008 #else
19009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19010 #endif
19011 }
19012 {
19013 if (temp1)
19014 delete arg1;
19015 }
19016 return resultobj;
19017 fail:
19018 {
19019 if (temp1)
19020 delete arg1;
19021 }
19022 return NULL;
19023 }
19024
19025
19026 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19027 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19028 return 1;
19029 }
19030
19031
19032 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19033 PyObject *pyobj;
19034
19035 {
19036 #if wxUSE_UNICODE
19037 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19038 #else
19039 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19040 #endif
19041 }
19042 return pyobj;
19043 }
19044
19045
19046 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19047 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19048 return 1;
19049 }
19050
19051
19052 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19053 PyObject *pyobj;
19054
19055 {
19056 #if wxUSE_UNICODE
19057 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19058 #else
19059 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19060 #endif
19061 }
19062 return pyobj;
19063 }
19064
19065
19066 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19067 PyObject *resultobj;
19068 wxDateTime::Country arg1 ;
19069 PyObject * obj0 = 0 ;
19070 char *kwnames[] = {
19071 (char *) "country", NULL
19072 };
19073
19074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19075 {
19076 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19077 if (SWIG_arg_fail(1)) SWIG_fail;
19078 }
19079 {
19080 PyThreadState* __tstate = wxPyBeginAllowThreads();
19081 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19082
19083 wxPyEndAllowThreads(__tstate);
19084 if (PyErr_Occurred()) SWIG_fail;
19085 }
19086 Py_INCREF(Py_None); resultobj = Py_None;
19087 return resultobj;
19088 fail:
19089 return NULL;
19090 }
19091
19092
19093 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19094 PyObject *resultobj;
19095 wxDateTime::Country result;
19096 char *kwnames[] = {
19097 NULL
19098 };
19099
19100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19101 {
19102 PyThreadState* __tstate = wxPyBeginAllowThreads();
19103 result = (wxDateTime::Country)wxDateTime::GetCountry();
19104
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 resultobj = SWIG_From_int((result));
19109 return resultobj;
19110 fail:
19111 return NULL;
19112 }
19113
19114
19115 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19116 PyObject *resultobj;
19117 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19118 bool result;
19119 PyObject * obj0 = 0 ;
19120 char *kwnames[] = {
19121 (char *) "country", NULL
19122 };
19123
19124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19125 if (obj0) {
19126 {
19127 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19128 if (SWIG_arg_fail(1)) SWIG_fail;
19129 }
19130 }
19131 {
19132 PyThreadState* __tstate = wxPyBeginAllowThreads();
19133 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19134
19135 wxPyEndAllowThreads(__tstate);
19136 if (PyErr_Occurred()) SWIG_fail;
19137 }
19138 {
19139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19140 }
19141 return resultobj;
19142 fail:
19143 return NULL;
19144 }
19145
19146
19147 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19148 PyObject *resultobj;
19149 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19150 int result;
19151 PyObject * obj0 = 0 ;
19152 char *kwnames[] = {
19153 (char *) "cal", NULL
19154 };
19155
19156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19157 if (obj0) {
19158 {
19159 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19160 if (SWIG_arg_fail(1)) SWIG_fail;
19161 }
19162 }
19163 {
19164 PyThreadState* __tstate = wxPyBeginAllowThreads();
19165 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19166
19167 wxPyEndAllowThreads(__tstate);
19168 if (PyErr_Occurred()) SWIG_fail;
19169 }
19170 {
19171 resultobj = SWIG_From_int((int)(result));
19172 }
19173 return resultobj;
19174 fail:
19175 return NULL;
19176 }
19177
19178
19179 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19180 PyObject *resultobj;
19181 int arg1 ;
19182 int result;
19183 PyObject * obj0 = 0 ;
19184 char *kwnames[] = {
19185 (char *) "year", NULL
19186 };
19187
19188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19189 {
19190 arg1 = (int)(SWIG_As_int(obj0));
19191 if (SWIG_arg_fail(1)) SWIG_fail;
19192 }
19193 {
19194 PyThreadState* __tstate = wxPyBeginAllowThreads();
19195 result = (int)wxDateTime::ConvertYearToBC(arg1);
19196
19197 wxPyEndAllowThreads(__tstate);
19198 if (PyErr_Occurred()) SWIG_fail;
19199 }
19200 {
19201 resultobj = SWIG_From_int((int)(result));
19202 }
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj;
19211 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19212 wxDateTime::Month result;
19213 PyObject * obj0 = 0 ;
19214 char *kwnames[] = {
19215 (char *) "cal", NULL
19216 };
19217
19218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19219 if (obj0) {
19220 {
19221 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19222 if (SWIG_arg_fail(1)) SWIG_fail;
19223 }
19224 }
19225 {
19226 PyThreadState* __tstate = wxPyBeginAllowThreads();
19227 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19228
19229 wxPyEndAllowThreads(__tstate);
19230 if (PyErr_Occurred()) SWIG_fail;
19231 }
19232 resultobj = SWIG_From_int((result));
19233 return resultobj;
19234 fail:
19235 return NULL;
19236 }
19237
19238
19239 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19240 PyObject *resultobj;
19241 int arg1 = (int) wxDateTime::Inv_Year ;
19242 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19243 bool result;
19244 PyObject * obj0 = 0 ;
19245 PyObject * obj1 = 0 ;
19246 char *kwnames[] = {
19247 (char *) "year",(char *) "cal", NULL
19248 };
19249
19250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19251 if (obj0) {
19252 {
19253 arg1 = (int)(SWIG_As_int(obj0));
19254 if (SWIG_arg_fail(1)) SWIG_fail;
19255 }
19256 }
19257 if (obj1) {
19258 {
19259 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19260 if (SWIG_arg_fail(2)) SWIG_fail;
19261 }
19262 }
19263 {
19264 PyThreadState* __tstate = wxPyBeginAllowThreads();
19265 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19266
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 {
19271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19272 }
19273 return resultobj;
19274 fail:
19275 return NULL;
19276 }
19277
19278
19279 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19280 PyObject *resultobj;
19281 int arg1 = (int) wxDateTime::Inv_Year ;
19282 int result;
19283 PyObject * obj0 = 0 ;
19284 char *kwnames[] = {
19285 (char *) "year", NULL
19286 };
19287
19288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19289 if (obj0) {
19290 {
19291 arg1 = (int)(SWIG_As_int(obj0));
19292 if (SWIG_arg_fail(1)) SWIG_fail;
19293 }
19294 }
19295 {
19296 PyThreadState* __tstate = wxPyBeginAllowThreads();
19297 result = (int)wxDateTime::GetCentury(arg1);
19298
19299 wxPyEndAllowThreads(__tstate);
19300 if (PyErr_Occurred()) SWIG_fail;
19301 }
19302 {
19303 resultobj = SWIG_From_int((int)(result));
19304 }
19305 return resultobj;
19306 fail:
19307 return NULL;
19308 }
19309
19310
19311 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19312 PyObject *resultobj;
19313 int arg1 ;
19314 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19315 int result;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char *kwnames[] = {
19319 (char *) "year",(char *) "cal", NULL
19320 };
19321
19322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19323 {
19324 arg1 = (int)(SWIG_As_int(obj0));
19325 if (SWIG_arg_fail(1)) SWIG_fail;
19326 }
19327 if (obj1) {
19328 {
19329 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19330 if (SWIG_arg_fail(2)) SWIG_fail;
19331 }
19332 }
19333 {
19334 PyThreadState* __tstate = wxPyBeginAllowThreads();
19335 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19336
19337 wxPyEndAllowThreads(__tstate);
19338 if (PyErr_Occurred()) SWIG_fail;
19339 }
19340 {
19341 resultobj = SWIG_From_int((int)(result));
19342 }
19343 return resultobj;
19344 fail:
19345 return NULL;
19346 }
19347
19348
19349 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19350 PyObject *resultobj;
19351 wxDateTime::Month arg1 ;
19352 int arg2 = (int) wxDateTime::Inv_Year ;
19353 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19354 int result;
19355 PyObject * obj0 = 0 ;
19356 PyObject * obj1 = 0 ;
19357 PyObject * obj2 = 0 ;
19358 char *kwnames[] = {
19359 (char *) "month",(char *) "year",(char *) "cal", NULL
19360 };
19361
19362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19363 {
19364 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19365 if (SWIG_arg_fail(1)) SWIG_fail;
19366 }
19367 if (obj1) {
19368 {
19369 arg2 = (int)(SWIG_As_int(obj1));
19370 if (SWIG_arg_fail(2)) SWIG_fail;
19371 }
19372 }
19373 if (obj2) {
19374 {
19375 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19376 if (SWIG_arg_fail(3)) SWIG_fail;
19377 }
19378 }
19379 {
19380 PyThreadState* __tstate = wxPyBeginAllowThreads();
19381 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19382
19383 wxPyEndAllowThreads(__tstate);
19384 if (PyErr_Occurred()) SWIG_fail;
19385 }
19386 {
19387 resultobj = SWIG_From_int((int)(result));
19388 }
19389 return resultobj;
19390 fail:
19391 return NULL;
19392 }
19393
19394
19395 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19396 PyObject *resultobj;
19397 wxDateTime::Month arg1 ;
19398 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19399 wxString result;
19400 PyObject * obj0 = 0 ;
19401 PyObject * obj1 = 0 ;
19402 char *kwnames[] = {
19403 (char *) "month",(char *) "flags", NULL
19404 };
19405
19406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19407 {
19408 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19409 if (SWIG_arg_fail(1)) SWIG_fail;
19410 }
19411 if (obj1) {
19412 {
19413 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19414 if (SWIG_arg_fail(2)) SWIG_fail;
19415 }
19416 }
19417 {
19418 PyThreadState* __tstate = wxPyBeginAllowThreads();
19419 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19420
19421 wxPyEndAllowThreads(__tstate);
19422 if (PyErr_Occurred()) SWIG_fail;
19423 }
19424 {
19425 #if wxUSE_UNICODE
19426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19427 #else
19428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19429 #endif
19430 }
19431 return resultobj;
19432 fail:
19433 return NULL;
19434 }
19435
19436
19437 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19438 PyObject *resultobj;
19439 wxDateTime::WeekDay arg1 ;
19440 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19441 wxString result;
19442 PyObject * obj0 = 0 ;
19443 PyObject * obj1 = 0 ;
19444 char *kwnames[] = {
19445 (char *) "weekday",(char *) "flags", NULL
19446 };
19447
19448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19449 {
19450 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19451 if (SWIG_arg_fail(1)) SWIG_fail;
19452 }
19453 if (obj1) {
19454 {
19455 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19456 if (SWIG_arg_fail(2)) SWIG_fail;
19457 }
19458 }
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19462
19463 wxPyEndAllowThreads(__tstate);
19464 if (PyErr_Occurred()) SWIG_fail;
19465 }
19466 {
19467 #if wxUSE_UNICODE
19468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19469 #else
19470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19471 #endif
19472 }
19473 return resultobj;
19474 fail:
19475 return NULL;
19476 }
19477
19478
19479 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19480 PyObject *resultobj;
19481 PyObject *result;
19482 char *kwnames[] = {
19483 NULL
19484 };
19485
19486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19487 {
19488 PyThreadState* __tstate = wxPyBeginAllowThreads();
19489 result = (PyObject *)DateTime_GetAmPmStrings();
19490
19491 wxPyEndAllowThreads(__tstate);
19492 if (PyErr_Occurred()) SWIG_fail;
19493 }
19494 resultobj = result;
19495 return resultobj;
19496 fail:
19497 return NULL;
19498 }
19499
19500
19501 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19502 PyObject *resultobj;
19503 int arg1 = (int) wxDateTime::Inv_Year ;
19504 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19505 bool result;
19506 PyObject * obj0 = 0 ;
19507 PyObject * obj1 = 0 ;
19508 char *kwnames[] = {
19509 (char *) "year",(char *) "country", NULL
19510 };
19511
19512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19513 if (obj0) {
19514 {
19515 arg1 = (int)(SWIG_As_int(obj0));
19516 if (SWIG_arg_fail(1)) SWIG_fail;
19517 }
19518 }
19519 if (obj1) {
19520 {
19521 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19522 if (SWIG_arg_fail(2)) SWIG_fail;
19523 }
19524 }
19525 {
19526 PyThreadState* __tstate = wxPyBeginAllowThreads();
19527 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19528
19529 wxPyEndAllowThreads(__tstate);
19530 if (PyErr_Occurred()) SWIG_fail;
19531 }
19532 {
19533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19534 }
19535 return resultobj;
19536 fail:
19537 return NULL;
19538 }
19539
19540
19541 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19542 PyObject *resultobj;
19543 int arg1 = (int) wxDateTime::Inv_Year ;
19544 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19545 wxDateTime result;
19546 PyObject * obj0 = 0 ;
19547 PyObject * obj1 = 0 ;
19548 char *kwnames[] = {
19549 (char *) "year",(char *) "country", NULL
19550 };
19551
19552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19553 if (obj0) {
19554 {
19555 arg1 = (int)(SWIG_As_int(obj0));
19556 if (SWIG_arg_fail(1)) SWIG_fail;
19557 }
19558 }
19559 if (obj1) {
19560 {
19561 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19562 if (SWIG_arg_fail(2)) SWIG_fail;
19563 }
19564 }
19565 {
19566 PyThreadState* __tstate = wxPyBeginAllowThreads();
19567 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19568
19569 wxPyEndAllowThreads(__tstate);
19570 if (PyErr_Occurred()) SWIG_fail;
19571 }
19572 {
19573 wxDateTime * resultptr;
19574 resultptr = new wxDateTime((wxDateTime &)(result));
19575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19576 }
19577 return resultobj;
19578 fail:
19579 return NULL;
19580 }
19581
19582
19583 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19584 PyObject *resultobj;
19585 int arg1 = (int) wxDateTime::Inv_Year ;
19586 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19587 wxDateTime result;
19588 PyObject * obj0 = 0 ;
19589 PyObject * obj1 = 0 ;
19590 char *kwnames[] = {
19591 (char *) "year",(char *) "country", NULL
19592 };
19593
19594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19595 if (obj0) {
19596 {
19597 arg1 = (int)(SWIG_As_int(obj0));
19598 if (SWIG_arg_fail(1)) SWIG_fail;
19599 }
19600 }
19601 if (obj1) {
19602 {
19603 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19604 if (SWIG_arg_fail(2)) SWIG_fail;
19605 }
19606 }
19607 {
19608 PyThreadState* __tstate = wxPyBeginAllowThreads();
19609 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19610
19611 wxPyEndAllowThreads(__tstate);
19612 if (PyErr_Occurred()) SWIG_fail;
19613 }
19614 {
19615 wxDateTime * resultptr;
19616 resultptr = new wxDateTime((wxDateTime &)(result));
19617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19618 }
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj;
19627 wxDateTime result;
19628 char *kwnames[] = {
19629 NULL
19630 };
19631
19632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19633 {
19634 PyThreadState* __tstate = wxPyBeginAllowThreads();
19635 result = wxDateTime::Now();
19636
19637 wxPyEndAllowThreads(__tstate);
19638 if (PyErr_Occurred()) SWIG_fail;
19639 }
19640 {
19641 wxDateTime * resultptr;
19642 resultptr = new wxDateTime((wxDateTime &)(result));
19643 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19644 }
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj;
19653 wxDateTime result;
19654 char *kwnames[] = {
19655 NULL
19656 };
19657
19658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19659 {
19660 PyThreadState* __tstate = wxPyBeginAllowThreads();
19661 result = wxDateTime::UNow();
19662
19663 wxPyEndAllowThreads(__tstate);
19664 if (PyErr_Occurred()) SWIG_fail;
19665 }
19666 {
19667 wxDateTime * resultptr;
19668 resultptr = new wxDateTime((wxDateTime &)(result));
19669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19670 }
19671 return resultobj;
19672 fail:
19673 return NULL;
19674 }
19675
19676
19677 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19678 PyObject *resultobj;
19679 wxDateTime result;
19680 char *kwnames[] = {
19681 NULL
19682 };
19683
19684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = wxDateTime::Today();
19688
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 {
19693 wxDateTime * resultptr;
19694 resultptr = new wxDateTime((wxDateTime &)(result));
19695 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19696 }
19697 return resultobj;
19698 fail:
19699 return NULL;
19700 }
19701
19702
19703 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19704 PyObject *resultobj;
19705 wxDateTime *result;
19706 char *kwnames[] = {
19707 NULL
19708 };
19709
19710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19711 {
19712 PyThreadState* __tstate = wxPyBeginAllowThreads();
19713 result = (wxDateTime *)new wxDateTime();
19714
19715 wxPyEndAllowThreads(__tstate);
19716 if (PyErr_Occurred()) SWIG_fail;
19717 }
19718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19719 return resultobj;
19720 fail:
19721 return NULL;
19722 }
19723
19724
19725 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19726 PyObject *resultobj;
19727 time_t arg1 ;
19728 wxDateTime *result;
19729 PyObject * obj0 = 0 ;
19730 char *kwnames[] = {
19731 (char *) "timet", NULL
19732 };
19733
19734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19735 {
19736 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19737 if (SWIG_arg_fail(1)) SWIG_fail;
19738 }
19739 {
19740 PyThreadState* __tstate = wxPyBeginAllowThreads();
19741 result = (wxDateTime *)new wxDateTime(arg1);
19742
19743 wxPyEndAllowThreads(__tstate);
19744 if (PyErr_Occurred()) SWIG_fail;
19745 }
19746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19747 return resultobj;
19748 fail:
19749 return NULL;
19750 }
19751
19752
19753 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj;
19755 double arg1 ;
19756 wxDateTime *result;
19757 PyObject * obj0 = 0 ;
19758 char *kwnames[] = {
19759 (char *) "jdn", NULL
19760 };
19761
19762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19763 {
19764 arg1 = (double)(SWIG_As_double(obj0));
19765 if (SWIG_arg_fail(1)) SWIG_fail;
19766 }
19767 {
19768 PyThreadState* __tstate = wxPyBeginAllowThreads();
19769 result = (wxDateTime *)new wxDateTime(arg1);
19770
19771 wxPyEndAllowThreads(__tstate);
19772 if (PyErr_Occurred()) SWIG_fail;
19773 }
19774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19775 return resultobj;
19776 fail:
19777 return NULL;
19778 }
19779
19780
19781 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19782 PyObject *resultobj;
19783 int arg1 ;
19784 int arg2 = (int) 0 ;
19785 int arg3 = (int) 0 ;
19786 int arg4 = (int) 0 ;
19787 wxDateTime *result;
19788 PyObject * obj0 = 0 ;
19789 PyObject * obj1 = 0 ;
19790 PyObject * obj2 = 0 ;
19791 PyObject * obj3 = 0 ;
19792 char *kwnames[] = {
19793 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19794 };
19795
19796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19797 {
19798 arg1 = (int)(SWIG_As_int(obj0));
19799 if (SWIG_arg_fail(1)) SWIG_fail;
19800 }
19801 if (obj1) {
19802 {
19803 arg2 = (int)(SWIG_As_int(obj1));
19804 if (SWIG_arg_fail(2)) SWIG_fail;
19805 }
19806 }
19807 if (obj2) {
19808 {
19809 arg3 = (int)(SWIG_As_int(obj2));
19810 if (SWIG_arg_fail(3)) SWIG_fail;
19811 }
19812 }
19813 if (obj3) {
19814 {
19815 arg4 = (int)(SWIG_As_int(obj3));
19816 if (SWIG_arg_fail(4)) SWIG_fail;
19817 }
19818 }
19819 {
19820 PyThreadState* __tstate = wxPyBeginAllowThreads();
19821 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19822
19823 wxPyEndAllowThreads(__tstate);
19824 if (PyErr_Occurred()) SWIG_fail;
19825 }
19826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19827 return resultobj;
19828 fail:
19829 return NULL;
19830 }
19831
19832
19833 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19834 PyObject *resultobj;
19835 int arg1 ;
19836 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19837 int arg3 = (int) wxDateTime::Inv_Year ;
19838 int arg4 = (int) 0 ;
19839 int arg5 = (int) 0 ;
19840 int arg6 = (int) 0 ;
19841 int arg7 = (int) 0 ;
19842 wxDateTime *result;
19843 PyObject * obj0 = 0 ;
19844 PyObject * obj1 = 0 ;
19845 PyObject * obj2 = 0 ;
19846 PyObject * obj3 = 0 ;
19847 PyObject * obj4 = 0 ;
19848 PyObject * obj5 = 0 ;
19849 PyObject * obj6 = 0 ;
19850 char *kwnames[] = {
19851 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19852 };
19853
19854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19855 {
19856 arg1 = (int)(SWIG_As_int(obj0));
19857 if (SWIG_arg_fail(1)) SWIG_fail;
19858 }
19859 if (obj1) {
19860 {
19861 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19862 if (SWIG_arg_fail(2)) SWIG_fail;
19863 }
19864 }
19865 if (obj2) {
19866 {
19867 arg3 = (int)(SWIG_As_int(obj2));
19868 if (SWIG_arg_fail(3)) SWIG_fail;
19869 }
19870 }
19871 if (obj3) {
19872 {
19873 arg4 = (int)(SWIG_As_int(obj3));
19874 if (SWIG_arg_fail(4)) SWIG_fail;
19875 }
19876 }
19877 if (obj4) {
19878 {
19879 arg5 = (int)(SWIG_As_int(obj4));
19880 if (SWIG_arg_fail(5)) SWIG_fail;
19881 }
19882 }
19883 if (obj5) {
19884 {
19885 arg6 = (int)(SWIG_As_int(obj5));
19886 if (SWIG_arg_fail(6)) SWIG_fail;
19887 }
19888 }
19889 if (obj6) {
19890 {
19891 arg7 = (int)(SWIG_As_int(obj6));
19892 if (SWIG_arg_fail(7)) SWIG_fail;
19893 }
19894 }
19895 {
19896 PyThreadState* __tstate = wxPyBeginAllowThreads();
19897 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19898
19899 wxPyEndAllowThreads(__tstate);
19900 if (PyErr_Occurred()) SWIG_fail;
19901 }
19902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19903 return resultobj;
19904 fail:
19905 return NULL;
19906 }
19907
19908
19909 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19910 PyObject *resultobj;
19911 wxDateTime *arg1 = (wxDateTime *) 0 ;
19912 PyObject * obj0 = 0 ;
19913 char *kwnames[] = {
19914 (char *) "self", NULL
19915 };
19916
19917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19919 if (SWIG_arg_fail(1)) SWIG_fail;
19920 {
19921 PyThreadState* __tstate = wxPyBeginAllowThreads();
19922 delete arg1;
19923
19924 wxPyEndAllowThreads(__tstate);
19925 if (PyErr_Occurred()) SWIG_fail;
19926 }
19927 Py_INCREF(Py_None); resultobj = Py_None;
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj;
19936 wxDateTime *arg1 = (wxDateTime *) 0 ;
19937 wxDateTime *result;
19938 PyObject * obj0 = 0 ;
19939 char *kwnames[] = {
19940 (char *) "self", NULL
19941 };
19942
19943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19945 if (SWIG_arg_fail(1)) SWIG_fail;
19946 {
19947 PyThreadState* __tstate = wxPyBeginAllowThreads();
19948 {
19949 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19950 result = (wxDateTime *) &_result_ref;
19951 }
19952
19953 wxPyEndAllowThreads(__tstate);
19954 if (PyErr_Occurred()) SWIG_fail;
19955 }
19956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19957 return resultobj;
19958 fail:
19959 return NULL;
19960 }
19961
19962
19963 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19964 PyObject *resultobj;
19965 wxDateTime *arg1 = (wxDateTime *) 0 ;
19966 time_t arg2 ;
19967 wxDateTime *result;
19968 PyObject * obj0 = 0 ;
19969 PyObject * obj1 = 0 ;
19970 char *kwnames[] = {
19971 (char *) "self",(char *) "timet", NULL
19972 };
19973
19974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19976 if (SWIG_arg_fail(1)) SWIG_fail;
19977 {
19978 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19979 if (SWIG_arg_fail(2)) SWIG_fail;
19980 }
19981 {
19982 PyThreadState* __tstate = wxPyBeginAllowThreads();
19983 {
19984 wxDateTime &_result_ref = (arg1)->Set(arg2);
19985 result = (wxDateTime *) &_result_ref;
19986 }
19987
19988 wxPyEndAllowThreads(__tstate);
19989 if (PyErr_Occurred()) SWIG_fail;
19990 }
19991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19992 return resultobj;
19993 fail:
19994 return NULL;
19995 }
19996
19997
19998 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj;
20000 wxDateTime *arg1 = (wxDateTime *) 0 ;
20001 double arg2 ;
20002 wxDateTime *result;
20003 PyObject * obj0 = 0 ;
20004 PyObject * obj1 = 0 ;
20005 char *kwnames[] = {
20006 (char *) "self",(char *) "jdn", NULL
20007 };
20008
20009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20011 if (SWIG_arg_fail(1)) SWIG_fail;
20012 {
20013 arg2 = (double)(SWIG_As_double(obj1));
20014 if (SWIG_arg_fail(2)) SWIG_fail;
20015 }
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 {
20019 wxDateTime &_result_ref = (arg1)->Set(arg2);
20020 result = (wxDateTime *) &_result_ref;
20021 }
20022
20023 wxPyEndAllowThreads(__tstate);
20024 if (PyErr_Occurred()) SWIG_fail;
20025 }
20026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20027 return resultobj;
20028 fail:
20029 return NULL;
20030 }
20031
20032
20033 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20034 PyObject *resultobj;
20035 wxDateTime *arg1 = (wxDateTime *) 0 ;
20036 int arg2 ;
20037 int arg3 = (int) 0 ;
20038 int arg4 = (int) 0 ;
20039 int arg5 = (int) 0 ;
20040 wxDateTime *result;
20041 PyObject * obj0 = 0 ;
20042 PyObject * obj1 = 0 ;
20043 PyObject * obj2 = 0 ;
20044 PyObject * obj3 = 0 ;
20045 PyObject * obj4 = 0 ;
20046 char *kwnames[] = {
20047 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20048 };
20049
20050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20052 if (SWIG_arg_fail(1)) SWIG_fail;
20053 {
20054 arg2 = (int)(SWIG_As_int(obj1));
20055 if (SWIG_arg_fail(2)) SWIG_fail;
20056 }
20057 if (obj2) {
20058 {
20059 arg3 = (int)(SWIG_As_int(obj2));
20060 if (SWIG_arg_fail(3)) SWIG_fail;
20061 }
20062 }
20063 if (obj3) {
20064 {
20065 arg4 = (int)(SWIG_As_int(obj3));
20066 if (SWIG_arg_fail(4)) SWIG_fail;
20067 }
20068 }
20069 if (obj4) {
20070 {
20071 arg5 = (int)(SWIG_As_int(obj4));
20072 if (SWIG_arg_fail(5)) SWIG_fail;
20073 }
20074 }
20075 {
20076 PyThreadState* __tstate = wxPyBeginAllowThreads();
20077 {
20078 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20079 result = (wxDateTime *) &_result_ref;
20080 }
20081
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20086 return resultobj;
20087 fail:
20088 return NULL;
20089 }
20090
20091
20092 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20093 PyObject *resultobj;
20094 wxDateTime *arg1 = (wxDateTime *) 0 ;
20095 int arg2 ;
20096 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20097 int arg4 = (int) wxDateTime::Inv_Year ;
20098 int arg5 = (int) 0 ;
20099 int arg6 = (int) 0 ;
20100 int arg7 = (int) 0 ;
20101 int arg8 = (int) 0 ;
20102 wxDateTime *result;
20103 PyObject * obj0 = 0 ;
20104 PyObject * obj1 = 0 ;
20105 PyObject * obj2 = 0 ;
20106 PyObject * obj3 = 0 ;
20107 PyObject * obj4 = 0 ;
20108 PyObject * obj5 = 0 ;
20109 PyObject * obj6 = 0 ;
20110 PyObject * obj7 = 0 ;
20111 char *kwnames[] = {
20112 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20113 };
20114
20115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20117 if (SWIG_arg_fail(1)) SWIG_fail;
20118 {
20119 arg2 = (int)(SWIG_As_int(obj1));
20120 if (SWIG_arg_fail(2)) SWIG_fail;
20121 }
20122 if (obj2) {
20123 {
20124 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20125 if (SWIG_arg_fail(3)) SWIG_fail;
20126 }
20127 }
20128 if (obj3) {
20129 {
20130 arg4 = (int)(SWIG_As_int(obj3));
20131 if (SWIG_arg_fail(4)) SWIG_fail;
20132 }
20133 }
20134 if (obj4) {
20135 {
20136 arg5 = (int)(SWIG_As_int(obj4));
20137 if (SWIG_arg_fail(5)) SWIG_fail;
20138 }
20139 }
20140 if (obj5) {
20141 {
20142 arg6 = (int)(SWIG_As_int(obj5));
20143 if (SWIG_arg_fail(6)) SWIG_fail;
20144 }
20145 }
20146 if (obj6) {
20147 {
20148 arg7 = (int)(SWIG_As_int(obj6));
20149 if (SWIG_arg_fail(7)) SWIG_fail;
20150 }
20151 }
20152 if (obj7) {
20153 {
20154 arg8 = (int)(SWIG_As_int(obj7));
20155 if (SWIG_arg_fail(8)) SWIG_fail;
20156 }
20157 }
20158 {
20159 PyThreadState* __tstate = wxPyBeginAllowThreads();
20160 {
20161 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20162 result = (wxDateTime *) &_result_ref;
20163 }
20164
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20176 PyObject *resultobj;
20177 wxDateTime *arg1 = (wxDateTime *) 0 ;
20178 wxDateTime *result;
20179 PyObject * obj0 = 0 ;
20180 char *kwnames[] = {
20181 (char *) "self", NULL
20182 };
20183
20184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20186 if (SWIG_arg_fail(1)) SWIG_fail;
20187 {
20188 PyThreadState* __tstate = wxPyBeginAllowThreads();
20189 {
20190 wxDateTime &_result_ref = (arg1)->ResetTime();
20191 result = (wxDateTime *) &_result_ref;
20192 }
20193
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj;
20206 wxDateTime *arg1 = (wxDateTime *) 0 ;
20207 int arg2 ;
20208 wxDateTime *result;
20209 PyObject * obj0 = 0 ;
20210 PyObject * obj1 = 0 ;
20211 char *kwnames[] = {
20212 (char *) "self",(char *) "year", NULL
20213 };
20214
20215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20217 if (SWIG_arg_fail(1)) SWIG_fail;
20218 {
20219 arg2 = (int)(SWIG_As_int(obj1));
20220 if (SWIG_arg_fail(2)) SWIG_fail;
20221 }
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 {
20225 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20226 result = (wxDateTime *) &_result_ref;
20227 }
20228
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20240 PyObject *resultobj;
20241 wxDateTime *arg1 = (wxDateTime *) 0 ;
20242 wxDateTime::Month arg2 ;
20243 wxDateTime *result;
20244 PyObject * obj0 = 0 ;
20245 PyObject * obj1 = 0 ;
20246 char *kwnames[] = {
20247 (char *) "self",(char *) "month", NULL
20248 };
20249
20250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20252 if (SWIG_arg_fail(1)) SWIG_fail;
20253 {
20254 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20255 if (SWIG_arg_fail(2)) SWIG_fail;
20256 }
20257 {
20258 PyThreadState* __tstate = wxPyBeginAllowThreads();
20259 {
20260 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20261 result = (wxDateTime *) &_result_ref;
20262 }
20263
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20268 return resultobj;
20269 fail:
20270 return NULL;
20271 }
20272
20273
20274 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20275 PyObject *resultobj;
20276 wxDateTime *arg1 = (wxDateTime *) 0 ;
20277 int arg2 ;
20278 wxDateTime *result;
20279 PyObject * obj0 = 0 ;
20280 PyObject * obj1 = 0 ;
20281 char *kwnames[] = {
20282 (char *) "self",(char *) "day", NULL
20283 };
20284
20285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20287 if (SWIG_arg_fail(1)) SWIG_fail;
20288 {
20289 arg2 = (int)(SWIG_As_int(obj1));
20290 if (SWIG_arg_fail(2)) SWIG_fail;
20291 }
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 {
20295 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20296 result = (wxDateTime *) &_result_ref;
20297 }
20298
20299 wxPyEndAllowThreads(__tstate);
20300 if (PyErr_Occurred()) SWIG_fail;
20301 }
20302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20310 PyObject *resultobj;
20311 wxDateTime *arg1 = (wxDateTime *) 0 ;
20312 int arg2 ;
20313 wxDateTime *result;
20314 PyObject * obj0 = 0 ;
20315 PyObject * obj1 = 0 ;
20316 char *kwnames[] = {
20317 (char *) "self",(char *) "hour", NULL
20318 };
20319
20320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20322 if (SWIG_arg_fail(1)) SWIG_fail;
20323 {
20324 arg2 = (int)(SWIG_As_int(obj1));
20325 if (SWIG_arg_fail(2)) SWIG_fail;
20326 }
20327 {
20328 PyThreadState* __tstate = wxPyBeginAllowThreads();
20329 {
20330 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20331 result = (wxDateTime *) &_result_ref;
20332 }
20333
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20345 PyObject *resultobj;
20346 wxDateTime *arg1 = (wxDateTime *) 0 ;
20347 int arg2 ;
20348 wxDateTime *result;
20349 PyObject * obj0 = 0 ;
20350 PyObject * obj1 = 0 ;
20351 char *kwnames[] = {
20352 (char *) "self",(char *) "minute", NULL
20353 };
20354
20355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20357 if (SWIG_arg_fail(1)) SWIG_fail;
20358 {
20359 arg2 = (int)(SWIG_As_int(obj1));
20360 if (SWIG_arg_fail(2)) SWIG_fail;
20361 }
20362 {
20363 PyThreadState* __tstate = wxPyBeginAllowThreads();
20364 {
20365 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20366 result = (wxDateTime *) &_result_ref;
20367 }
20368
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20373 return resultobj;
20374 fail:
20375 return NULL;
20376 }
20377
20378
20379 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20380 PyObject *resultobj;
20381 wxDateTime *arg1 = (wxDateTime *) 0 ;
20382 int arg2 ;
20383 wxDateTime *result;
20384 PyObject * obj0 = 0 ;
20385 PyObject * obj1 = 0 ;
20386 char *kwnames[] = {
20387 (char *) "self",(char *) "second", NULL
20388 };
20389
20390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20392 if (SWIG_arg_fail(1)) SWIG_fail;
20393 {
20394 arg2 = (int)(SWIG_As_int(obj1));
20395 if (SWIG_arg_fail(2)) SWIG_fail;
20396 }
20397 {
20398 PyThreadState* __tstate = wxPyBeginAllowThreads();
20399 {
20400 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20401 result = (wxDateTime *) &_result_ref;
20402 }
20403
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20415 PyObject *resultobj;
20416 wxDateTime *arg1 = (wxDateTime *) 0 ;
20417 int arg2 ;
20418 wxDateTime *result;
20419 PyObject * obj0 = 0 ;
20420 PyObject * obj1 = 0 ;
20421 char *kwnames[] = {
20422 (char *) "self",(char *) "millisecond", NULL
20423 };
20424
20425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20427 if (SWIG_arg_fail(1)) SWIG_fail;
20428 {
20429 arg2 = (int)(SWIG_As_int(obj1));
20430 if (SWIG_arg_fail(2)) SWIG_fail;
20431 }
20432 {
20433 PyThreadState* __tstate = wxPyBeginAllowThreads();
20434 {
20435 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20436 result = (wxDateTime *) &_result_ref;
20437 }
20438
20439 wxPyEndAllowThreads(__tstate);
20440 if (PyErr_Occurred()) SWIG_fail;
20441 }
20442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20443 return resultobj;
20444 fail:
20445 return NULL;
20446 }
20447
20448
20449 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20450 PyObject *resultobj;
20451 wxDateTime *arg1 = (wxDateTime *) 0 ;
20452 wxDateTime::WeekDay arg2 ;
20453 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20454 wxDateTime *result;
20455 PyObject * obj0 = 0 ;
20456 PyObject * obj1 = 0 ;
20457 PyObject * obj2 = 0 ;
20458 char *kwnames[] = {
20459 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20460 };
20461
20462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20464 if (SWIG_arg_fail(1)) SWIG_fail;
20465 {
20466 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20467 if (SWIG_arg_fail(2)) SWIG_fail;
20468 }
20469 if (obj2) {
20470 {
20471 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20472 if (SWIG_arg_fail(3)) SWIG_fail;
20473 }
20474 }
20475 {
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 {
20478 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20479 result = (wxDateTime *) &_result_ref;
20480 }
20481
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20493 PyObject *resultobj;
20494 wxDateTime *arg1 = (wxDateTime *) 0 ;
20495 wxDateTime::WeekDay arg2 ;
20496 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20497 wxDateTime result;
20498 PyObject * obj0 = 0 ;
20499 PyObject * obj1 = 0 ;
20500 PyObject * obj2 = 0 ;
20501 char *kwnames[] = {
20502 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20503 };
20504
20505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20507 if (SWIG_arg_fail(1)) SWIG_fail;
20508 {
20509 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20510 if (SWIG_arg_fail(2)) SWIG_fail;
20511 }
20512 if (obj2) {
20513 {
20514 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20515 if (SWIG_arg_fail(3)) SWIG_fail;
20516 }
20517 }
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20521
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 {
20526 wxDateTime * resultptr;
20527 resultptr = new wxDateTime((wxDateTime &)(result));
20528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20529 }
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20537 PyObject *resultobj;
20538 wxDateTime *arg1 = (wxDateTime *) 0 ;
20539 wxDateTime::WeekDay arg2 ;
20540 wxDateTime *result;
20541 PyObject * obj0 = 0 ;
20542 PyObject * obj1 = 0 ;
20543 char *kwnames[] = {
20544 (char *) "self",(char *) "weekday", NULL
20545 };
20546
20547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20549 if (SWIG_arg_fail(1)) SWIG_fail;
20550 {
20551 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20552 if (SWIG_arg_fail(2)) SWIG_fail;
20553 }
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 {
20557 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20558 result = (wxDateTime *) &_result_ref;
20559 }
20560
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20572 PyObject *resultobj;
20573 wxDateTime *arg1 = (wxDateTime *) 0 ;
20574 wxDateTime::WeekDay arg2 ;
20575 wxDateTime result;
20576 PyObject * obj0 = 0 ;
20577 PyObject * obj1 = 0 ;
20578 char *kwnames[] = {
20579 (char *) "self",(char *) "weekday", NULL
20580 };
20581
20582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20584 if (SWIG_arg_fail(1)) SWIG_fail;
20585 {
20586 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20587 if (SWIG_arg_fail(2)) SWIG_fail;
20588 }
20589 {
20590 PyThreadState* __tstate = wxPyBeginAllowThreads();
20591 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20592
20593 wxPyEndAllowThreads(__tstate);
20594 if (PyErr_Occurred()) SWIG_fail;
20595 }
20596 {
20597 wxDateTime * resultptr;
20598 resultptr = new wxDateTime((wxDateTime &)(result));
20599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20600 }
20601 return resultobj;
20602 fail:
20603 return NULL;
20604 }
20605
20606
20607 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20608 PyObject *resultobj;
20609 wxDateTime *arg1 = (wxDateTime *) 0 ;
20610 wxDateTime::WeekDay arg2 ;
20611 wxDateTime *result;
20612 PyObject * obj0 = 0 ;
20613 PyObject * obj1 = 0 ;
20614 char *kwnames[] = {
20615 (char *) "self",(char *) "weekday", NULL
20616 };
20617
20618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20620 if (SWIG_arg_fail(1)) SWIG_fail;
20621 {
20622 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20623 if (SWIG_arg_fail(2)) SWIG_fail;
20624 }
20625 {
20626 PyThreadState* __tstate = wxPyBeginAllowThreads();
20627 {
20628 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20629 result = (wxDateTime *) &_result_ref;
20630 }
20631
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20636 return resultobj;
20637 fail:
20638 return NULL;
20639 }
20640
20641
20642 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20643 PyObject *resultobj;
20644 wxDateTime *arg1 = (wxDateTime *) 0 ;
20645 wxDateTime::WeekDay arg2 ;
20646 wxDateTime result;
20647 PyObject * obj0 = 0 ;
20648 PyObject * obj1 = 0 ;
20649 char *kwnames[] = {
20650 (char *) "self",(char *) "weekday", NULL
20651 };
20652
20653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20655 if (SWIG_arg_fail(1)) SWIG_fail;
20656 {
20657 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20658 if (SWIG_arg_fail(2)) SWIG_fail;
20659 }
20660 {
20661 PyThreadState* __tstate = wxPyBeginAllowThreads();
20662 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20663
20664 wxPyEndAllowThreads(__tstate);
20665 if (PyErr_Occurred()) SWIG_fail;
20666 }
20667 {
20668 wxDateTime * resultptr;
20669 resultptr = new wxDateTime((wxDateTime &)(result));
20670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20671 }
20672 return resultobj;
20673 fail:
20674 return NULL;
20675 }
20676
20677
20678 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20679 PyObject *resultobj;
20680 wxDateTime *arg1 = (wxDateTime *) 0 ;
20681 wxDateTime::WeekDay arg2 ;
20682 int arg3 = (int) 1 ;
20683 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20684 int arg5 = (int) wxDateTime::Inv_Year ;
20685 bool result;
20686 PyObject * obj0 = 0 ;
20687 PyObject * obj1 = 0 ;
20688 PyObject * obj2 = 0 ;
20689 PyObject * obj3 = 0 ;
20690 PyObject * obj4 = 0 ;
20691 char *kwnames[] = {
20692 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20693 };
20694
20695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20697 if (SWIG_arg_fail(1)) SWIG_fail;
20698 {
20699 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20700 if (SWIG_arg_fail(2)) SWIG_fail;
20701 }
20702 if (obj2) {
20703 {
20704 arg3 = (int)(SWIG_As_int(obj2));
20705 if (SWIG_arg_fail(3)) SWIG_fail;
20706 }
20707 }
20708 if (obj3) {
20709 {
20710 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20711 if (SWIG_arg_fail(4)) SWIG_fail;
20712 }
20713 }
20714 if (obj4) {
20715 {
20716 arg5 = (int)(SWIG_As_int(obj4));
20717 if (SWIG_arg_fail(5)) SWIG_fail;
20718 }
20719 }
20720 {
20721 PyThreadState* __tstate = wxPyBeginAllowThreads();
20722 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20723
20724 wxPyEndAllowThreads(__tstate);
20725 if (PyErr_Occurred()) SWIG_fail;
20726 }
20727 {
20728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20729 }
20730 return resultobj;
20731 fail:
20732 return NULL;
20733 }
20734
20735
20736 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20737 PyObject *resultobj;
20738 wxDateTime *arg1 = (wxDateTime *) 0 ;
20739 wxDateTime::WeekDay arg2 ;
20740 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20741 int arg4 = (int) wxDateTime::Inv_Year ;
20742 bool result;
20743 PyObject * obj0 = 0 ;
20744 PyObject * obj1 = 0 ;
20745 PyObject * obj2 = 0 ;
20746 PyObject * obj3 = 0 ;
20747 char *kwnames[] = {
20748 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20749 };
20750
20751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20753 if (SWIG_arg_fail(1)) SWIG_fail;
20754 {
20755 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20756 if (SWIG_arg_fail(2)) SWIG_fail;
20757 }
20758 if (obj2) {
20759 {
20760 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20761 if (SWIG_arg_fail(3)) SWIG_fail;
20762 }
20763 }
20764 if (obj3) {
20765 {
20766 arg4 = (int)(SWIG_As_int(obj3));
20767 if (SWIG_arg_fail(4)) SWIG_fail;
20768 }
20769 }
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20773
20774 wxPyEndAllowThreads(__tstate);
20775 if (PyErr_Occurred()) SWIG_fail;
20776 }
20777 {
20778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20779 }
20780 return resultobj;
20781 fail:
20782 return NULL;
20783 }
20784
20785
20786 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20787 PyObject *resultobj;
20788 wxDateTime *arg1 = (wxDateTime *) 0 ;
20789 wxDateTime::WeekDay arg2 ;
20790 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20791 int arg4 = (int) wxDateTime::Inv_Year ;
20792 wxDateTime result;
20793 PyObject * obj0 = 0 ;
20794 PyObject * obj1 = 0 ;
20795 PyObject * obj2 = 0 ;
20796 PyObject * obj3 = 0 ;
20797 char *kwnames[] = {
20798 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20799 };
20800
20801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20803 if (SWIG_arg_fail(1)) SWIG_fail;
20804 {
20805 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20806 if (SWIG_arg_fail(2)) SWIG_fail;
20807 }
20808 if (obj2) {
20809 {
20810 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20811 if (SWIG_arg_fail(3)) SWIG_fail;
20812 }
20813 }
20814 if (obj3) {
20815 {
20816 arg4 = (int)(SWIG_As_int(obj3));
20817 if (SWIG_arg_fail(4)) SWIG_fail;
20818 }
20819 }
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20823
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 {
20828 wxDateTime * resultptr;
20829 resultptr = new wxDateTime((wxDateTime &)(result));
20830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20831 }
20832 return resultobj;
20833 fail:
20834 return NULL;
20835 }
20836
20837
20838 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20839 PyObject *resultobj;
20840 wxDateTime *arg1 = (wxDateTime *) 0 ;
20841 int arg2 ;
20842 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20843 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20844 bool result;
20845 PyObject * obj0 = 0 ;
20846 PyObject * obj1 = 0 ;
20847 PyObject * obj2 = 0 ;
20848 PyObject * obj3 = 0 ;
20849 char *kwnames[] = {
20850 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20851 };
20852
20853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20855 if (SWIG_arg_fail(1)) SWIG_fail;
20856 {
20857 arg2 = (int)(SWIG_As_int(obj1));
20858 if (SWIG_arg_fail(2)) SWIG_fail;
20859 }
20860 if (obj2) {
20861 {
20862 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20863 if (SWIG_arg_fail(3)) SWIG_fail;
20864 }
20865 }
20866 if (obj3) {
20867 {
20868 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20869 if (SWIG_arg_fail(4)) SWIG_fail;
20870 }
20871 }
20872 {
20873 PyThreadState* __tstate = wxPyBeginAllowThreads();
20874 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20875
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 {
20880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20881 }
20882 return resultobj;
20883 fail:
20884 return NULL;
20885 }
20886
20887
20888 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20889 PyObject *resultobj;
20890 wxDateTime *arg1 = (wxDateTime *) 0 ;
20891 int arg2 ;
20892 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20893 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20894 wxDateTime result;
20895 PyObject * obj0 = 0 ;
20896 PyObject * obj1 = 0 ;
20897 PyObject * obj2 = 0 ;
20898 PyObject * obj3 = 0 ;
20899 char *kwnames[] = {
20900 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20901 };
20902
20903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20905 if (SWIG_arg_fail(1)) SWIG_fail;
20906 {
20907 arg2 = (int)(SWIG_As_int(obj1));
20908 if (SWIG_arg_fail(2)) SWIG_fail;
20909 }
20910 if (obj2) {
20911 {
20912 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20913 if (SWIG_arg_fail(3)) SWIG_fail;
20914 }
20915 }
20916 if (obj3) {
20917 {
20918 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20919 if (SWIG_arg_fail(4)) SWIG_fail;
20920 }
20921 }
20922 {
20923 PyThreadState* __tstate = wxPyBeginAllowThreads();
20924 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20925
20926 wxPyEndAllowThreads(__tstate);
20927 if (PyErr_Occurred()) SWIG_fail;
20928 }
20929 {
20930 wxDateTime * resultptr;
20931 resultptr = new wxDateTime((wxDateTime &)(result));
20932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20933 }
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20941 PyObject *resultobj;
20942 int arg1 ;
20943 int arg2 ;
20944 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20945 wxDateTime result;
20946 PyObject * obj0 = 0 ;
20947 PyObject * obj1 = 0 ;
20948 PyObject * obj2 = 0 ;
20949 char *kwnames[] = {
20950 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20951 };
20952
20953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20954 {
20955 arg1 = (int)(SWIG_As_int(obj0));
20956 if (SWIG_arg_fail(1)) SWIG_fail;
20957 }
20958 {
20959 arg2 = (int)(SWIG_As_int(obj1));
20960 if (SWIG_arg_fail(2)) SWIG_fail;
20961 }
20962 if (obj2) {
20963 {
20964 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20965 if (SWIG_arg_fail(3)) SWIG_fail;
20966 }
20967 }
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20971
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 {
20976 wxDateTime * resultptr;
20977 resultptr = new wxDateTime((wxDateTime &)(result));
20978 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20979 }
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20987 PyObject *resultobj;
20988 wxDateTime *arg1 = (wxDateTime *) 0 ;
20989 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20990 int arg3 = (int) wxDateTime::Inv_Year ;
20991 wxDateTime *result;
20992 PyObject * obj0 = 0 ;
20993 PyObject * obj1 = 0 ;
20994 PyObject * obj2 = 0 ;
20995 char *kwnames[] = {
20996 (char *) "self",(char *) "month",(char *) "year", NULL
20997 };
20998
20999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21001 if (SWIG_arg_fail(1)) SWIG_fail;
21002 if (obj1) {
21003 {
21004 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21005 if (SWIG_arg_fail(2)) SWIG_fail;
21006 }
21007 }
21008 if (obj2) {
21009 {
21010 arg3 = (int)(SWIG_As_int(obj2));
21011 if (SWIG_arg_fail(3)) SWIG_fail;
21012 }
21013 }
21014 {
21015 PyThreadState* __tstate = wxPyBeginAllowThreads();
21016 {
21017 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21018 result = (wxDateTime *) &_result_ref;
21019 }
21020
21021 wxPyEndAllowThreads(__tstate);
21022 if (PyErr_Occurred()) SWIG_fail;
21023 }
21024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21025 return resultobj;
21026 fail:
21027 return NULL;
21028 }
21029
21030
21031 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21032 PyObject *resultobj;
21033 wxDateTime *arg1 = (wxDateTime *) 0 ;
21034 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21035 int arg3 = (int) wxDateTime::Inv_Year ;
21036 wxDateTime result;
21037 PyObject * obj0 = 0 ;
21038 PyObject * obj1 = 0 ;
21039 PyObject * obj2 = 0 ;
21040 char *kwnames[] = {
21041 (char *) "self",(char *) "month",(char *) "year", NULL
21042 };
21043
21044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21046 if (SWIG_arg_fail(1)) SWIG_fail;
21047 if (obj1) {
21048 {
21049 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21050 if (SWIG_arg_fail(2)) SWIG_fail;
21051 }
21052 }
21053 if (obj2) {
21054 {
21055 arg3 = (int)(SWIG_As_int(obj2));
21056 if (SWIG_arg_fail(3)) SWIG_fail;
21057 }
21058 }
21059 {
21060 PyThreadState* __tstate = wxPyBeginAllowThreads();
21061 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21062
21063 wxPyEndAllowThreads(__tstate);
21064 if (PyErr_Occurred()) SWIG_fail;
21065 }
21066 {
21067 wxDateTime * resultptr;
21068 resultptr = new wxDateTime((wxDateTime &)(result));
21069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21070 }
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21078 PyObject *resultobj;
21079 wxDateTime *arg1 = (wxDateTime *) 0 ;
21080 int arg2 ;
21081 wxDateTime *result;
21082 PyObject * obj0 = 0 ;
21083 PyObject * obj1 = 0 ;
21084 char *kwnames[] = {
21085 (char *) "self",(char *) "yday", NULL
21086 };
21087
21088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21090 if (SWIG_arg_fail(1)) SWIG_fail;
21091 {
21092 arg2 = (int)(SWIG_As_int(obj1));
21093 if (SWIG_arg_fail(2)) SWIG_fail;
21094 }
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 {
21098 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21099 result = (wxDateTime *) &_result_ref;
21100 }
21101
21102 wxPyEndAllowThreads(__tstate);
21103 if (PyErr_Occurred()) SWIG_fail;
21104 }
21105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21106 return resultobj;
21107 fail:
21108 return NULL;
21109 }
21110
21111
21112 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21113 PyObject *resultobj;
21114 wxDateTime *arg1 = (wxDateTime *) 0 ;
21115 int arg2 ;
21116 wxDateTime result;
21117 PyObject * obj0 = 0 ;
21118 PyObject * obj1 = 0 ;
21119 char *kwnames[] = {
21120 (char *) "self",(char *) "yday", NULL
21121 };
21122
21123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21125 if (SWIG_arg_fail(1)) SWIG_fail;
21126 {
21127 arg2 = (int)(SWIG_As_int(obj1));
21128 if (SWIG_arg_fail(2)) SWIG_fail;
21129 }
21130 {
21131 PyThreadState* __tstate = wxPyBeginAllowThreads();
21132 result = (arg1)->GetYearDay(arg2);
21133
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 {
21138 wxDateTime * resultptr;
21139 resultptr = new wxDateTime((wxDateTime &)(result));
21140 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21141 }
21142 return resultobj;
21143 fail:
21144 return NULL;
21145 }
21146
21147
21148 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21149 PyObject *resultobj;
21150 wxDateTime *arg1 = (wxDateTime *) 0 ;
21151 double result;
21152 PyObject * obj0 = 0 ;
21153 char *kwnames[] = {
21154 (char *) "self", NULL
21155 };
21156
21157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21159 if (SWIG_arg_fail(1)) SWIG_fail;
21160 {
21161 PyThreadState* __tstate = wxPyBeginAllowThreads();
21162 result = (double)(arg1)->GetJulianDayNumber();
21163
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 {
21168 resultobj = SWIG_From_double((double)(result));
21169 }
21170 return resultobj;
21171 fail:
21172 return NULL;
21173 }
21174
21175
21176 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21177 PyObject *resultobj;
21178 wxDateTime *arg1 = (wxDateTime *) 0 ;
21179 double result;
21180 PyObject * obj0 = 0 ;
21181 char *kwnames[] = {
21182 (char *) "self", NULL
21183 };
21184
21185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21187 if (SWIG_arg_fail(1)) SWIG_fail;
21188 {
21189 PyThreadState* __tstate = wxPyBeginAllowThreads();
21190 result = (double)(arg1)->GetJDN();
21191
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 {
21196 resultobj = SWIG_From_double((double)(result));
21197 }
21198 return resultobj;
21199 fail:
21200 return NULL;
21201 }
21202
21203
21204 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21205 PyObject *resultobj;
21206 wxDateTime *arg1 = (wxDateTime *) 0 ;
21207 double result;
21208 PyObject * obj0 = 0 ;
21209 char *kwnames[] = {
21210 (char *) "self", NULL
21211 };
21212
21213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21215 if (SWIG_arg_fail(1)) SWIG_fail;
21216 {
21217 PyThreadState* __tstate = wxPyBeginAllowThreads();
21218 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21219
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 {
21224 resultobj = SWIG_From_double((double)(result));
21225 }
21226 return resultobj;
21227 fail:
21228 return NULL;
21229 }
21230
21231
21232 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21233 PyObject *resultobj;
21234 wxDateTime *arg1 = (wxDateTime *) 0 ;
21235 double result;
21236 PyObject * obj0 = 0 ;
21237 char *kwnames[] = {
21238 (char *) "self", NULL
21239 };
21240
21241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21243 if (SWIG_arg_fail(1)) SWIG_fail;
21244 {
21245 PyThreadState* __tstate = wxPyBeginAllowThreads();
21246 result = (double)(arg1)->GetMJD();
21247
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 {
21252 resultobj = SWIG_From_double((double)(result));
21253 }
21254 return resultobj;
21255 fail:
21256 return NULL;
21257 }
21258
21259
21260 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21261 PyObject *resultobj;
21262 wxDateTime *arg1 = (wxDateTime *) 0 ;
21263 double result;
21264 PyObject * obj0 = 0 ;
21265 char *kwnames[] = {
21266 (char *) "self", NULL
21267 };
21268
21269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21271 if (SWIG_arg_fail(1)) SWIG_fail;
21272 {
21273 PyThreadState* __tstate = wxPyBeginAllowThreads();
21274 result = (double)(arg1)->GetRataDie();
21275
21276 wxPyEndAllowThreads(__tstate);
21277 if (PyErr_Occurred()) SWIG_fail;
21278 }
21279 {
21280 resultobj = SWIG_From_double((double)(result));
21281 }
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21289 PyObject *resultobj;
21290 wxDateTime *arg1 = (wxDateTime *) 0 ;
21291 wxDateTime::TimeZone *arg2 = 0 ;
21292 bool arg3 = (bool) false ;
21293 wxDateTime result;
21294 bool temp2 = false ;
21295 PyObject * obj0 = 0 ;
21296 PyObject * obj1 = 0 ;
21297 PyObject * obj2 = 0 ;
21298 char *kwnames[] = {
21299 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21300 };
21301
21302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21304 if (SWIG_arg_fail(1)) SWIG_fail;
21305 {
21306 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21307 temp2 = true;
21308 }
21309 if (obj2) {
21310 {
21311 arg3 = (bool)(SWIG_As_bool(obj2));
21312 if (SWIG_arg_fail(3)) SWIG_fail;
21313 }
21314 }
21315 {
21316 PyThreadState* __tstate = wxPyBeginAllowThreads();
21317 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21318
21319 wxPyEndAllowThreads(__tstate);
21320 if (PyErr_Occurred()) SWIG_fail;
21321 }
21322 {
21323 wxDateTime * resultptr;
21324 resultptr = new wxDateTime((wxDateTime &)(result));
21325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21326 }
21327 {
21328 if (temp2) delete arg2;
21329 }
21330 return resultobj;
21331 fail:
21332 {
21333 if (temp2) delete arg2;
21334 }
21335 return NULL;
21336 }
21337
21338
21339 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj;
21341 wxDateTime *arg1 = (wxDateTime *) 0 ;
21342 wxDateTime::TimeZone *arg2 = 0 ;
21343 bool arg3 = (bool) false ;
21344 wxDateTime *result;
21345 bool temp2 = false ;
21346 PyObject * obj0 = 0 ;
21347 PyObject * obj1 = 0 ;
21348 PyObject * obj2 = 0 ;
21349 char *kwnames[] = {
21350 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21351 };
21352
21353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21355 if (SWIG_arg_fail(1)) SWIG_fail;
21356 {
21357 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21358 temp2 = true;
21359 }
21360 if (obj2) {
21361 {
21362 arg3 = (bool)(SWIG_As_bool(obj2));
21363 if (SWIG_arg_fail(3)) SWIG_fail;
21364 }
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 {
21369 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21370 result = (wxDateTime *) &_result_ref;
21371 }
21372
21373 wxPyEndAllowThreads(__tstate);
21374 if (PyErr_Occurred()) SWIG_fail;
21375 }
21376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21377 {
21378 if (temp2) delete arg2;
21379 }
21380 return resultobj;
21381 fail:
21382 {
21383 if (temp2) delete arg2;
21384 }
21385 return NULL;
21386 }
21387
21388
21389 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj;
21391 wxDateTime *arg1 = (wxDateTime *) 0 ;
21392 bool arg2 = (bool) false ;
21393 wxDateTime result;
21394 PyObject * obj0 = 0 ;
21395 PyObject * obj1 = 0 ;
21396 char *kwnames[] = {
21397 (char *) "self",(char *) "noDST", NULL
21398 };
21399
21400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21402 if (SWIG_arg_fail(1)) SWIG_fail;
21403 if (obj1) {
21404 {
21405 arg2 = (bool)(SWIG_As_bool(obj1));
21406 if (SWIG_arg_fail(2)) SWIG_fail;
21407 }
21408 }
21409 {
21410 PyThreadState* __tstate = wxPyBeginAllowThreads();
21411 result = (arg1)->ToGMT(arg2);
21412
21413 wxPyEndAllowThreads(__tstate);
21414 if (PyErr_Occurred()) SWIG_fail;
21415 }
21416 {
21417 wxDateTime * resultptr;
21418 resultptr = new wxDateTime((wxDateTime &)(result));
21419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21420 }
21421 return resultobj;
21422 fail:
21423 return NULL;
21424 }
21425
21426
21427 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21428 PyObject *resultobj;
21429 wxDateTime *arg1 = (wxDateTime *) 0 ;
21430 bool arg2 = (bool) false ;
21431 wxDateTime *result;
21432 PyObject * obj0 = 0 ;
21433 PyObject * obj1 = 0 ;
21434 char *kwnames[] = {
21435 (char *) "self",(char *) "noDST", NULL
21436 };
21437
21438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21440 if (SWIG_arg_fail(1)) SWIG_fail;
21441 if (obj1) {
21442 {
21443 arg2 = (bool)(SWIG_As_bool(obj1));
21444 if (SWIG_arg_fail(2)) SWIG_fail;
21445 }
21446 }
21447 {
21448 PyThreadState* __tstate = wxPyBeginAllowThreads();
21449 {
21450 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21451 result = (wxDateTime *) &_result_ref;
21452 }
21453
21454 wxPyEndAllowThreads(__tstate);
21455 if (PyErr_Occurred()) SWIG_fail;
21456 }
21457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21458 return resultobj;
21459 fail:
21460 return NULL;
21461 }
21462
21463
21464 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21465 PyObject *resultobj;
21466 wxDateTime *arg1 = (wxDateTime *) 0 ;
21467 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21468 int result;
21469 PyObject * obj0 = 0 ;
21470 PyObject * obj1 = 0 ;
21471 char *kwnames[] = {
21472 (char *) "self",(char *) "country", NULL
21473 };
21474
21475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21477 if (SWIG_arg_fail(1)) SWIG_fail;
21478 if (obj1) {
21479 {
21480 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21481 if (SWIG_arg_fail(2)) SWIG_fail;
21482 }
21483 }
21484 {
21485 PyThreadState* __tstate = wxPyBeginAllowThreads();
21486 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21487
21488 wxPyEndAllowThreads(__tstate);
21489 if (PyErr_Occurred()) SWIG_fail;
21490 }
21491 {
21492 resultobj = SWIG_From_int((int)(result));
21493 }
21494 return resultobj;
21495 fail:
21496 return NULL;
21497 }
21498
21499
21500 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21501 PyObject *resultobj;
21502 wxDateTime *arg1 = (wxDateTime *) 0 ;
21503 bool result;
21504 PyObject * obj0 = 0 ;
21505 char *kwnames[] = {
21506 (char *) "self", NULL
21507 };
21508
21509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21511 if (SWIG_arg_fail(1)) SWIG_fail;
21512 {
21513 PyThreadState* __tstate = wxPyBeginAllowThreads();
21514 result = (bool)((wxDateTime const *)arg1)->IsValid();
21515
21516 wxPyEndAllowThreads(__tstate);
21517 if (PyErr_Occurred()) SWIG_fail;
21518 }
21519 {
21520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21521 }
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21529 PyObject *resultobj;
21530 wxDateTime *arg1 = (wxDateTime *) 0 ;
21531 time_t result;
21532 PyObject * obj0 = 0 ;
21533 char *kwnames[] = {
21534 (char *) "self", NULL
21535 };
21536
21537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21539 if (SWIG_arg_fail(1)) SWIG_fail;
21540 {
21541 PyThreadState* __tstate = wxPyBeginAllowThreads();
21542 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21543
21544 wxPyEndAllowThreads(__tstate);
21545 if (PyErr_Occurred()) SWIG_fail;
21546 }
21547 {
21548 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21549 }
21550 return resultobj;
21551 fail:
21552 return NULL;
21553 }
21554
21555
21556 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21557 PyObject *resultobj;
21558 wxDateTime *arg1 = (wxDateTime *) 0 ;
21559 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21560 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21561 int result;
21562 bool temp2 = false ;
21563 PyObject * obj0 = 0 ;
21564 PyObject * obj1 = 0 ;
21565 char *kwnames[] = {
21566 (char *) "self",(char *) "tz", NULL
21567 };
21568
21569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21571 if (SWIG_arg_fail(1)) SWIG_fail;
21572 if (obj1) {
21573 {
21574 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21575 temp2 = true;
21576 }
21577 }
21578 {
21579 PyThreadState* __tstate = wxPyBeginAllowThreads();
21580 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21581
21582 wxPyEndAllowThreads(__tstate);
21583 if (PyErr_Occurred()) SWIG_fail;
21584 }
21585 {
21586 resultobj = SWIG_From_int((int)(result));
21587 }
21588 {
21589 if (temp2) delete arg2;
21590 }
21591 return resultobj;
21592 fail:
21593 {
21594 if (temp2) delete arg2;
21595 }
21596 return NULL;
21597 }
21598
21599
21600 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21601 PyObject *resultobj;
21602 wxDateTime *arg1 = (wxDateTime *) 0 ;
21603 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21604 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21605 wxDateTime::Month result;
21606 bool temp2 = false ;
21607 PyObject * obj0 = 0 ;
21608 PyObject * obj1 = 0 ;
21609 char *kwnames[] = {
21610 (char *) "self",(char *) "tz", NULL
21611 };
21612
21613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21615 if (SWIG_arg_fail(1)) SWIG_fail;
21616 if (obj1) {
21617 {
21618 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21619 temp2 = true;
21620 }
21621 }
21622 {
21623 PyThreadState* __tstate = wxPyBeginAllowThreads();
21624 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21625
21626 wxPyEndAllowThreads(__tstate);
21627 if (PyErr_Occurred()) SWIG_fail;
21628 }
21629 resultobj = SWIG_From_int((result));
21630 {
21631 if (temp2) delete arg2;
21632 }
21633 return resultobj;
21634 fail:
21635 {
21636 if (temp2) delete arg2;
21637 }
21638 return NULL;
21639 }
21640
21641
21642 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21643 PyObject *resultobj;
21644 wxDateTime *arg1 = (wxDateTime *) 0 ;
21645 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21646 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21647 int result;
21648 bool temp2 = false ;
21649 PyObject * obj0 = 0 ;
21650 PyObject * obj1 = 0 ;
21651 char *kwnames[] = {
21652 (char *) "self",(char *) "tz", NULL
21653 };
21654
21655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21657 if (SWIG_arg_fail(1)) SWIG_fail;
21658 if (obj1) {
21659 {
21660 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21661 temp2 = true;
21662 }
21663 }
21664 {
21665 PyThreadState* __tstate = wxPyBeginAllowThreads();
21666 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21667
21668 wxPyEndAllowThreads(__tstate);
21669 if (PyErr_Occurred()) SWIG_fail;
21670 }
21671 {
21672 resultobj = SWIG_From_int((int)(result));
21673 }
21674 {
21675 if (temp2) delete arg2;
21676 }
21677 return resultobj;
21678 fail:
21679 {
21680 if (temp2) delete arg2;
21681 }
21682 return NULL;
21683 }
21684
21685
21686 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21687 PyObject *resultobj;
21688 wxDateTime *arg1 = (wxDateTime *) 0 ;
21689 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21690 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21691 wxDateTime::WeekDay result;
21692 bool temp2 = false ;
21693 PyObject * obj0 = 0 ;
21694 PyObject * obj1 = 0 ;
21695 char *kwnames[] = {
21696 (char *) "self",(char *) "tz", NULL
21697 };
21698
21699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21701 if (SWIG_arg_fail(1)) SWIG_fail;
21702 if (obj1) {
21703 {
21704 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21705 temp2 = true;
21706 }
21707 }
21708 {
21709 PyThreadState* __tstate = wxPyBeginAllowThreads();
21710 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21711
21712 wxPyEndAllowThreads(__tstate);
21713 if (PyErr_Occurred()) SWIG_fail;
21714 }
21715 resultobj = SWIG_From_int((result));
21716 {
21717 if (temp2) delete arg2;
21718 }
21719 return resultobj;
21720 fail:
21721 {
21722 if (temp2) delete arg2;
21723 }
21724 return NULL;
21725 }
21726
21727
21728 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21729 PyObject *resultobj;
21730 wxDateTime *arg1 = (wxDateTime *) 0 ;
21731 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21732 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21733 int result;
21734 bool temp2 = false ;
21735 PyObject * obj0 = 0 ;
21736 PyObject * obj1 = 0 ;
21737 char *kwnames[] = {
21738 (char *) "self",(char *) "tz", NULL
21739 };
21740
21741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21743 if (SWIG_arg_fail(1)) SWIG_fail;
21744 if (obj1) {
21745 {
21746 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21747 temp2 = true;
21748 }
21749 }
21750 {
21751 PyThreadState* __tstate = wxPyBeginAllowThreads();
21752 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21753
21754 wxPyEndAllowThreads(__tstate);
21755 if (PyErr_Occurred()) SWIG_fail;
21756 }
21757 {
21758 resultobj = SWIG_From_int((int)(result));
21759 }
21760 {
21761 if (temp2) delete arg2;
21762 }
21763 return resultobj;
21764 fail:
21765 {
21766 if (temp2) delete arg2;
21767 }
21768 return NULL;
21769 }
21770
21771
21772 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21773 PyObject *resultobj;
21774 wxDateTime *arg1 = (wxDateTime *) 0 ;
21775 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21776 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21777 int result;
21778 bool temp2 = false ;
21779 PyObject * obj0 = 0 ;
21780 PyObject * obj1 = 0 ;
21781 char *kwnames[] = {
21782 (char *) "self",(char *) "tz", NULL
21783 };
21784
21785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21787 if (SWIG_arg_fail(1)) SWIG_fail;
21788 if (obj1) {
21789 {
21790 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21791 temp2 = true;
21792 }
21793 }
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21797
21798 wxPyEndAllowThreads(__tstate);
21799 if (PyErr_Occurred()) SWIG_fail;
21800 }
21801 {
21802 resultobj = SWIG_From_int((int)(result));
21803 }
21804 {
21805 if (temp2) delete arg2;
21806 }
21807 return resultobj;
21808 fail:
21809 {
21810 if (temp2) delete arg2;
21811 }
21812 return NULL;
21813 }
21814
21815
21816 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21817 PyObject *resultobj;
21818 wxDateTime *arg1 = (wxDateTime *) 0 ;
21819 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21820 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21821 int result;
21822 bool temp2 = false ;
21823 PyObject * obj0 = 0 ;
21824 PyObject * obj1 = 0 ;
21825 char *kwnames[] = {
21826 (char *) "self",(char *) "tz", NULL
21827 };
21828
21829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21831 if (SWIG_arg_fail(1)) SWIG_fail;
21832 if (obj1) {
21833 {
21834 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21835 temp2 = true;
21836 }
21837 }
21838 {
21839 PyThreadState* __tstate = wxPyBeginAllowThreads();
21840 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21841
21842 wxPyEndAllowThreads(__tstate);
21843 if (PyErr_Occurred()) SWIG_fail;
21844 }
21845 {
21846 resultobj = SWIG_From_int((int)(result));
21847 }
21848 {
21849 if (temp2) delete arg2;
21850 }
21851 return resultobj;
21852 fail:
21853 {
21854 if (temp2) delete arg2;
21855 }
21856 return NULL;
21857 }
21858
21859
21860 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21861 PyObject *resultobj;
21862 wxDateTime *arg1 = (wxDateTime *) 0 ;
21863 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21864 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21865 int result;
21866 bool temp2 = false ;
21867 PyObject * obj0 = 0 ;
21868 PyObject * obj1 = 0 ;
21869 char *kwnames[] = {
21870 (char *) "self",(char *) "tz", NULL
21871 };
21872
21873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21875 if (SWIG_arg_fail(1)) SWIG_fail;
21876 if (obj1) {
21877 {
21878 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21879 temp2 = true;
21880 }
21881 }
21882 {
21883 PyThreadState* __tstate = wxPyBeginAllowThreads();
21884 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21885
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 {
21890 resultobj = SWIG_From_int((int)(result));
21891 }
21892 {
21893 if (temp2) delete arg2;
21894 }
21895 return resultobj;
21896 fail:
21897 {
21898 if (temp2) delete arg2;
21899 }
21900 return NULL;
21901 }
21902
21903
21904 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21905 PyObject *resultobj;
21906 wxDateTime *arg1 = (wxDateTime *) 0 ;
21907 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21908 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21909 int result;
21910 bool temp2 = false ;
21911 PyObject * obj0 = 0 ;
21912 PyObject * obj1 = 0 ;
21913 char *kwnames[] = {
21914 (char *) "self",(char *) "tz", NULL
21915 };
21916
21917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21919 if (SWIG_arg_fail(1)) SWIG_fail;
21920 if (obj1) {
21921 {
21922 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21923 temp2 = true;
21924 }
21925 }
21926 {
21927 PyThreadState* __tstate = wxPyBeginAllowThreads();
21928 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21929
21930 wxPyEndAllowThreads(__tstate);
21931 if (PyErr_Occurred()) SWIG_fail;
21932 }
21933 {
21934 resultobj = SWIG_From_int((int)(result));
21935 }
21936 {
21937 if (temp2) delete arg2;
21938 }
21939 return resultobj;
21940 fail:
21941 {
21942 if (temp2) delete arg2;
21943 }
21944 return NULL;
21945 }
21946
21947
21948 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21949 PyObject *resultobj;
21950 wxDateTime *arg1 = (wxDateTime *) 0 ;
21951 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21952 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21953 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21954 int result;
21955 bool temp3 = false ;
21956 PyObject * obj0 = 0 ;
21957 PyObject * obj1 = 0 ;
21958 PyObject * obj2 = 0 ;
21959 char *kwnames[] = {
21960 (char *) "self",(char *) "flags",(char *) "tz", NULL
21961 };
21962
21963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21965 if (SWIG_arg_fail(1)) SWIG_fail;
21966 if (obj1) {
21967 {
21968 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21969 if (SWIG_arg_fail(2)) SWIG_fail;
21970 }
21971 }
21972 if (obj2) {
21973 {
21974 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21975 temp3 = true;
21976 }
21977 }
21978 {
21979 PyThreadState* __tstate = wxPyBeginAllowThreads();
21980 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21981
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 {
21986 resultobj = SWIG_From_int((int)(result));
21987 }
21988 {
21989 if (temp3) delete arg3;
21990 }
21991 return resultobj;
21992 fail:
21993 {
21994 if (temp3) delete arg3;
21995 }
21996 return NULL;
21997 }
21998
21999
22000 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22001 PyObject *resultobj;
22002 wxDateTime *arg1 = (wxDateTime *) 0 ;
22003 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22004 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22005 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22006 int result;
22007 bool temp3 = false ;
22008 PyObject * obj0 = 0 ;
22009 PyObject * obj1 = 0 ;
22010 PyObject * obj2 = 0 ;
22011 char *kwnames[] = {
22012 (char *) "self",(char *) "flags",(char *) "tz", NULL
22013 };
22014
22015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22017 if (SWIG_arg_fail(1)) SWIG_fail;
22018 if (obj1) {
22019 {
22020 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22021 if (SWIG_arg_fail(2)) SWIG_fail;
22022 }
22023 }
22024 if (obj2) {
22025 {
22026 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22027 temp3 = true;
22028 }
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22033
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 {
22038 resultobj = SWIG_From_int((int)(result));
22039 }
22040 {
22041 if (temp3) delete arg3;
22042 }
22043 return resultobj;
22044 fail:
22045 {
22046 if (temp3) delete arg3;
22047 }
22048 return NULL;
22049 }
22050
22051
22052 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22053 PyObject *resultobj;
22054 wxDateTime *arg1 = (wxDateTime *) 0 ;
22055 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22056 bool result;
22057 PyObject * obj0 = 0 ;
22058 PyObject * obj1 = 0 ;
22059 char *kwnames[] = {
22060 (char *) "self",(char *) "country", NULL
22061 };
22062
22063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22065 if (SWIG_arg_fail(1)) SWIG_fail;
22066 if (obj1) {
22067 {
22068 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22069 if (SWIG_arg_fail(2)) SWIG_fail;
22070 }
22071 }
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22075
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 {
22080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22081 }
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22089 PyObject *resultobj;
22090 wxDateTime *arg1 = (wxDateTime *) 0 ;
22091 wxDateTime *arg2 = 0 ;
22092 bool result;
22093 PyObject * obj0 = 0 ;
22094 PyObject * obj1 = 0 ;
22095 char *kwnames[] = {
22096 (char *) "self",(char *) "datetime", NULL
22097 };
22098
22099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22101 if (SWIG_arg_fail(1)) SWIG_fail;
22102 {
22103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22104 if (SWIG_arg_fail(2)) SWIG_fail;
22105 if (arg2 == NULL) {
22106 SWIG_null_ref("wxDateTime");
22107 }
22108 if (SWIG_arg_fail(2)) SWIG_fail;
22109 }
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22113
22114 wxPyEndAllowThreads(__tstate);
22115 if (PyErr_Occurred()) SWIG_fail;
22116 }
22117 {
22118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22119 }
22120 return resultobj;
22121 fail:
22122 return NULL;
22123 }
22124
22125
22126 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22127 PyObject *resultobj;
22128 wxDateTime *arg1 = (wxDateTime *) 0 ;
22129 wxDateTime *arg2 = 0 ;
22130 bool result;
22131 PyObject * obj0 = 0 ;
22132 PyObject * obj1 = 0 ;
22133 char *kwnames[] = {
22134 (char *) "self",(char *) "datetime", NULL
22135 };
22136
22137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22139 if (SWIG_arg_fail(1)) SWIG_fail;
22140 {
22141 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22142 if (SWIG_arg_fail(2)) SWIG_fail;
22143 if (arg2 == NULL) {
22144 SWIG_null_ref("wxDateTime");
22145 }
22146 if (SWIG_arg_fail(2)) SWIG_fail;
22147 }
22148 {
22149 PyThreadState* __tstate = wxPyBeginAllowThreads();
22150 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22151
22152 wxPyEndAllowThreads(__tstate);
22153 if (PyErr_Occurred()) SWIG_fail;
22154 }
22155 {
22156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22157 }
22158 return resultobj;
22159 fail:
22160 return NULL;
22161 }
22162
22163
22164 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22165 PyObject *resultobj;
22166 wxDateTime *arg1 = (wxDateTime *) 0 ;
22167 wxDateTime *arg2 = 0 ;
22168 bool result;
22169 PyObject * obj0 = 0 ;
22170 PyObject * obj1 = 0 ;
22171 char *kwnames[] = {
22172 (char *) "self",(char *) "datetime", NULL
22173 };
22174
22175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22177 if (SWIG_arg_fail(1)) SWIG_fail;
22178 {
22179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22180 if (SWIG_arg_fail(2)) SWIG_fail;
22181 if (arg2 == NULL) {
22182 SWIG_null_ref("wxDateTime");
22183 }
22184 if (SWIG_arg_fail(2)) SWIG_fail;
22185 }
22186 {
22187 PyThreadState* __tstate = wxPyBeginAllowThreads();
22188 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22189
22190 wxPyEndAllowThreads(__tstate);
22191 if (PyErr_Occurred()) SWIG_fail;
22192 }
22193 {
22194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22195 }
22196 return resultobj;
22197 fail:
22198 return NULL;
22199 }
22200
22201
22202 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22203 PyObject *resultobj;
22204 wxDateTime *arg1 = (wxDateTime *) 0 ;
22205 wxDateTime *arg2 = 0 ;
22206 wxDateTime *arg3 = 0 ;
22207 bool result;
22208 PyObject * obj0 = 0 ;
22209 PyObject * obj1 = 0 ;
22210 PyObject * obj2 = 0 ;
22211 char *kwnames[] = {
22212 (char *) "self",(char *) "t1",(char *) "t2", NULL
22213 };
22214
22215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22217 if (SWIG_arg_fail(1)) SWIG_fail;
22218 {
22219 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22220 if (SWIG_arg_fail(2)) SWIG_fail;
22221 if (arg2 == NULL) {
22222 SWIG_null_ref("wxDateTime");
22223 }
22224 if (SWIG_arg_fail(2)) SWIG_fail;
22225 }
22226 {
22227 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22228 if (SWIG_arg_fail(3)) SWIG_fail;
22229 if (arg3 == NULL) {
22230 SWIG_null_ref("wxDateTime");
22231 }
22232 if (SWIG_arg_fail(3)) SWIG_fail;
22233 }
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22237
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 {
22242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22243 }
22244 return resultobj;
22245 fail:
22246 return NULL;
22247 }
22248
22249
22250 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22251 PyObject *resultobj;
22252 wxDateTime *arg1 = (wxDateTime *) 0 ;
22253 wxDateTime *arg2 = 0 ;
22254 wxDateTime *arg3 = 0 ;
22255 bool result;
22256 PyObject * obj0 = 0 ;
22257 PyObject * obj1 = 0 ;
22258 PyObject * obj2 = 0 ;
22259 char *kwnames[] = {
22260 (char *) "self",(char *) "t1",(char *) "t2", NULL
22261 };
22262
22263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22265 if (SWIG_arg_fail(1)) SWIG_fail;
22266 {
22267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22268 if (SWIG_arg_fail(2)) SWIG_fail;
22269 if (arg2 == NULL) {
22270 SWIG_null_ref("wxDateTime");
22271 }
22272 if (SWIG_arg_fail(2)) SWIG_fail;
22273 }
22274 {
22275 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22276 if (SWIG_arg_fail(3)) SWIG_fail;
22277 if (arg3 == NULL) {
22278 SWIG_null_ref("wxDateTime");
22279 }
22280 if (SWIG_arg_fail(3)) SWIG_fail;
22281 }
22282 {
22283 PyThreadState* __tstate = wxPyBeginAllowThreads();
22284 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22285
22286 wxPyEndAllowThreads(__tstate);
22287 if (PyErr_Occurred()) SWIG_fail;
22288 }
22289 {
22290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22291 }
22292 return resultobj;
22293 fail:
22294 return NULL;
22295 }
22296
22297
22298 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22299 PyObject *resultobj;
22300 wxDateTime *arg1 = (wxDateTime *) 0 ;
22301 wxDateTime *arg2 = 0 ;
22302 bool result;
22303 PyObject * obj0 = 0 ;
22304 PyObject * obj1 = 0 ;
22305 char *kwnames[] = {
22306 (char *) "self",(char *) "dt", NULL
22307 };
22308
22309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22311 if (SWIG_arg_fail(1)) SWIG_fail;
22312 {
22313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22314 if (SWIG_arg_fail(2)) SWIG_fail;
22315 if (arg2 == NULL) {
22316 SWIG_null_ref("wxDateTime");
22317 }
22318 if (SWIG_arg_fail(2)) SWIG_fail;
22319 }
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22323
22324 wxPyEndAllowThreads(__tstate);
22325 if (PyErr_Occurred()) SWIG_fail;
22326 }
22327 {
22328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22329 }
22330 return resultobj;
22331 fail:
22332 return NULL;
22333 }
22334
22335
22336 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22337 PyObject *resultobj;
22338 wxDateTime *arg1 = (wxDateTime *) 0 ;
22339 wxDateTime *arg2 = 0 ;
22340 bool result;
22341 PyObject * obj0 = 0 ;
22342 PyObject * obj1 = 0 ;
22343 char *kwnames[] = {
22344 (char *) "self",(char *) "dt", NULL
22345 };
22346
22347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22349 if (SWIG_arg_fail(1)) SWIG_fail;
22350 {
22351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22352 if (SWIG_arg_fail(2)) SWIG_fail;
22353 if (arg2 == NULL) {
22354 SWIG_null_ref("wxDateTime");
22355 }
22356 if (SWIG_arg_fail(2)) SWIG_fail;
22357 }
22358 {
22359 PyThreadState* __tstate = wxPyBeginAllowThreads();
22360 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22361
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 {
22366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22367 }
22368 return resultobj;
22369 fail:
22370 return NULL;
22371 }
22372
22373
22374 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22375 PyObject *resultobj;
22376 wxDateTime *arg1 = (wxDateTime *) 0 ;
22377 wxDateTime *arg2 = 0 ;
22378 wxTimeSpan *arg3 = 0 ;
22379 bool result;
22380 PyObject * obj0 = 0 ;
22381 PyObject * obj1 = 0 ;
22382 PyObject * obj2 = 0 ;
22383 char *kwnames[] = {
22384 (char *) "self",(char *) "dt",(char *) "ts", NULL
22385 };
22386
22387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22389 if (SWIG_arg_fail(1)) SWIG_fail;
22390 {
22391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22392 if (SWIG_arg_fail(2)) SWIG_fail;
22393 if (arg2 == NULL) {
22394 SWIG_null_ref("wxDateTime");
22395 }
22396 if (SWIG_arg_fail(2)) SWIG_fail;
22397 }
22398 {
22399 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22400 if (SWIG_arg_fail(3)) SWIG_fail;
22401 if (arg3 == NULL) {
22402 SWIG_null_ref("wxTimeSpan");
22403 }
22404 if (SWIG_arg_fail(3)) SWIG_fail;
22405 }
22406 {
22407 PyThreadState* __tstate = wxPyBeginAllowThreads();
22408 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22409
22410 wxPyEndAllowThreads(__tstate);
22411 if (PyErr_Occurred()) SWIG_fail;
22412 }
22413 {
22414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22415 }
22416 return resultobj;
22417 fail:
22418 return NULL;
22419 }
22420
22421
22422 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22423 PyObject *resultobj;
22424 wxDateTime *arg1 = (wxDateTime *) 0 ;
22425 wxTimeSpan *arg2 = 0 ;
22426 wxDateTime *result;
22427 PyObject * obj0 = 0 ;
22428 PyObject * obj1 = 0 ;
22429 char *kwnames[] = {
22430 (char *) "self",(char *) "diff", NULL
22431 };
22432
22433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22435 if (SWIG_arg_fail(1)) SWIG_fail;
22436 {
22437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22438 if (SWIG_arg_fail(2)) SWIG_fail;
22439 if (arg2 == NULL) {
22440 SWIG_null_ref("wxTimeSpan");
22441 }
22442 if (SWIG_arg_fail(2)) SWIG_fail;
22443 }
22444 {
22445 PyThreadState* __tstate = wxPyBeginAllowThreads();
22446 {
22447 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22448 result = (wxDateTime *) &_result_ref;
22449 }
22450
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22462 PyObject *resultobj;
22463 wxDateTime *arg1 = (wxDateTime *) 0 ;
22464 wxDateSpan *arg2 = 0 ;
22465 wxDateTime *result;
22466 PyObject * obj0 = 0 ;
22467 PyObject * obj1 = 0 ;
22468 char *kwnames[] = {
22469 (char *) "self",(char *) "diff", NULL
22470 };
22471
22472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22474 if (SWIG_arg_fail(1)) SWIG_fail;
22475 {
22476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22477 if (SWIG_arg_fail(2)) SWIG_fail;
22478 if (arg2 == NULL) {
22479 SWIG_null_ref("wxDateSpan");
22480 }
22481 if (SWIG_arg_fail(2)) SWIG_fail;
22482 }
22483 {
22484 PyThreadState* __tstate = wxPyBeginAllowThreads();
22485 {
22486 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22487 result = (wxDateTime *) &_result_ref;
22488 }
22489
22490 wxPyEndAllowThreads(__tstate);
22491 if (PyErr_Occurred()) SWIG_fail;
22492 }
22493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22494 return resultobj;
22495 fail:
22496 return NULL;
22497 }
22498
22499
22500 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22501 PyObject *resultobj;
22502 wxDateTime *arg1 = (wxDateTime *) 0 ;
22503 wxTimeSpan *arg2 = 0 ;
22504 wxDateTime *result;
22505 PyObject * obj0 = 0 ;
22506 PyObject * obj1 = 0 ;
22507 char *kwnames[] = {
22508 (char *) "self",(char *) "diff", NULL
22509 };
22510
22511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22513 if (SWIG_arg_fail(1)) SWIG_fail;
22514 {
22515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22516 if (SWIG_arg_fail(2)) SWIG_fail;
22517 if (arg2 == NULL) {
22518 SWIG_null_ref("wxTimeSpan");
22519 }
22520 if (SWIG_arg_fail(2)) SWIG_fail;
22521 }
22522 {
22523 PyThreadState* __tstate = wxPyBeginAllowThreads();
22524 {
22525 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22526 result = (wxDateTime *) &_result_ref;
22527 }
22528
22529 wxPyEndAllowThreads(__tstate);
22530 if (PyErr_Occurred()) SWIG_fail;
22531 }
22532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22533 return resultobj;
22534 fail:
22535 return NULL;
22536 }
22537
22538
22539 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22540 PyObject *resultobj;
22541 wxDateTime *arg1 = (wxDateTime *) 0 ;
22542 wxDateSpan *arg2 = 0 ;
22543 wxDateTime *result;
22544 PyObject * obj0 = 0 ;
22545 PyObject * obj1 = 0 ;
22546 char *kwnames[] = {
22547 (char *) "self",(char *) "diff", NULL
22548 };
22549
22550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22552 if (SWIG_arg_fail(1)) SWIG_fail;
22553 {
22554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22555 if (SWIG_arg_fail(2)) SWIG_fail;
22556 if (arg2 == NULL) {
22557 SWIG_null_ref("wxDateSpan");
22558 }
22559 if (SWIG_arg_fail(2)) SWIG_fail;
22560 }
22561 {
22562 PyThreadState* __tstate = wxPyBeginAllowThreads();
22563 {
22564 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22565 result = (wxDateTime *) &_result_ref;
22566 }
22567
22568 wxPyEndAllowThreads(__tstate);
22569 if (PyErr_Occurred()) SWIG_fail;
22570 }
22571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22572 return resultobj;
22573 fail:
22574 return NULL;
22575 }
22576
22577
22578 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22579 PyObject *resultobj;
22580 wxDateTime *arg1 = (wxDateTime *) 0 ;
22581 wxDateTime *arg2 = 0 ;
22582 wxTimeSpan result;
22583 PyObject * obj0 = 0 ;
22584 PyObject * obj1 = 0 ;
22585 char *kwnames[] = {
22586 (char *) "self",(char *) "dt", NULL
22587 };
22588
22589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22591 if (SWIG_arg_fail(1)) SWIG_fail;
22592 {
22593 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22594 if (SWIG_arg_fail(2)) SWIG_fail;
22595 if (arg2 == NULL) {
22596 SWIG_null_ref("wxDateTime");
22597 }
22598 if (SWIG_arg_fail(2)) SWIG_fail;
22599 }
22600 {
22601 PyThreadState* __tstate = wxPyBeginAllowThreads();
22602 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22603
22604 wxPyEndAllowThreads(__tstate);
22605 if (PyErr_Occurred()) SWIG_fail;
22606 }
22607 {
22608 wxTimeSpan * resultptr;
22609 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22610 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22611 }
22612 return resultobj;
22613 fail:
22614 return NULL;
22615 }
22616
22617
22618 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22619 PyObject *resultobj;
22620 wxDateTime *arg1 = (wxDateTime *) 0 ;
22621 wxTimeSpan *arg2 = 0 ;
22622 wxDateTime *result;
22623 PyObject * obj0 = 0 ;
22624 PyObject * obj1 = 0 ;
22625
22626 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22628 if (SWIG_arg_fail(1)) SWIG_fail;
22629 {
22630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22631 if (SWIG_arg_fail(2)) SWIG_fail;
22632 if (arg2 == NULL) {
22633 SWIG_null_ref("wxTimeSpan");
22634 }
22635 if (SWIG_arg_fail(2)) SWIG_fail;
22636 }
22637 {
22638 PyThreadState* __tstate = wxPyBeginAllowThreads();
22639 {
22640 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22641 result = (wxDateTime *) &_result_ref;
22642 }
22643
22644 wxPyEndAllowThreads(__tstate);
22645 if (PyErr_Occurred()) SWIG_fail;
22646 }
22647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22648 return resultobj;
22649 fail:
22650 return NULL;
22651 }
22652
22653
22654 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22655 PyObject *resultobj;
22656 wxDateTime *arg1 = (wxDateTime *) 0 ;
22657 wxDateSpan *arg2 = 0 ;
22658 wxDateTime *result;
22659 PyObject * obj0 = 0 ;
22660 PyObject * obj1 = 0 ;
22661
22662 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22664 if (SWIG_arg_fail(1)) SWIG_fail;
22665 {
22666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22667 if (SWIG_arg_fail(2)) SWIG_fail;
22668 if (arg2 == NULL) {
22669 SWIG_null_ref("wxDateSpan");
22670 }
22671 if (SWIG_arg_fail(2)) SWIG_fail;
22672 }
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 {
22676 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22677 result = (wxDateTime *) &_result_ref;
22678 }
22679
22680 wxPyEndAllowThreads(__tstate);
22681 if (PyErr_Occurred()) SWIG_fail;
22682 }
22683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22684 return resultobj;
22685 fail:
22686 return NULL;
22687 }
22688
22689
22690 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22691 int argc;
22692 PyObject *argv[3];
22693 int ii;
22694
22695 argc = PyObject_Length(args);
22696 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22697 argv[ii] = PyTuple_GetItem(args,ii);
22698 }
22699 if (argc == 2) {
22700 int _v;
22701 {
22702 void *ptr;
22703 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22704 _v = 0;
22705 PyErr_Clear();
22706 } else {
22707 _v = 1;
22708 }
22709 }
22710 if (_v) {
22711 {
22712 void *ptr = 0;
22713 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22714 _v = 0;
22715 PyErr_Clear();
22716 } else {
22717 _v = (ptr != 0);
22718 }
22719 }
22720 if (_v) {
22721 return _wrap_DateTime___iadd____SWIG_0(self,args);
22722 }
22723 }
22724 }
22725 if (argc == 2) {
22726 int _v;
22727 {
22728 void *ptr;
22729 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22730 _v = 0;
22731 PyErr_Clear();
22732 } else {
22733 _v = 1;
22734 }
22735 }
22736 if (_v) {
22737 {
22738 void *ptr = 0;
22739 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22740 _v = 0;
22741 PyErr_Clear();
22742 } else {
22743 _v = (ptr != 0);
22744 }
22745 }
22746 if (_v) {
22747 return _wrap_DateTime___iadd____SWIG_1(self,args);
22748 }
22749 }
22750 }
22751
22752 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22753 return NULL;
22754 }
22755
22756
22757 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22758 PyObject *resultobj;
22759 wxDateTime *arg1 = (wxDateTime *) 0 ;
22760 wxTimeSpan *arg2 = 0 ;
22761 wxDateTime *result;
22762 PyObject * obj0 = 0 ;
22763 PyObject * obj1 = 0 ;
22764
22765 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22767 if (SWIG_arg_fail(1)) SWIG_fail;
22768 {
22769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22770 if (SWIG_arg_fail(2)) SWIG_fail;
22771 if (arg2 == NULL) {
22772 SWIG_null_ref("wxTimeSpan");
22773 }
22774 if (SWIG_arg_fail(2)) SWIG_fail;
22775 }
22776 {
22777 PyThreadState* __tstate = wxPyBeginAllowThreads();
22778 {
22779 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22780 result = (wxDateTime *) &_result_ref;
22781 }
22782
22783 wxPyEndAllowThreads(__tstate);
22784 if (PyErr_Occurred()) SWIG_fail;
22785 }
22786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22787 return resultobj;
22788 fail:
22789 return NULL;
22790 }
22791
22792
22793 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22794 PyObject *resultobj;
22795 wxDateTime *arg1 = (wxDateTime *) 0 ;
22796 wxDateSpan *arg2 = 0 ;
22797 wxDateTime *result;
22798 PyObject * obj0 = 0 ;
22799 PyObject * obj1 = 0 ;
22800
22801 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22803 if (SWIG_arg_fail(1)) SWIG_fail;
22804 {
22805 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22806 if (SWIG_arg_fail(2)) SWIG_fail;
22807 if (arg2 == NULL) {
22808 SWIG_null_ref("wxDateSpan");
22809 }
22810 if (SWIG_arg_fail(2)) SWIG_fail;
22811 }
22812 {
22813 PyThreadState* __tstate = wxPyBeginAllowThreads();
22814 {
22815 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22816 result = (wxDateTime *) &_result_ref;
22817 }
22818
22819 wxPyEndAllowThreads(__tstate);
22820 if (PyErr_Occurred()) SWIG_fail;
22821 }
22822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22830 int argc;
22831 PyObject *argv[3];
22832 int ii;
22833
22834 argc = PyObject_Length(args);
22835 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22836 argv[ii] = PyTuple_GetItem(args,ii);
22837 }
22838 if (argc == 2) {
22839 int _v;
22840 {
22841 void *ptr;
22842 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22843 _v = 0;
22844 PyErr_Clear();
22845 } else {
22846 _v = 1;
22847 }
22848 }
22849 if (_v) {
22850 {
22851 void *ptr = 0;
22852 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22853 _v = 0;
22854 PyErr_Clear();
22855 } else {
22856 _v = (ptr != 0);
22857 }
22858 }
22859 if (_v) {
22860 return _wrap_DateTime___isub____SWIG_0(self,args);
22861 }
22862 }
22863 }
22864 if (argc == 2) {
22865 int _v;
22866 {
22867 void *ptr;
22868 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22869 _v = 0;
22870 PyErr_Clear();
22871 } else {
22872 _v = 1;
22873 }
22874 }
22875 if (_v) {
22876 {
22877 void *ptr = 0;
22878 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22879 _v = 0;
22880 PyErr_Clear();
22881 } else {
22882 _v = (ptr != 0);
22883 }
22884 }
22885 if (_v) {
22886 return _wrap_DateTime___isub____SWIG_1(self,args);
22887 }
22888 }
22889 }
22890
22891 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22892 return NULL;
22893 }
22894
22895
22896 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22897 PyObject *resultobj;
22898 wxDateTime *arg1 = (wxDateTime *) 0 ;
22899 wxTimeSpan *arg2 = 0 ;
22900 wxDateTime result;
22901 PyObject * obj0 = 0 ;
22902 PyObject * obj1 = 0 ;
22903
22904 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22906 if (SWIG_arg_fail(1)) SWIG_fail;
22907 {
22908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22909 if (SWIG_arg_fail(2)) SWIG_fail;
22910 if (arg2 == NULL) {
22911 SWIG_null_ref("wxTimeSpan");
22912 }
22913 if (SWIG_arg_fail(2)) SWIG_fail;
22914 }
22915 {
22916 PyThreadState* __tstate = wxPyBeginAllowThreads();
22917 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22918
22919 wxPyEndAllowThreads(__tstate);
22920 if (PyErr_Occurred()) SWIG_fail;
22921 }
22922 {
22923 wxDateTime * resultptr;
22924 resultptr = new wxDateTime((wxDateTime &)(result));
22925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22926 }
22927 return resultobj;
22928 fail:
22929 return NULL;
22930 }
22931
22932
22933 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22934 PyObject *resultobj;
22935 wxDateTime *arg1 = (wxDateTime *) 0 ;
22936 wxDateSpan *arg2 = 0 ;
22937 wxDateTime result;
22938 PyObject * obj0 = 0 ;
22939 PyObject * obj1 = 0 ;
22940
22941 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22943 if (SWIG_arg_fail(1)) SWIG_fail;
22944 {
22945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22946 if (SWIG_arg_fail(2)) SWIG_fail;
22947 if (arg2 == NULL) {
22948 SWIG_null_ref("wxDateSpan");
22949 }
22950 if (SWIG_arg_fail(2)) SWIG_fail;
22951 }
22952 {
22953 PyThreadState* __tstate = wxPyBeginAllowThreads();
22954 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22955
22956 wxPyEndAllowThreads(__tstate);
22957 if (PyErr_Occurred()) SWIG_fail;
22958 }
22959 {
22960 wxDateTime * resultptr;
22961 resultptr = new wxDateTime((wxDateTime &)(result));
22962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22963 }
22964 return resultobj;
22965 fail:
22966 return NULL;
22967 }
22968
22969
22970 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22971 int argc;
22972 PyObject *argv[3];
22973 int ii;
22974
22975 argc = PyObject_Length(args);
22976 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22977 argv[ii] = PyTuple_GetItem(args,ii);
22978 }
22979 if (argc == 2) {
22980 int _v;
22981 {
22982 void *ptr;
22983 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22984 _v = 0;
22985 PyErr_Clear();
22986 } else {
22987 _v = 1;
22988 }
22989 }
22990 if (_v) {
22991 {
22992 void *ptr = 0;
22993 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22994 _v = 0;
22995 PyErr_Clear();
22996 } else {
22997 _v = (ptr != 0);
22998 }
22999 }
23000 if (_v) {
23001 return _wrap_DateTime___add____SWIG_0(self,args);
23002 }
23003 }
23004 }
23005 if (argc == 2) {
23006 int _v;
23007 {
23008 void *ptr;
23009 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23010 _v = 0;
23011 PyErr_Clear();
23012 } else {
23013 _v = 1;
23014 }
23015 }
23016 if (_v) {
23017 {
23018 void *ptr = 0;
23019 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23020 _v = 0;
23021 PyErr_Clear();
23022 } else {
23023 _v = (ptr != 0);
23024 }
23025 }
23026 if (_v) {
23027 return _wrap_DateTime___add____SWIG_1(self,args);
23028 }
23029 }
23030 }
23031
23032 Py_INCREF(Py_NotImplemented);
23033 return Py_NotImplemented;
23034 }
23035
23036
23037 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23038 PyObject *resultobj;
23039 wxDateTime *arg1 = (wxDateTime *) 0 ;
23040 wxDateTime *arg2 = 0 ;
23041 wxTimeSpan result;
23042 PyObject * obj0 = 0 ;
23043 PyObject * obj1 = 0 ;
23044
23045 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23047 if (SWIG_arg_fail(1)) SWIG_fail;
23048 {
23049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23050 if (SWIG_arg_fail(2)) SWIG_fail;
23051 if (arg2 == NULL) {
23052 SWIG_null_ref("wxDateTime");
23053 }
23054 if (SWIG_arg_fail(2)) SWIG_fail;
23055 }
23056 {
23057 PyThreadState* __tstate = wxPyBeginAllowThreads();
23058 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23059
23060 wxPyEndAllowThreads(__tstate);
23061 if (PyErr_Occurred()) SWIG_fail;
23062 }
23063 {
23064 wxTimeSpan * resultptr;
23065 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23067 }
23068 return resultobj;
23069 fail:
23070 return NULL;
23071 }
23072
23073
23074 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23075 PyObject *resultobj;
23076 wxDateTime *arg1 = (wxDateTime *) 0 ;
23077 wxTimeSpan *arg2 = 0 ;
23078 wxDateTime result;
23079 PyObject * obj0 = 0 ;
23080 PyObject * obj1 = 0 ;
23081
23082 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23084 if (SWIG_arg_fail(1)) SWIG_fail;
23085 {
23086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23087 if (SWIG_arg_fail(2)) SWIG_fail;
23088 if (arg2 == NULL) {
23089 SWIG_null_ref("wxTimeSpan");
23090 }
23091 if (SWIG_arg_fail(2)) SWIG_fail;
23092 }
23093 {
23094 PyThreadState* __tstate = wxPyBeginAllowThreads();
23095 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23096
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 {
23101 wxDateTime * resultptr;
23102 resultptr = new wxDateTime((wxDateTime &)(result));
23103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23104 }
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23112 PyObject *resultobj;
23113 wxDateTime *arg1 = (wxDateTime *) 0 ;
23114 wxDateSpan *arg2 = 0 ;
23115 wxDateTime result;
23116 PyObject * obj0 = 0 ;
23117 PyObject * obj1 = 0 ;
23118
23119 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23121 if (SWIG_arg_fail(1)) SWIG_fail;
23122 {
23123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23124 if (SWIG_arg_fail(2)) SWIG_fail;
23125 if (arg2 == NULL) {
23126 SWIG_null_ref("wxDateSpan");
23127 }
23128 if (SWIG_arg_fail(2)) SWIG_fail;
23129 }
23130 {
23131 PyThreadState* __tstate = wxPyBeginAllowThreads();
23132 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23133
23134 wxPyEndAllowThreads(__tstate);
23135 if (PyErr_Occurred()) SWIG_fail;
23136 }
23137 {
23138 wxDateTime * resultptr;
23139 resultptr = new wxDateTime((wxDateTime &)(result));
23140 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23141 }
23142 return resultobj;
23143 fail:
23144 return NULL;
23145 }
23146
23147
23148 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23149 int argc;
23150 PyObject *argv[3];
23151 int ii;
23152
23153 argc = PyObject_Length(args);
23154 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23155 argv[ii] = PyTuple_GetItem(args,ii);
23156 }
23157 if (argc == 2) {
23158 int _v;
23159 {
23160 void *ptr;
23161 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23162 _v = 0;
23163 PyErr_Clear();
23164 } else {
23165 _v = 1;
23166 }
23167 }
23168 if (_v) {
23169 {
23170 void *ptr = 0;
23171 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23172 _v = 0;
23173 PyErr_Clear();
23174 } else {
23175 _v = (ptr != 0);
23176 }
23177 }
23178 if (_v) {
23179 return _wrap_DateTime___sub____SWIG_0(self,args);
23180 }
23181 }
23182 }
23183 if (argc == 2) {
23184 int _v;
23185 {
23186 void *ptr;
23187 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23188 _v = 0;
23189 PyErr_Clear();
23190 } else {
23191 _v = 1;
23192 }
23193 }
23194 if (_v) {
23195 {
23196 void *ptr = 0;
23197 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23198 _v = 0;
23199 PyErr_Clear();
23200 } else {
23201 _v = (ptr != 0);
23202 }
23203 }
23204 if (_v) {
23205 return _wrap_DateTime___sub____SWIG_1(self,args);
23206 }
23207 }
23208 }
23209 if (argc == 2) {
23210 int _v;
23211 {
23212 void *ptr;
23213 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23214 _v = 0;
23215 PyErr_Clear();
23216 } else {
23217 _v = 1;
23218 }
23219 }
23220 if (_v) {
23221 {
23222 void *ptr = 0;
23223 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23224 _v = 0;
23225 PyErr_Clear();
23226 } else {
23227 _v = (ptr != 0);
23228 }
23229 }
23230 if (_v) {
23231 return _wrap_DateTime___sub____SWIG_2(self,args);
23232 }
23233 }
23234 }
23235
23236 Py_INCREF(Py_NotImplemented);
23237 return Py_NotImplemented;
23238 }
23239
23240
23241 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23242 PyObject *resultobj;
23243 wxDateTime *arg1 = (wxDateTime *) 0 ;
23244 wxDateTime *arg2 = (wxDateTime *) 0 ;
23245 bool result;
23246 PyObject * obj0 = 0 ;
23247 PyObject * obj1 = 0 ;
23248 char *kwnames[] = {
23249 (char *) "self",(char *) "other", NULL
23250 };
23251
23252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23254 if (SWIG_arg_fail(1)) SWIG_fail;
23255 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23256 if (SWIG_arg_fail(2)) SWIG_fail;
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23260
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 {
23265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23266 }
23267 return resultobj;
23268 fail:
23269 return NULL;
23270 }
23271
23272
23273 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23274 PyObject *resultobj;
23275 wxDateTime *arg1 = (wxDateTime *) 0 ;
23276 wxDateTime *arg2 = (wxDateTime *) 0 ;
23277 bool result;
23278 PyObject * obj0 = 0 ;
23279 PyObject * obj1 = 0 ;
23280 char *kwnames[] = {
23281 (char *) "self",(char *) "other", NULL
23282 };
23283
23284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23286 if (SWIG_arg_fail(1)) SWIG_fail;
23287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23288 if (SWIG_arg_fail(2)) SWIG_fail;
23289 {
23290 PyThreadState* __tstate = wxPyBeginAllowThreads();
23291 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23292
23293 wxPyEndAllowThreads(__tstate);
23294 if (PyErr_Occurred()) SWIG_fail;
23295 }
23296 {
23297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23298 }
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj;
23307 wxDateTime *arg1 = (wxDateTime *) 0 ;
23308 wxDateTime *arg2 = (wxDateTime *) 0 ;
23309 bool result;
23310 PyObject * obj0 = 0 ;
23311 PyObject * obj1 = 0 ;
23312 char *kwnames[] = {
23313 (char *) "self",(char *) "other", NULL
23314 };
23315
23316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23318 if (SWIG_arg_fail(1)) SWIG_fail;
23319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23320 if (SWIG_arg_fail(2)) SWIG_fail;
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23324
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 {
23329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23330 }
23331 return resultobj;
23332 fail:
23333 return NULL;
23334 }
23335
23336
23337 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23338 PyObject *resultobj;
23339 wxDateTime *arg1 = (wxDateTime *) 0 ;
23340 wxDateTime *arg2 = (wxDateTime *) 0 ;
23341 bool result;
23342 PyObject * obj0 = 0 ;
23343 PyObject * obj1 = 0 ;
23344 char *kwnames[] = {
23345 (char *) "self",(char *) "other", NULL
23346 };
23347
23348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23350 if (SWIG_arg_fail(1)) SWIG_fail;
23351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23352 if (SWIG_arg_fail(2)) SWIG_fail;
23353 {
23354 PyThreadState* __tstate = wxPyBeginAllowThreads();
23355 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23356
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 {
23361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23362 }
23363 return resultobj;
23364 fail:
23365 return NULL;
23366 }
23367
23368
23369 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23370 PyObject *resultobj;
23371 wxDateTime *arg1 = (wxDateTime *) 0 ;
23372 wxDateTime *arg2 = (wxDateTime *) 0 ;
23373 bool result;
23374 PyObject * obj0 = 0 ;
23375 PyObject * obj1 = 0 ;
23376 char *kwnames[] = {
23377 (char *) "self",(char *) "other", NULL
23378 };
23379
23380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23382 if (SWIG_arg_fail(1)) SWIG_fail;
23383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23384 if (SWIG_arg_fail(2)) SWIG_fail;
23385 {
23386 PyThreadState* __tstate = wxPyBeginAllowThreads();
23387 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23388
23389 wxPyEndAllowThreads(__tstate);
23390 if (PyErr_Occurred()) SWIG_fail;
23391 }
23392 {
23393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23394 }
23395 return resultobj;
23396 fail:
23397 return NULL;
23398 }
23399
23400
23401 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23402 PyObject *resultobj;
23403 wxDateTime *arg1 = (wxDateTime *) 0 ;
23404 wxDateTime *arg2 = (wxDateTime *) 0 ;
23405 bool result;
23406 PyObject * obj0 = 0 ;
23407 PyObject * obj1 = 0 ;
23408 char *kwnames[] = {
23409 (char *) "self",(char *) "other", NULL
23410 };
23411
23412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23414 if (SWIG_arg_fail(1)) SWIG_fail;
23415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23416 if (SWIG_arg_fail(2)) SWIG_fail;
23417 {
23418 PyThreadState* __tstate = wxPyBeginAllowThreads();
23419 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23420
23421 wxPyEndAllowThreads(__tstate);
23422 if (PyErr_Occurred()) SWIG_fail;
23423 }
23424 {
23425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23426 }
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj;
23435 wxDateTime *arg1 = (wxDateTime *) 0 ;
23436 wxString *arg2 = 0 ;
23437 int result;
23438 bool temp2 = false ;
23439 PyObject * obj0 = 0 ;
23440 PyObject * obj1 = 0 ;
23441 char *kwnames[] = {
23442 (char *) "self",(char *) "date", NULL
23443 };
23444
23445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23447 if (SWIG_arg_fail(1)) SWIG_fail;
23448 {
23449 arg2 = wxString_in_helper(obj1);
23450 if (arg2 == NULL) SWIG_fail;
23451 temp2 = true;
23452 }
23453 {
23454 PyThreadState* __tstate = wxPyBeginAllowThreads();
23455 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23456
23457 wxPyEndAllowThreads(__tstate);
23458 if (PyErr_Occurred()) SWIG_fail;
23459 }
23460 {
23461 resultobj = SWIG_From_int((int)(result));
23462 }
23463 {
23464 if (temp2)
23465 delete arg2;
23466 }
23467 return resultobj;
23468 fail:
23469 {
23470 if (temp2)
23471 delete arg2;
23472 }
23473 return NULL;
23474 }
23475
23476
23477 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23478 PyObject *resultobj;
23479 wxDateTime *arg1 = (wxDateTime *) 0 ;
23480 wxString *arg2 = 0 ;
23481 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23482 wxString *arg3 = (wxString *) &arg3_defvalue ;
23483 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23484 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23485 int result;
23486 bool temp2 = false ;
23487 bool temp3 = false ;
23488 PyObject * obj0 = 0 ;
23489 PyObject * obj1 = 0 ;
23490 PyObject * obj2 = 0 ;
23491 PyObject * obj3 = 0 ;
23492 char *kwnames[] = {
23493 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23494 };
23495
23496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23498 if (SWIG_arg_fail(1)) SWIG_fail;
23499 {
23500 arg2 = wxString_in_helper(obj1);
23501 if (arg2 == NULL) SWIG_fail;
23502 temp2 = true;
23503 }
23504 if (obj2) {
23505 {
23506 arg3 = wxString_in_helper(obj2);
23507 if (arg3 == NULL) SWIG_fail;
23508 temp3 = true;
23509 }
23510 }
23511 if (obj3) {
23512 {
23513 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23514 if (SWIG_arg_fail(4)) SWIG_fail;
23515 if (arg4 == NULL) {
23516 SWIG_null_ref("wxDateTime");
23517 }
23518 if (SWIG_arg_fail(4)) SWIG_fail;
23519 }
23520 }
23521 {
23522 PyThreadState* __tstate = wxPyBeginAllowThreads();
23523 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23524
23525 wxPyEndAllowThreads(__tstate);
23526 if (PyErr_Occurred()) SWIG_fail;
23527 }
23528 {
23529 resultobj = SWIG_From_int((int)(result));
23530 }
23531 {
23532 if (temp2)
23533 delete arg2;
23534 }
23535 {
23536 if (temp3)
23537 delete arg3;
23538 }
23539 return resultobj;
23540 fail:
23541 {
23542 if (temp2)
23543 delete arg2;
23544 }
23545 {
23546 if (temp3)
23547 delete arg3;
23548 }
23549 return NULL;
23550 }
23551
23552
23553 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23554 PyObject *resultobj;
23555 wxDateTime *arg1 = (wxDateTime *) 0 ;
23556 wxString *arg2 = 0 ;
23557 int result;
23558 bool temp2 = false ;
23559 PyObject * obj0 = 0 ;
23560 PyObject * obj1 = 0 ;
23561 char *kwnames[] = {
23562 (char *) "self",(char *) "datetime", NULL
23563 };
23564
23565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23567 if (SWIG_arg_fail(1)) SWIG_fail;
23568 {
23569 arg2 = wxString_in_helper(obj1);
23570 if (arg2 == NULL) SWIG_fail;
23571 temp2 = true;
23572 }
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23576
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 {
23581 resultobj = SWIG_From_int((int)(result));
23582 }
23583 {
23584 if (temp2)
23585 delete arg2;
23586 }
23587 return resultobj;
23588 fail:
23589 {
23590 if (temp2)
23591 delete arg2;
23592 }
23593 return NULL;
23594 }
23595
23596
23597 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23598 PyObject *resultobj;
23599 wxDateTime *arg1 = (wxDateTime *) 0 ;
23600 wxString *arg2 = 0 ;
23601 int result;
23602 bool temp2 = false ;
23603 PyObject * obj0 = 0 ;
23604 PyObject * obj1 = 0 ;
23605 char *kwnames[] = {
23606 (char *) "self",(char *) "date", NULL
23607 };
23608
23609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23611 if (SWIG_arg_fail(1)) SWIG_fail;
23612 {
23613 arg2 = wxString_in_helper(obj1);
23614 if (arg2 == NULL) SWIG_fail;
23615 temp2 = true;
23616 }
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23620
23621 wxPyEndAllowThreads(__tstate);
23622 if (PyErr_Occurred()) SWIG_fail;
23623 }
23624 {
23625 resultobj = SWIG_From_int((int)(result));
23626 }
23627 {
23628 if (temp2)
23629 delete arg2;
23630 }
23631 return resultobj;
23632 fail:
23633 {
23634 if (temp2)
23635 delete arg2;
23636 }
23637 return NULL;
23638 }
23639
23640
23641 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj;
23643 wxDateTime *arg1 = (wxDateTime *) 0 ;
23644 wxString *arg2 = 0 ;
23645 int result;
23646 bool temp2 = false ;
23647 PyObject * obj0 = 0 ;
23648 PyObject * obj1 = 0 ;
23649 char *kwnames[] = {
23650 (char *) "self",(char *) "time", NULL
23651 };
23652
23653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23655 if (SWIG_arg_fail(1)) SWIG_fail;
23656 {
23657 arg2 = wxString_in_helper(obj1);
23658 if (arg2 == NULL) SWIG_fail;
23659 temp2 = true;
23660 }
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23664
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 {
23669 resultobj = SWIG_From_int((int)(result));
23670 }
23671 {
23672 if (temp2)
23673 delete arg2;
23674 }
23675 return resultobj;
23676 fail:
23677 {
23678 if (temp2)
23679 delete arg2;
23680 }
23681 return NULL;
23682 }
23683
23684
23685 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23686 PyObject *resultobj;
23687 wxDateTime *arg1 = (wxDateTime *) 0 ;
23688 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23689 wxString *arg2 = (wxString *) &arg2_defvalue ;
23690 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23691 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23692 wxString result;
23693 bool temp2 = false ;
23694 bool temp3 = false ;
23695 PyObject * obj0 = 0 ;
23696 PyObject * obj1 = 0 ;
23697 PyObject * obj2 = 0 ;
23698 char *kwnames[] = {
23699 (char *) "self",(char *) "format",(char *) "tz", NULL
23700 };
23701
23702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23704 if (SWIG_arg_fail(1)) SWIG_fail;
23705 if (obj1) {
23706 {
23707 arg2 = wxString_in_helper(obj1);
23708 if (arg2 == NULL) SWIG_fail;
23709 temp2 = true;
23710 }
23711 }
23712 if (obj2) {
23713 {
23714 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23715 temp3 = true;
23716 }
23717 }
23718 {
23719 PyThreadState* __tstate = wxPyBeginAllowThreads();
23720 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23721
23722 wxPyEndAllowThreads(__tstate);
23723 if (PyErr_Occurred()) SWIG_fail;
23724 }
23725 {
23726 #if wxUSE_UNICODE
23727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23728 #else
23729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23730 #endif
23731 }
23732 {
23733 if (temp2)
23734 delete arg2;
23735 }
23736 {
23737 if (temp3) delete arg3;
23738 }
23739 return resultobj;
23740 fail:
23741 {
23742 if (temp2)
23743 delete arg2;
23744 }
23745 {
23746 if (temp3) delete arg3;
23747 }
23748 return NULL;
23749 }
23750
23751
23752 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj;
23754 wxDateTime *arg1 = (wxDateTime *) 0 ;
23755 wxString result;
23756 PyObject * obj0 = 0 ;
23757 char *kwnames[] = {
23758 (char *) "self", NULL
23759 };
23760
23761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23763 if (SWIG_arg_fail(1)) SWIG_fail;
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 result = ((wxDateTime const *)arg1)->FormatDate();
23767
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 {
23772 #if wxUSE_UNICODE
23773 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23774 #else
23775 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23776 #endif
23777 }
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23785 PyObject *resultobj;
23786 wxDateTime *arg1 = (wxDateTime *) 0 ;
23787 wxString result;
23788 PyObject * obj0 = 0 ;
23789 char *kwnames[] = {
23790 (char *) "self", NULL
23791 };
23792
23793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23795 if (SWIG_arg_fail(1)) SWIG_fail;
23796 {
23797 PyThreadState* __tstate = wxPyBeginAllowThreads();
23798 result = ((wxDateTime const *)arg1)->FormatTime();
23799
23800 wxPyEndAllowThreads(__tstate);
23801 if (PyErr_Occurred()) SWIG_fail;
23802 }
23803 {
23804 #if wxUSE_UNICODE
23805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23806 #else
23807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23808 #endif
23809 }
23810 return resultobj;
23811 fail:
23812 return NULL;
23813 }
23814
23815
23816 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23817 PyObject *resultobj;
23818 wxDateTime *arg1 = (wxDateTime *) 0 ;
23819 wxString result;
23820 PyObject * obj0 = 0 ;
23821 char *kwnames[] = {
23822 (char *) "self", NULL
23823 };
23824
23825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23827 if (SWIG_arg_fail(1)) SWIG_fail;
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 result = ((wxDateTime const *)arg1)->FormatISODate();
23831
23832 wxPyEndAllowThreads(__tstate);
23833 if (PyErr_Occurred()) SWIG_fail;
23834 }
23835 {
23836 #if wxUSE_UNICODE
23837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23838 #else
23839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23840 #endif
23841 }
23842 return resultobj;
23843 fail:
23844 return NULL;
23845 }
23846
23847
23848 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23849 PyObject *resultobj;
23850 wxDateTime *arg1 = (wxDateTime *) 0 ;
23851 wxString result;
23852 PyObject * obj0 = 0 ;
23853 char *kwnames[] = {
23854 (char *) "self", NULL
23855 };
23856
23857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23859 if (SWIG_arg_fail(1)) SWIG_fail;
23860 {
23861 PyThreadState* __tstate = wxPyBeginAllowThreads();
23862 result = ((wxDateTime const *)arg1)->FormatISOTime();
23863
23864 wxPyEndAllowThreads(__tstate);
23865 if (PyErr_Occurred()) SWIG_fail;
23866 }
23867 {
23868 #if wxUSE_UNICODE
23869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23870 #else
23871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23872 #endif
23873 }
23874 return resultobj;
23875 fail:
23876 return NULL;
23877 }
23878
23879
23880 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23881 PyObject *obj;
23882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23883 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23884 Py_INCREF(obj);
23885 return Py_BuildValue((char *)"");
23886 }
23887 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23888 PyObject *resultobj;
23889 long arg1 ;
23890 wxTimeSpan result;
23891 PyObject * obj0 = 0 ;
23892 char *kwnames[] = {
23893 (char *) "sec", NULL
23894 };
23895
23896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23897 {
23898 arg1 = (long)(SWIG_As_long(obj0));
23899 if (SWIG_arg_fail(1)) SWIG_fail;
23900 }
23901 {
23902 PyThreadState* __tstate = wxPyBeginAllowThreads();
23903 result = wxTimeSpan::Seconds(arg1);
23904
23905 wxPyEndAllowThreads(__tstate);
23906 if (PyErr_Occurred()) SWIG_fail;
23907 }
23908 {
23909 wxTimeSpan * resultptr;
23910 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23911 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23912 }
23913 return resultobj;
23914 fail:
23915 return NULL;
23916 }
23917
23918
23919 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23920 PyObject *resultobj;
23921 wxTimeSpan result;
23922 char *kwnames[] = {
23923 NULL
23924 };
23925
23926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23927 {
23928 PyThreadState* __tstate = wxPyBeginAllowThreads();
23929 result = wxTimeSpan::Second();
23930
23931 wxPyEndAllowThreads(__tstate);
23932 if (PyErr_Occurred()) SWIG_fail;
23933 }
23934 {
23935 wxTimeSpan * resultptr;
23936 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23937 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23938 }
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23946 PyObject *resultobj;
23947 long arg1 ;
23948 wxTimeSpan result;
23949 PyObject * obj0 = 0 ;
23950 char *kwnames[] = {
23951 (char *) "min", NULL
23952 };
23953
23954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23955 {
23956 arg1 = (long)(SWIG_As_long(obj0));
23957 if (SWIG_arg_fail(1)) SWIG_fail;
23958 }
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = wxTimeSpan::Minutes(arg1);
23962
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 {
23967 wxTimeSpan * resultptr;
23968 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23969 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23978 PyObject *resultobj;
23979 wxTimeSpan result;
23980 char *kwnames[] = {
23981 NULL
23982 };
23983
23984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23985 {
23986 PyThreadState* __tstate = wxPyBeginAllowThreads();
23987 result = wxTimeSpan::Minute();
23988
23989 wxPyEndAllowThreads(__tstate);
23990 if (PyErr_Occurred()) SWIG_fail;
23991 }
23992 {
23993 wxTimeSpan * resultptr;
23994 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23995 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23996 }
23997 return resultobj;
23998 fail:
23999 return NULL;
24000 }
24001
24002
24003 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24004 PyObject *resultobj;
24005 long arg1 ;
24006 wxTimeSpan result;
24007 PyObject * obj0 = 0 ;
24008 char *kwnames[] = {
24009 (char *) "hours", NULL
24010 };
24011
24012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24013 {
24014 arg1 = (long)(SWIG_As_long(obj0));
24015 if (SWIG_arg_fail(1)) SWIG_fail;
24016 }
24017 {
24018 PyThreadState* __tstate = wxPyBeginAllowThreads();
24019 result = wxTimeSpan::Hours(arg1);
24020
24021 wxPyEndAllowThreads(__tstate);
24022 if (PyErr_Occurred()) SWIG_fail;
24023 }
24024 {
24025 wxTimeSpan * resultptr;
24026 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24027 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24028 }
24029 return resultobj;
24030 fail:
24031 return NULL;
24032 }
24033
24034
24035 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24036 PyObject *resultobj;
24037 wxTimeSpan result;
24038 char *kwnames[] = {
24039 NULL
24040 };
24041
24042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24043 {
24044 PyThreadState* __tstate = wxPyBeginAllowThreads();
24045 result = wxTimeSpan::Hour();
24046
24047 wxPyEndAllowThreads(__tstate);
24048 if (PyErr_Occurred()) SWIG_fail;
24049 }
24050 {
24051 wxTimeSpan * resultptr;
24052 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24053 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24054 }
24055 return resultobj;
24056 fail:
24057 return NULL;
24058 }
24059
24060
24061 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24062 PyObject *resultobj;
24063 long arg1 ;
24064 wxTimeSpan result;
24065 PyObject * obj0 = 0 ;
24066 char *kwnames[] = {
24067 (char *) "days", NULL
24068 };
24069
24070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24071 {
24072 arg1 = (long)(SWIG_As_long(obj0));
24073 if (SWIG_arg_fail(1)) SWIG_fail;
24074 }
24075 {
24076 PyThreadState* __tstate = wxPyBeginAllowThreads();
24077 result = wxTimeSpan::Days(arg1);
24078
24079 wxPyEndAllowThreads(__tstate);
24080 if (PyErr_Occurred()) SWIG_fail;
24081 }
24082 {
24083 wxTimeSpan * resultptr;
24084 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24086 }
24087 return resultobj;
24088 fail:
24089 return NULL;
24090 }
24091
24092
24093 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24094 PyObject *resultobj;
24095 wxTimeSpan result;
24096 char *kwnames[] = {
24097 NULL
24098 };
24099
24100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24101 {
24102 PyThreadState* __tstate = wxPyBeginAllowThreads();
24103 result = wxTimeSpan::Day();
24104
24105 wxPyEndAllowThreads(__tstate);
24106 if (PyErr_Occurred()) SWIG_fail;
24107 }
24108 {
24109 wxTimeSpan * resultptr;
24110 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24111 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24112 }
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24120 PyObject *resultobj;
24121 long arg1 ;
24122 wxTimeSpan result;
24123 PyObject * obj0 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "days", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24129 {
24130 arg1 = (long)(SWIG_As_long(obj0));
24131 if (SWIG_arg_fail(1)) SWIG_fail;
24132 }
24133 {
24134 PyThreadState* __tstate = wxPyBeginAllowThreads();
24135 result = wxTimeSpan::Weeks(arg1);
24136
24137 wxPyEndAllowThreads(__tstate);
24138 if (PyErr_Occurred()) SWIG_fail;
24139 }
24140 {
24141 wxTimeSpan * resultptr;
24142 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24143 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24144 }
24145 return resultobj;
24146 fail:
24147 return NULL;
24148 }
24149
24150
24151 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24152 PyObject *resultobj;
24153 wxTimeSpan result;
24154 char *kwnames[] = {
24155 NULL
24156 };
24157
24158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 result = wxTimeSpan::Week();
24162
24163 wxPyEndAllowThreads(__tstate);
24164 if (PyErr_Occurred()) SWIG_fail;
24165 }
24166 {
24167 wxTimeSpan * resultptr;
24168 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24170 }
24171 return resultobj;
24172 fail:
24173 return NULL;
24174 }
24175
24176
24177 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24178 PyObject *resultobj;
24179 long arg1 = (long) 0 ;
24180 long arg2 = (long) 0 ;
24181 long arg3 = (long) 0 ;
24182 long arg4 = (long) 0 ;
24183 wxTimeSpan *result;
24184 PyObject * obj0 = 0 ;
24185 PyObject * obj1 = 0 ;
24186 PyObject * obj2 = 0 ;
24187 PyObject * obj3 = 0 ;
24188 char *kwnames[] = {
24189 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24190 };
24191
24192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24193 if (obj0) {
24194 {
24195 arg1 = (long)(SWIG_As_long(obj0));
24196 if (SWIG_arg_fail(1)) SWIG_fail;
24197 }
24198 }
24199 if (obj1) {
24200 {
24201 arg2 = (long)(SWIG_As_long(obj1));
24202 if (SWIG_arg_fail(2)) SWIG_fail;
24203 }
24204 }
24205 if (obj2) {
24206 {
24207 arg3 = (long)(SWIG_As_long(obj2));
24208 if (SWIG_arg_fail(3)) SWIG_fail;
24209 }
24210 }
24211 if (obj3) {
24212 {
24213 arg4 = (long)(SWIG_As_long(obj3));
24214 if (SWIG_arg_fail(4)) SWIG_fail;
24215 }
24216 }
24217 {
24218 PyThreadState* __tstate = wxPyBeginAllowThreads();
24219 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24220
24221 wxPyEndAllowThreads(__tstate);
24222 if (PyErr_Occurred()) SWIG_fail;
24223 }
24224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24225 return resultobj;
24226 fail:
24227 return NULL;
24228 }
24229
24230
24231 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24232 PyObject *resultobj;
24233 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24234 PyObject * obj0 = 0 ;
24235 char *kwnames[] = {
24236 (char *) "self", NULL
24237 };
24238
24239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24241 if (SWIG_arg_fail(1)) SWIG_fail;
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 delete arg1;
24245
24246 wxPyEndAllowThreads(__tstate);
24247 if (PyErr_Occurred()) SWIG_fail;
24248 }
24249 Py_INCREF(Py_None); resultobj = Py_None;
24250 return resultobj;
24251 fail:
24252 return NULL;
24253 }
24254
24255
24256 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24257 PyObject *resultobj;
24258 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24259 wxTimeSpan *arg2 = 0 ;
24260 wxTimeSpan *result;
24261 PyObject * obj0 = 0 ;
24262 PyObject * obj1 = 0 ;
24263 char *kwnames[] = {
24264 (char *) "self",(char *) "diff", NULL
24265 };
24266
24267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24269 if (SWIG_arg_fail(1)) SWIG_fail;
24270 {
24271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24272 if (SWIG_arg_fail(2)) SWIG_fail;
24273 if (arg2 == NULL) {
24274 SWIG_null_ref("wxTimeSpan");
24275 }
24276 if (SWIG_arg_fail(2)) SWIG_fail;
24277 }
24278 {
24279 PyThreadState* __tstate = wxPyBeginAllowThreads();
24280 {
24281 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24282 result = (wxTimeSpan *) &_result_ref;
24283 }
24284
24285 wxPyEndAllowThreads(__tstate);
24286 if (PyErr_Occurred()) SWIG_fail;
24287 }
24288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj;
24297 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24298 wxTimeSpan *arg2 = 0 ;
24299 wxTimeSpan *result;
24300 PyObject * obj0 = 0 ;
24301 PyObject * obj1 = 0 ;
24302 char *kwnames[] = {
24303 (char *) "self",(char *) "diff", NULL
24304 };
24305
24306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24308 if (SWIG_arg_fail(1)) SWIG_fail;
24309 {
24310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24311 if (SWIG_arg_fail(2)) SWIG_fail;
24312 if (arg2 == NULL) {
24313 SWIG_null_ref("wxTimeSpan");
24314 }
24315 if (SWIG_arg_fail(2)) SWIG_fail;
24316 }
24317 {
24318 PyThreadState* __tstate = wxPyBeginAllowThreads();
24319 {
24320 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24321 result = (wxTimeSpan *) &_result_ref;
24322 }
24323
24324 wxPyEndAllowThreads(__tstate);
24325 if (PyErr_Occurred()) SWIG_fail;
24326 }
24327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24335 PyObject *resultobj;
24336 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24337 int arg2 ;
24338 wxTimeSpan *result;
24339 PyObject * obj0 = 0 ;
24340 PyObject * obj1 = 0 ;
24341 char *kwnames[] = {
24342 (char *) "self",(char *) "n", NULL
24343 };
24344
24345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24347 if (SWIG_arg_fail(1)) SWIG_fail;
24348 {
24349 arg2 = (int)(SWIG_As_int(obj1));
24350 if (SWIG_arg_fail(2)) SWIG_fail;
24351 }
24352 {
24353 PyThreadState* __tstate = wxPyBeginAllowThreads();
24354 {
24355 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24356 result = (wxTimeSpan *) &_result_ref;
24357 }
24358
24359 wxPyEndAllowThreads(__tstate);
24360 if (PyErr_Occurred()) SWIG_fail;
24361 }
24362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24370 PyObject *resultobj;
24371 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24372 wxTimeSpan *result;
24373 PyObject * obj0 = 0 ;
24374 char *kwnames[] = {
24375 (char *) "self", NULL
24376 };
24377
24378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24380 if (SWIG_arg_fail(1)) SWIG_fail;
24381 {
24382 PyThreadState* __tstate = wxPyBeginAllowThreads();
24383 {
24384 wxTimeSpan &_result_ref = (arg1)->Neg();
24385 result = (wxTimeSpan *) &_result_ref;
24386 }
24387
24388 wxPyEndAllowThreads(__tstate);
24389 if (PyErr_Occurred()) SWIG_fail;
24390 }
24391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24392 return resultobj;
24393 fail:
24394 return NULL;
24395 }
24396
24397
24398 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24399 PyObject *resultobj;
24400 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24401 wxTimeSpan result;
24402 PyObject * obj0 = 0 ;
24403 char *kwnames[] = {
24404 (char *) "self", NULL
24405 };
24406
24407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24409 if (SWIG_arg_fail(1)) SWIG_fail;
24410 {
24411 PyThreadState* __tstate = wxPyBeginAllowThreads();
24412 result = ((wxTimeSpan const *)arg1)->Abs();
24413
24414 wxPyEndAllowThreads(__tstate);
24415 if (PyErr_Occurred()) SWIG_fail;
24416 }
24417 {
24418 wxTimeSpan * resultptr;
24419 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24421 }
24422 return resultobj;
24423 fail:
24424 return NULL;
24425 }
24426
24427
24428 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24429 PyObject *resultobj;
24430 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24431 wxTimeSpan *arg2 = 0 ;
24432 wxTimeSpan *result;
24433 PyObject * obj0 = 0 ;
24434 PyObject * obj1 = 0 ;
24435 char *kwnames[] = {
24436 (char *) "self",(char *) "diff", NULL
24437 };
24438
24439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24441 if (SWIG_arg_fail(1)) SWIG_fail;
24442 {
24443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24444 if (SWIG_arg_fail(2)) SWIG_fail;
24445 if (arg2 == NULL) {
24446 SWIG_null_ref("wxTimeSpan");
24447 }
24448 if (SWIG_arg_fail(2)) SWIG_fail;
24449 }
24450 {
24451 PyThreadState* __tstate = wxPyBeginAllowThreads();
24452 {
24453 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24454 result = (wxTimeSpan *) &_result_ref;
24455 }
24456
24457 wxPyEndAllowThreads(__tstate);
24458 if (PyErr_Occurred()) SWIG_fail;
24459 }
24460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24461 return resultobj;
24462 fail:
24463 return NULL;
24464 }
24465
24466
24467 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24468 PyObject *resultobj;
24469 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24470 wxTimeSpan *arg2 = 0 ;
24471 wxTimeSpan *result;
24472 PyObject * obj0 = 0 ;
24473 PyObject * obj1 = 0 ;
24474 char *kwnames[] = {
24475 (char *) "self",(char *) "diff", NULL
24476 };
24477
24478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24480 if (SWIG_arg_fail(1)) SWIG_fail;
24481 {
24482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24483 if (SWIG_arg_fail(2)) SWIG_fail;
24484 if (arg2 == NULL) {
24485 SWIG_null_ref("wxTimeSpan");
24486 }
24487 if (SWIG_arg_fail(2)) SWIG_fail;
24488 }
24489 {
24490 PyThreadState* __tstate = wxPyBeginAllowThreads();
24491 {
24492 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24493 result = (wxTimeSpan *) &_result_ref;
24494 }
24495
24496 wxPyEndAllowThreads(__tstate);
24497 if (PyErr_Occurred()) SWIG_fail;
24498 }
24499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24500 return resultobj;
24501 fail:
24502 return NULL;
24503 }
24504
24505
24506 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24507 PyObject *resultobj;
24508 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24509 int arg2 ;
24510 wxTimeSpan *result;
24511 PyObject * obj0 = 0 ;
24512 PyObject * obj1 = 0 ;
24513 char *kwnames[] = {
24514 (char *) "self",(char *) "n", NULL
24515 };
24516
24517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24519 if (SWIG_arg_fail(1)) SWIG_fail;
24520 {
24521 arg2 = (int)(SWIG_As_int(obj1));
24522 if (SWIG_arg_fail(2)) SWIG_fail;
24523 }
24524 {
24525 PyThreadState* __tstate = wxPyBeginAllowThreads();
24526 {
24527 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24528 result = (wxTimeSpan *) &_result_ref;
24529 }
24530
24531 wxPyEndAllowThreads(__tstate);
24532 if (PyErr_Occurred()) SWIG_fail;
24533 }
24534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24535 return resultobj;
24536 fail:
24537 return NULL;
24538 }
24539
24540
24541 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24542 PyObject *resultobj;
24543 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24544 wxTimeSpan *result;
24545 PyObject * obj0 = 0 ;
24546 char *kwnames[] = {
24547 (char *) "self", NULL
24548 };
24549
24550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24552 if (SWIG_arg_fail(1)) SWIG_fail;
24553 {
24554 PyThreadState* __tstate = wxPyBeginAllowThreads();
24555 {
24556 wxTimeSpan &_result_ref = (arg1)->operator -();
24557 result = (wxTimeSpan *) &_result_ref;
24558 }
24559
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24564 return resultobj;
24565 fail:
24566 return NULL;
24567 }
24568
24569
24570 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24571 PyObject *resultobj;
24572 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24573 wxTimeSpan *arg2 = 0 ;
24574 wxTimeSpan result;
24575 PyObject * obj0 = 0 ;
24576 PyObject * obj1 = 0 ;
24577 char *kwnames[] = {
24578 (char *) "self",(char *) "other", NULL
24579 };
24580
24581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24583 if (SWIG_arg_fail(1)) SWIG_fail;
24584 {
24585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24586 if (SWIG_arg_fail(2)) SWIG_fail;
24587 if (arg2 == NULL) {
24588 SWIG_null_ref("wxTimeSpan");
24589 }
24590 if (SWIG_arg_fail(2)) SWIG_fail;
24591 }
24592 {
24593 PyThreadState* __tstate = wxPyBeginAllowThreads();
24594 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24595
24596 wxPyEndAllowThreads(__tstate);
24597 if (PyErr_Occurred()) SWIG_fail;
24598 }
24599 {
24600 wxTimeSpan * resultptr;
24601 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24602 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24603 }
24604 return resultobj;
24605 fail:
24606 return NULL;
24607 }
24608
24609
24610 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24611 PyObject *resultobj;
24612 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24613 wxTimeSpan *arg2 = 0 ;
24614 wxTimeSpan result;
24615 PyObject * obj0 = 0 ;
24616 PyObject * obj1 = 0 ;
24617 char *kwnames[] = {
24618 (char *) "self",(char *) "other", NULL
24619 };
24620
24621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24623 if (SWIG_arg_fail(1)) SWIG_fail;
24624 {
24625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24626 if (SWIG_arg_fail(2)) SWIG_fail;
24627 if (arg2 == NULL) {
24628 SWIG_null_ref("wxTimeSpan");
24629 }
24630 if (SWIG_arg_fail(2)) SWIG_fail;
24631 }
24632 {
24633 PyThreadState* __tstate = wxPyBeginAllowThreads();
24634 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24635
24636 wxPyEndAllowThreads(__tstate);
24637 if (PyErr_Occurred()) SWIG_fail;
24638 }
24639 {
24640 wxTimeSpan * resultptr;
24641 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24643 }
24644 return resultobj;
24645 fail:
24646 return NULL;
24647 }
24648
24649
24650 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24651 PyObject *resultobj;
24652 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24653 int arg2 ;
24654 wxTimeSpan result;
24655 PyObject * obj0 = 0 ;
24656 PyObject * obj1 = 0 ;
24657 char *kwnames[] = {
24658 (char *) "self",(char *) "n", NULL
24659 };
24660
24661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24663 if (SWIG_arg_fail(1)) SWIG_fail;
24664 {
24665 arg2 = (int)(SWIG_As_int(obj1));
24666 if (SWIG_arg_fail(2)) SWIG_fail;
24667 }
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 result = wxTimeSpan___mul__(arg1,arg2);
24671
24672 wxPyEndAllowThreads(__tstate);
24673 if (PyErr_Occurred()) SWIG_fail;
24674 }
24675 {
24676 wxTimeSpan * resultptr;
24677 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24678 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24679 }
24680 return resultobj;
24681 fail:
24682 return NULL;
24683 }
24684
24685
24686 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24687 PyObject *resultobj;
24688 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24689 int arg2 ;
24690 wxTimeSpan result;
24691 PyObject * obj0 = 0 ;
24692 PyObject * obj1 = 0 ;
24693 char *kwnames[] = {
24694 (char *) "self",(char *) "n", NULL
24695 };
24696
24697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24699 if (SWIG_arg_fail(1)) SWIG_fail;
24700 {
24701 arg2 = (int)(SWIG_As_int(obj1));
24702 if (SWIG_arg_fail(2)) SWIG_fail;
24703 }
24704 {
24705 PyThreadState* __tstate = wxPyBeginAllowThreads();
24706 result = wxTimeSpan___rmul__(arg1,arg2);
24707
24708 wxPyEndAllowThreads(__tstate);
24709 if (PyErr_Occurred()) SWIG_fail;
24710 }
24711 {
24712 wxTimeSpan * resultptr;
24713 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24714 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24715 }
24716 return resultobj;
24717 fail:
24718 return NULL;
24719 }
24720
24721
24722 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24723 PyObject *resultobj;
24724 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24725 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24726 bool result;
24727 PyObject * obj0 = 0 ;
24728 PyObject * obj1 = 0 ;
24729 char *kwnames[] = {
24730 (char *) "self",(char *) "other", NULL
24731 };
24732
24733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24735 if (SWIG_arg_fail(1)) SWIG_fail;
24736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24737 if (SWIG_arg_fail(2)) SWIG_fail;
24738 {
24739 PyThreadState* __tstate = wxPyBeginAllowThreads();
24740 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24741
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 {
24746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24747 }
24748 return resultobj;
24749 fail:
24750 return NULL;
24751 }
24752
24753
24754 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24755 PyObject *resultobj;
24756 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24757 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24758 bool result;
24759 PyObject * obj0 = 0 ;
24760 PyObject * obj1 = 0 ;
24761 char *kwnames[] = {
24762 (char *) "self",(char *) "other", NULL
24763 };
24764
24765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24767 if (SWIG_arg_fail(1)) SWIG_fail;
24768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24769 if (SWIG_arg_fail(2)) SWIG_fail;
24770 {
24771 PyThreadState* __tstate = wxPyBeginAllowThreads();
24772 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24773
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 {
24778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24779 }
24780 return resultobj;
24781 fail:
24782 return NULL;
24783 }
24784
24785
24786 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24787 PyObject *resultobj;
24788 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24789 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24790 bool result;
24791 PyObject * obj0 = 0 ;
24792 PyObject * obj1 = 0 ;
24793 char *kwnames[] = {
24794 (char *) "self",(char *) "other", NULL
24795 };
24796
24797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24799 if (SWIG_arg_fail(1)) SWIG_fail;
24800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24801 if (SWIG_arg_fail(2)) SWIG_fail;
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24805
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24811 }
24812 return resultobj;
24813 fail:
24814 return NULL;
24815 }
24816
24817
24818 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24819 PyObject *resultobj;
24820 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24821 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24822 bool result;
24823 PyObject * obj0 = 0 ;
24824 PyObject * obj1 = 0 ;
24825 char *kwnames[] = {
24826 (char *) "self",(char *) "other", NULL
24827 };
24828
24829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24831 if (SWIG_arg_fail(1)) SWIG_fail;
24832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24833 if (SWIG_arg_fail(2)) SWIG_fail;
24834 {
24835 PyThreadState* __tstate = wxPyBeginAllowThreads();
24836 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24837
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 {
24842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24843 }
24844 return resultobj;
24845 fail:
24846 return NULL;
24847 }
24848
24849
24850 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj;
24852 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24853 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24854 bool result;
24855 PyObject * obj0 = 0 ;
24856 PyObject * obj1 = 0 ;
24857 char *kwnames[] = {
24858 (char *) "self",(char *) "other", NULL
24859 };
24860
24861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24863 if (SWIG_arg_fail(1)) SWIG_fail;
24864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24865 if (SWIG_arg_fail(2)) SWIG_fail;
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24869
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 {
24874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24875 }
24876 return resultobj;
24877 fail:
24878 return NULL;
24879 }
24880
24881
24882 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24883 PyObject *resultobj;
24884 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24885 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24886 bool result;
24887 PyObject * obj0 = 0 ;
24888 PyObject * obj1 = 0 ;
24889 char *kwnames[] = {
24890 (char *) "self",(char *) "other", NULL
24891 };
24892
24893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24895 if (SWIG_arg_fail(1)) SWIG_fail;
24896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24897 if (SWIG_arg_fail(2)) SWIG_fail;
24898 {
24899 PyThreadState* __tstate = wxPyBeginAllowThreads();
24900 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24901
24902 wxPyEndAllowThreads(__tstate);
24903 if (PyErr_Occurred()) SWIG_fail;
24904 }
24905 {
24906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24907 }
24908 return resultobj;
24909 fail:
24910 return NULL;
24911 }
24912
24913
24914 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24915 PyObject *resultobj;
24916 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24917 bool result;
24918 PyObject * obj0 = 0 ;
24919 char *kwnames[] = {
24920 (char *) "self", NULL
24921 };
24922
24923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24925 if (SWIG_arg_fail(1)) SWIG_fail;
24926 {
24927 PyThreadState* __tstate = wxPyBeginAllowThreads();
24928 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24929
24930 wxPyEndAllowThreads(__tstate);
24931 if (PyErr_Occurred()) SWIG_fail;
24932 }
24933 {
24934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24935 }
24936 return resultobj;
24937 fail:
24938 return NULL;
24939 }
24940
24941
24942 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24943 PyObject *resultobj;
24944 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24945 bool result;
24946 PyObject * obj0 = 0 ;
24947 char *kwnames[] = {
24948 (char *) "self", NULL
24949 };
24950
24951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24953 if (SWIG_arg_fail(1)) SWIG_fail;
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24957
24958 wxPyEndAllowThreads(__tstate);
24959 if (PyErr_Occurred()) SWIG_fail;
24960 }
24961 {
24962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24963 }
24964 return resultobj;
24965 fail:
24966 return NULL;
24967 }
24968
24969
24970 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24971 PyObject *resultobj;
24972 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24973 bool result;
24974 PyObject * obj0 = 0 ;
24975 char *kwnames[] = {
24976 (char *) "self", NULL
24977 };
24978
24979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24981 if (SWIG_arg_fail(1)) SWIG_fail;
24982 {
24983 PyThreadState* __tstate = wxPyBeginAllowThreads();
24984 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24985
24986 wxPyEndAllowThreads(__tstate);
24987 if (PyErr_Occurred()) SWIG_fail;
24988 }
24989 {
24990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24991 }
24992 return resultobj;
24993 fail:
24994 return NULL;
24995 }
24996
24997
24998 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24999 PyObject *resultobj;
25000 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25001 wxTimeSpan *arg2 = 0 ;
25002 bool result;
25003 PyObject * obj0 = 0 ;
25004 PyObject * obj1 = 0 ;
25005 char *kwnames[] = {
25006 (char *) "self",(char *) "ts", NULL
25007 };
25008
25009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25011 if (SWIG_arg_fail(1)) SWIG_fail;
25012 {
25013 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25014 if (SWIG_arg_fail(2)) SWIG_fail;
25015 if (arg2 == NULL) {
25016 SWIG_null_ref("wxTimeSpan");
25017 }
25018 if (SWIG_arg_fail(2)) SWIG_fail;
25019 }
25020 {
25021 PyThreadState* __tstate = wxPyBeginAllowThreads();
25022 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25023
25024 wxPyEndAllowThreads(__tstate);
25025 if (PyErr_Occurred()) SWIG_fail;
25026 }
25027 {
25028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25029 }
25030 return resultobj;
25031 fail:
25032 return NULL;
25033 }
25034
25035
25036 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25037 PyObject *resultobj;
25038 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25039 wxTimeSpan *arg2 = 0 ;
25040 bool result;
25041 PyObject * obj0 = 0 ;
25042 PyObject * obj1 = 0 ;
25043 char *kwnames[] = {
25044 (char *) "self",(char *) "ts", NULL
25045 };
25046
25047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25049 if (SWIG_arg_fail(1)) SWIG_fail;
25050 {
25051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25052 if (SWIG_arg_fail(2)) SWIG_fail;
25053 if (arg2 == NULL) {
25054 SWIG_null_ref("wxTimeSpan");
25055 }
25056 if (SWIG_arg_fail(2)) SWIG_fail;
25057 }
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25061
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 {
25066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25067 }
25068 return resultobj;
25069 fail:
25070 return NULL;
25071 }
25072
25073
25074 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25075 PyObject *resultobj;
25076 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25077 wxTimeSpan *arg2 = 0 ;
25078 bool result;
25079 PyObject * obj0 = 0 ;
25080 PyObject * obj1 = 0 ;
25081 char *kwnames[] = {
25082 (char *) "self",(char *) "t", NULL
25083 };
25084
25085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25087 if (SWIG_arg_fail(1)) SWIG_fail;
25088 {
25089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25090 if (SWIG_arg_fail(2)) SWIG_fail;
25091 if (arg2 == NULL) {
25092 SWIG_null_ref("wxTimeSpan");
25093 }
25094 if (SWIG_arg_fail(2)) SWIG_fail;
25095 }
25096 {
25097 PyThreadState* __tstate = wxPyBeginAllowThreads();
25098 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25099
25100 wxPyEndAllowThreads(__tstate);
25101 if (PyErr_Occurred()) SWIG_fail;
25102 }
25103 {
25104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25105 }
25106 return resultobj;
25107 fail:
25108 return NULL;
25109 }
25110
25111
25112 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25113 PyObject *resultobj;
25114 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25115 int result;
25116 PyObject * obj0 = 0 ;
25117 char *kwnames[] = {
25118 (char *) "self", NULL
25119 };
25120
25121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25123 if (SWIG_arg_fail(1)) SWIG_fail;
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25127
25128 wxPyEndAllowThreads(__tstate);
25129 if (PyErr_Occurred()) SWIG_fail;
25130 }
25131 {
25132 resultobj = SWIG_From_int((int)(result));
25133 }
25134 return resultobj;
25135 fail:
25136 return NULL;
25137 }
25138
25139
25140 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25141 PyObject *resultobj;
25142 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25143 int result;
25144 PyObject * obj0 = 0 ;
25145 char *kwnames[] = {
25146 (char *) "self", NULL
25147 };
25148
25149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25151 if (SWIG_arg_fail(1)) SWIG_fail;
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25155
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 {
25160 resultobj = SWIG_From_int((int)(result));
25161 }
25162 return resultobj;
25163 fail:
25164 return NULL;
25165 }
25166
25167
25168 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25169 PyObject *resultobj;
25170 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25171 int result;
25172 PyObject * obj0 = 0 ;
25173 char *kwnames[] = {
25174 (char *) "self", NULL
25175 };
25176
25177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25179 if (SWIG_arg_fail(1)) SWIG_fail;
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25183
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 {
25188 resultobj = SWIG_From_int((int)(result));
25189 }
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25197 PyObject *resultobj;
25198 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25199 int result;
25200 PyObject * obj0 = 0 ;
25201 char *kwnames[] = {
25202 (char *) "self", NULL
25203 };
25204
25205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25207 if (SWIG_arg_fail(1)) SWIG_fail;
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25211
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 {
25216 resultobj = SWIG_From_int((int)(result));
25217 }
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj;
25226 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25227 wxLongLong result;
25228 PyObject * obj0 = 0 ;
25229 char *kwnames[] = {
25230 (char *) "self", NULL
25231 };
25232
25233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25235 if (SWIG_arg_fail(1)) SWIG_fail;
25236 {
25237 PyThreadState* __tstate = wxPyBeginAllowThreads();
25238 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25239
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 {
25244 PyObject *hi, *lo, *shifter, *shifted;
25245 hi = PyLong_FromLong( (&result)->GetHi() );
25246 lo = PyLong_FromLong( (&result)->GetLo() );
25247 shifter = PyLong_FromLong(32);
25248 shifted = PyNumber_Lshift(hi, shifter);
25249 resultobj = PyNumber_Or(shifted, lo);
25250 Py_DECREF(hi);
25251 Py_DECREF(lo);
25252 Py_DECREF(shifter);
25253 Py_DECREF(shifted);
25254 }
25255 return resultobj;
25256 fail:
25257 return NULL;
25258 }
25259
25260
25261 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25262 PyObject *resultobj;
25263 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25264 wxLongLong result;
25265 PyObject * obj0 = 0 ;
25266 char *kwnames[] = {
25267 (char *) "self", NULL
25268 };
25269
25270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25272 if (SWIG_arg_fail(1)) SWIG_fail;
25273 {
25274 PyThreadState* __tstate = wxPyBeginAllowThreads();
25275 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25276
25277 wxPyEndAllowThreads(__tstate);
25278 if (PyErr_Occurred()) SWIG_fail;
25279 }
25280 {
25281 PyObject *hi, *lo, *shifter, *shifted;
25282 hi = PyLong_FromLong( (&result)->GetHi() );
25283 lo = PyLong_FromLong( (&result)->GetLo() );
25284 shifter = PyLong_FromLong(32);
25285 shifted = PyNumber_Lshift(hi, shifter);
25286 resultobj = PyNumber_Or(shifted, lo);
25287 Py_DECREF(hi);
25288 Py_DECREF(lo);
25289 Py_DECREF(shifter);
25290 Py_DECREF(shifted);
25291 }
25292 return resultobj;
25293 fail:
25294 return NULL;
25295 }
25296
25297
25298 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25299 PyObject *resultobj;
25300 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25301 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25302 wxString *arg2 = (wxString *) &arg2_defvalue ;
25303 wxString result;
25304 bool temp2 = false ;
25305 PyObject * obj0 = 0 ;
25306 PyObject * obj1 = 0 ;
25307 char *kwnames[] = {
25308 (char *) "self",(char *) "format", NULL
25309 };
25310
25311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25313 if (SWIG_arg_fail(1)) SWIG_fail;
25314 if (obj1) {
25315 {
25316 arg2 = wxString_in_helper(obj1);
25317 if (arg2 == NULL) SWIG_fail;
25318 temp2 = true;
25319 }
25320 }
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25324
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 {
25329 #if wxUSE_UNICODE
25330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25331 #else
25332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25333 #endif
25334 }
25335 {
25336 if (temp2)
25337 delete arg2;
25338 }
25339 return resultobj;
25340 fail:
25341 {
25342 if (temp2)
25343 delete arg2;
25344 }
25345 return NULL;
25346 }
25347
25348
25349 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25350 PyObject *obj;
25351 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25352 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25353 Py_INCREF(obj);
25354 return Py_BuildValue((char *)"");
25355 }
25356 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25357 PyObject *resultobj;
25358 int arg1 = (int) 0 ;
25359 int arg2 = (int) 0 ;
25360 int arg3 = (int) 0 ;
25361 int arg4 = (int) 0 ;
25362 wxDateSpan *result;
25363 PyObject * obj0 = 0 ;
25364 PyObject * obj1 = 0 ;
25365 PyObject * obj2 = 0 ;
25366 PyObject * obj3 = 0 ;
25367 char *kwnames[] = {
25368 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25369 };
25370
25371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25372 if (obj0) {
25373 {
25374 arg1 = (int)(SWIG_As_int(obj0));
25375 if (SWIG_arg_fail(1)) SWIG_fail;
25376 }
25377 }
25378 if (obj1) {
25379 {
25380 arg2 = (int)(SWIG_As_int(obj1));
25381 if (SWIG_arg_fail(2)) SWIG_fail;
25382 }
25383 }
25384 if (obj2) {
25385 {
25386 arg3 = (int)(SWIG_As_int(obj2));
25387 if (SWIG_arg_fail(3)) SWIG_fail;
25388 }
25389 }
25390 if (obj3) {
25391 {
25392 arg4 = (int)(SWIG_As_int(obj3));
25393 if (SWIG_arg_fail(4)) SWIG_fail;
25394 }
25395 }
25396 {
25397 PyThreadState* __tstate = wxPyBeginAllowThreads();
25398 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25399
25400 wxPyEndAllowThreads(__tstate);
25401 if (PyErr_Occurred()) SWIG_fail;
25402 }
25403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25404 return resultobj;
25405 fail:
25406 return NULL;
25407 }
25408
25409
25410 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25411 PyObject *resultobj;
25412 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25413 PyObject * obj0 = 0 ;
25414 char *kwnames[] = {
25415 (char *) "self", NULL
25416 };
25417
25418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25420 if (SWIG_arg_fail(1)) SWIG_fail;
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 delete arg1;
25424
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 Py_INCREF(Py_None); resultobj = Py_None;
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25436 PyObject *resultobj;
25437 int arg1 ;
25438 wxDateSpan result;
25439 PyObject * obj0 = 0 ;
25440 char *kwnames[] = {
25441 (char *) "days", NULL
25442 };
25443
25444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25445 {
25446 arg1 = (int)(SWIG_As_int(obj0));
25447 if (SWIG_arg_fail(1)) SWIG_fail;
25448 }
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 result = wxDateSpan::Days(arg1);
25452
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 {
25457 wxDateSpan * resultptr;
25458 resultptr = new wxDateSpan((wxDateSpan &)(result));
25459 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25460 }
25461 return resultobj;
25462 fail:
25463 return NULL;
25464 }
25465
25466
25467 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25468 PyObject *resultobj;
25469 wxDateSpan result;
25470 char *kwnames[] = {
25471 NULL
25472 };
25473
25474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25475 {
25476 PyThreadState* __tstate = wxPyBeginAllowThreads();
25477 result = wxDateSpan::Day();
25478
25479 wxPyEndAllowThreads(__tstate);
25480 if (PyErr_Occurred()) SWIG_fail;
25481 }
25482 {
25483 wxDateSpan * resultptr;
25484 resultptr = new wxDateSpan((wxDateSpan &)(result));
25485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25486 }
25487 return resultobj;
25488 fail:
25489 return NULL;
25490 }
25491
25492
25493 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25494 PyObject *resultobj;
25495 int arg1 ;
25496 wxDateSpan result;
25497 PyObject * obj0 = 0 ;
25498 char *kwnames[] = {
25499 (char *) "weeks", NULL
25500 };
25501
25502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25503 {
25504 arg1 = (int)(SWIG_As_int(obj0));
25505 if (SWIG_arg_fail(1)) SWIG_fail;
25506 }
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 result = wxDateSpan::Weeks(arg1);
25510
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 {
25515 wxDateSpan * resultptr;
25516 resultptr = new wxDateSpan((wxDateSpan &)(result));
25517 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25518 }
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25526 PyObject *resultobj;
25527 wxDateSpan result;
25528 char *kwnames[] = {
25529 NULL
25530 };
25531
25532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25533 {
25534 PyThreadState* __tstate = wxPyBeginAllowThreads();
25535 result = wxDateSpan::Week();
25536
25537 wxPyEndAllowThreads(__tstate);
25538 if (PyErr_Occurred()) SWIG_fail;
25539 }
25540 {
25541 wxDateSpan * resultptr;
25542 resultptr = new wxDateSpan((wxDateSpan &)(result));
25543 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25544 }
25545 return resultobj;
25546 fail:
25547 return NULL;
25548 }
25549
25550
25551 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25552 PyObject *resultobj;
25553 int arg1 ;
25554 wxDateSpan result;
25555 PyObject * obj0 = 0 ;
25556 char *kwnames[] = {
25557 (char *) "mon", NULL
25558 };
25559
25560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25561 {
25562 arg1 = (int)(SWIG_As_int(obj0));
25563 if (SWIG_arg_fail(1)) SWIG_fail;
25564 }
25565 {
25566 PyThreadState* __tstate = wxPyBeginAllowThreads();
25567 result = wxDateSpan::Months(arg1);
25568
25569 wxPyEndAllowThreads(__tstate);
25570 if (PyErr_Occurred()) SWIG_fail;
25571 }
25572 {
25573 wxDateSpan * resultptr;
25574 resultptr = new wxDateSpan((wxDateSpan &)(result));
25575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25576 }
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25584 PyObject *resultobj;
25585 wxDateSpan result;
25586 char *kwnames[] = {
25587 NULL
25588 };
25589
25590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25591 {
25592 PyThreadState* __tstate = wxPyBeginAllowThreads();
25593 result = wxDateSpan::Month();
25594
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 {
25599 wxDateSpan * resultptr;
25600 resultptr = new wxDateSpan((wxDateSpan &)(result));
25601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25602 }
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj;
25611 int arg1 ;
25612 wxDateSpan result;
25613 PyObject * obj0 = 0 ;
25614 char *kwnames[] = {
25615 (char *) "years", NULL
25616 };
25617
25618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25619 {
25620 arg1 = (int)(SWIG_As_int(obj0));
25621 if (SWIG_arg_fail(1)) SWIG_fail;
25622 }
25623 {
25624 PyThreadState* __tstate = wxPyBeginAllowThreads();
25625 result = wxDateSpan::Years(arg1);
25626
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 {
25631 wxDateSpan * resultptr;
25632 resultptr = new wxDateSpan((wxDateSpan &)(result));
25633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25634 }
25635 return resultobj;
25636 fail:
25637 return NULL;
25638 }
25639
25640
25641 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25642 PyObject *resultobj;
25643 wxDateSpan result;
25644 char *kwnames[] = {
25645 NULL
25646 };
25647
25648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25649 {
25650 PyThreadState* __tstate = wxPyBeginAllowThreads();
25651 result = wxDateSpan::Year();
25652
25653 wxPyEndAllowThreads(__tstate);
25654 if (PyErr_Occurred()) SWIG_fail;
25655 }
25656 {
25657 wxDateSpan * resultptr;
25658 resultptr = new wxDateSpan((wxDateSpan &)(result));
25659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25660 }
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj;
25669 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25670 int arg2 ;
25671 wxDateSpan *result;
25672 PyObject * obj0 = 0 ;
25673 PyObject * obj1 = 0 ;
25674 char *kwnames[] = {
25675 (char *) "self",(char *) "n", NULL
25676 };
25677
25678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25680 if (SWIG_arg_fail(1)) SWIG_fail;
25681 {
25682 arg2 = (int)(SWIG_As_int(obj1));
25683 if (SWIG_arg_fail(2)) SWIG_fail;
25684 }
25685 {
25686 PyThreadState* __tstate = wxPyBeginAllowThreads();
25687 {
25688 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25689 result = (wxDateSpan *) &_result_ref;
25690 }
25691
25692 wxPyEndAllowThreads(__tstate);
25693 if (PyErr_Occurred()) SWIG_fail;
25694 }
25695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj;
25704 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25705 int arg2 ;
25706 wxDateSpan *result;
25707 PyObject * obj0 = 0 ;
25708 PyObject * obj1 = 0 ;
25709 char *kwnames[] = {
25710 (char *) "self",(char *) "n", NULL
25711 };
25712
25713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25715 if (SWIG_arg_fail(1)) SWIG_fail;
25716 {
25717 arg2 = (int)(SWIG_As_int(obj1));
25718 if (SWIG_arg_fail(2)) SWIG_fail;
25719 }
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 {
25723 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25724 result = (wxDateSpan *) &_result_ref;
25725 }
25726
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25738 PyObject *resultobj;
25739 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25740 int arg2 ;
25741 wxDateSpan *result;
25742 PyObject * obj0 = 0 ;
25743 PyObject * obj1 = 0 ;
25744 char *kwnames[] = {
25745 (char *) "self",(char *) "n", NULL
25746 };
25747
25748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25750 if (SWIG_arg_fail(1)) SWIG_fail;
25751 {
25752 arg2 = (int)(SWIG_As_int(obj1));
25753 if (SWIG_arg_fail(2)) SWIG_fail;
25754 }
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 {
25758 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25759 result = (wxDateSpan *) &_result_ref;
25760 }
25761
25762 wxPyEndAllowThreads(__tstate);
25763 if (PyErr_Occurred()) SWIG_fail;
25764 }
25765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25766 return resultobj;
25767 fail:
25768 return NULL;
25769 }
25770
25771
25772 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25773 PyObject *resultobj;
25774 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25775 int arg2 ;
25776 wxDateSpan *result;
25777 PyObject * obj0 = 0 ;
25778 PyObject * obj1 = 0 ;
25779 char *kwnames[] = {
25780 (char *) "self",(char *) "n", NULL
25781 };
25782
25783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25785 if (SWIG_arg_fail(1)) SWIG_fail;
25786 {
25787 arg2 = (int)(SWIG_As_int(obj1));
25788 if (SWIG_arg_fail(2)) SWIG_fail;
25789 }
25790 {
25791 PyThreadState* __tstate = wxPyBeginAllowThreads();
25792 {
25793 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25794 result = (wxDateSpan *) &_result_ref;
25795 }
25796
25797 wxPyEndAllowThreads(__tstate);
25798 if (PyErr_Occurred()) SWIG_fail;
25799 }
25800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25801 return resultobj;
25802 fail:
25803 return NULL;
25804 }
25805
25806
25807 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25808 PyObject *resultobj;
25809 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25810 int result;
25811 PyObject * obj0 = 0 ;
25812 char *kwnames[] = {
25813 (char *) "self", NULL
25814 };
25815
25816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25818 if (SWIG_arg_fail(1)) SWIG_fail;
25819 {
25820 PyThreadState* __tstate = wxPyBeginAllowThreads();
25821 result = (int)((wxDateSpan const *)arg1)->GetYears();
25822
25823 wxPyEndAllowThreads(__tstate);
25824 if (PyErr_Occurred()) SWIG_fail;
25825 }
25826 {
25827 resultobj = SWIG_From_int((int)(result));
25828 }
25829 return resultobj;
25830 fail:
25831 return NULL;
25832 }
25833
25834
25835 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25836 PyObject *resultobj;
25837 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25838 int result;
25839 PyObject * obj0 = 0 ;
25840 char *kwnames[] = {
25841 (char *) "self", NULL
25842 };
25843
25844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25846 if (SWIG_arg_fail(1)) SWIG_fail;
25847 {
25848 PyThreadState* __tstate = wxPyBeginAllowThreads();
25849 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25850
25851 wxPyEndAllowThreads(__tstate);
25852 if (PyErr_Occurred()) SWIG_fail;
25853 }
25854 {
25855 resultobj = SWIG_From_int((int)(result));
25856 }
25857 return resultobj;
25858 fail:
25859 return NULL;
25860 }
25861
25862
25863 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25864 PyObject *resultobj;
25865 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25866 int result;
25867 PyObject * obj0 = 0 ;
25868 char *kwnames[] = {
25869 (char *) "self", NULL
25870 };
25871
25872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25874 if (SWIG_arg_fail(1)) SWIG_fail;
25875 {
25876 PyThreadState* __tstate = wxPyBeginAllowThreads();
25877 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25878
25879 wxPyEndAllowThreads(__tstate);
25880 if (PyErr_Occurred()) SWIG_fail;
25881 }
25882 {
25883 resultobj = SWIG_From_int((int)(result));
25884 }
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25892 PyObject *resultobj;
25893 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25894 int result;
25895 PyObject * obj0 = 0 ;
25896 char *kwnames[] = {
25897 (char *) "self", NULL
25898 };
25899
25900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25902 if (SWIG_arg_fail(1)) SWIG_fail;
25903 {
25904 PyThreadState* __tstate = wxPyBeginAllowThreads();
25905 result = (int)((wxDateSpan const *)arg1)->GetDays();
25906
25907 wxPyEndAllowThreads(__tstate);
25908 if (PyErr_Occurred()) SWIG_fail;
25909 }
25910 {
25911 resultobj = SWIG_From_int((int)(result));
25912 }
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25920 PyObject *resultobj;
25921 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25922 int result;
25923 PyObject * obj0 = 0 ;
25924 char *kwnames[] = {
25925 (char *) "self", NULL
25926 };
25927
25928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25930 if (SWIG_arg_fail(1)) SWIG_fail;
25931 {
25932 PyThreadState* __tstate = wxPyBeginAllowThreads();
25933 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25934
25935 wxPyEndAllowThreads(__tstate);
25936 if (PyErr_Occurred()) SWIG_fail;
25937 }
25938 {
25939 resultobj = SWIG_From_int((int)(result));
25940 }
25941 return resultobj;
25942 fail:
25943 return NULL;
25944 }
25945
25946
25947 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25948 PyObject *resultobj;
25949 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25950 wxDateSpan *arg2 = 0 ;
25951 wxDateSpan *result;
25952 PyObject * obj0 = 0 ;
25953 PyObject * obj1 = 0 ;
25954 char *kwnames[] = {
25955 (char *) "self",(char *) "other", NULL
25956 };
25957
25958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25960 if (SWIG_arg_fail(1)) SWIG_fail;
25961 {
25962 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25963 if (SWIG_arg_fail(2)) SWIG_fail;
25964 if (arg2 == NULL) {
25965 SWIG_null_ref("wxDateSpan");
25966 }
25967 if (SWIG_arg_fail(2)) SWIG_fail;
25968 }
25969 {
25970 PyThreadState* __tstate = wxPyBeginAllowThreads();
25971 {
25972 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25973 result = (wxDateSpan *) &_result_ref;
25974 }
25975
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj;
25988 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25989 wxDateSpan *arg2 = 0 ;
25990 wxDateSpan *result;
25991 PyObject * obj0 = 0 ;
25992 PyObject * obj1 = 0 ;
25993 char *kwnames[] = {
25994 (char *) "self",(char *) "other", NULL
25995 };
25996
25997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25999 if (SWIG_arg_fail(1)) SWIG_fail;
26000 {
26001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26002 if (SWIG_arg_fail(2)) SWIG_fail;
26003 if (arg2 == NULL) {
26004 SWIG_null_ref("wxDateSpan");
26005 }
26006 if (SWIG_arg_fail(2)) SWIG_fail;
26007 }
26008 {
26009 PyThreadState* __tstate = wxPyBeginAllowThreads();
26010 {
26011 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26012 result = (wxDateSpan *) &_result_ref;
26013 }
26014
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj;
26027 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26028 wxDateSpan *result;
26029 PyObject * obj0 = 0 ;
26030 char *kwnames[] = {
26031 (char *) "self", NULL
26032 };
26033
26034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26036 if (SWIG_arg_fail(1)) SWIG_fail;
26037 {
26038 PyThreadState* __tstate = wxPyBeginAllowThreads();
26039 {
26040 wxDateSpan &_result_ref = (arg1)->Neg();
26041 result = (wxDateSpan *) &_result_ref;
26042 }
26043
26044 wxPyEndAllowThreads(__tstate);
26045 if (PyErr_Occurred()) SWIG_fail;
26046 }
26047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj;
26056 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26057 int arg2 ;
26058 wxDateSpan *result;
26059 PyObject * obj0 = 0 ;
26060 PyObject * obj1 = 0 ;
26061 char *kwnames[] = {
26062 (char *) "self",(char *) "factor", NULL
26063 };
26064
26065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26067 if (SWIG_arg_fail(1)) SWIG_fail;
26068 {
26069 arg2 = (int)(SWIG_As_int(obj1));
26070 if (SWIG_arg_fail(2)) SWIG_fail;
26071 }
26072 {
26073 PyThreadState* __tstate = wxPyBeginAllowThreads();
26074 {
26075 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26076 result = (wxDateSpan *) &_result_ref;
26077 }
26078
26079 wxPyEndAllowThreads(__tstate);
26080 if (PyErr_Occurred()) SWIG_fail;
26081 }
26082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26083 return resultobj;
26084 fail:
26085 return NULL;
26086 }
26087
26088
26089 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26090 PyObject *resultobj;
26091 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26092 wxDateSpan *arg2 = 0 ;
26093 wxDateSpan *result;
26094 PyObject * obj0 = 0 ;
26095 PyObject * obj1 = 0 ;
26096 char *kwnames[] = {
26097 (char *) "self",(char *) "other", NULL
26098 };
26099
26100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26102 if (SWIG_arg_fail(1)) SWIG_fail;
26103 {
26104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26105 if (SWIG_arg_fail(2)) SWIG_fail;
26106 if (arg2 == NULL) {
26107 SWIG_null_ref("wxDateSpan");
26108 }
26109 if (SWIG_arg_fail(2)) SWIG_fail;
26110 }
26111 {
26112 PyThreadState* __tstate = wxPyBeginAllowThreads();
26113 {
26114 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26115 result = (wxDateSpan *) &_result_ref;
26116 }
26117
26118 wxPyEndAllowThreads(__tstate);
26119 if (PyErr_Occurred()) SWIG_fail;
26120 }
26121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26129 PyObject *resultobj;
26130 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26131 wxDateSpan *arg2 = 0 ;
26132 wxDateSpan *result;
26133 PyObject * obj0 = 0 ;
26134 PyObject * obj1 = 0 ;
26135 char *kwnames[] = {
26136 (char *) "self",(char *) "other", NULL
26137 };
26138
26139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26141 if (SWIG_arg_fail(1)) SWIG_fail;
26142 {
26143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26144 if (SWIG_arg_fail(2)) SWIG_fail;
26145 if (arg2 == NULL) {
26146 SWIG_null_ref("wxDateSpan");
26147 }
26148 if (SWIG_arg_fail(2)) SWIG_fail;
26149 }
26150 {
26151 PyThreadState* __tstate = wxPyBeginAllowThreads();
26152 {
26153 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26154 result = (wxDateSpan *) &_result_ref;
26155 }
26156
26157 wxPyEndAllowThreads(__tstate);
26158 if (PyErr_Occurred()) SWIG_fail;
26159 }
26160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26161 return resultobj;
26162 fail:
26163 return NULL;
26164 }
26165
26166
26167 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26168 PyObject *resultobj;
26169 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26170 wxDateSpan *result;
26171 PyObject * obj0 = 0 ;
26172 char *kwnames[] = {
26173 (char *) "self", NULL
26174 };
26175
26176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26178 if (SWIG_arg_fail(1)) SWIG_fail;
26179 {
26180 PyThreadState* __tstate = wxPyBeginAllowThreads();
26181 {
26182 wxDateSpan &_result_ref = (arg1)->operator -();
26183 result = (wxDateSpan *) &_result_ref;
26184 }
26185
26186 wxPyEndAllowThreads(__tstate);
26187 if (PyErr_Occurred()) SWIG_fail;
26188 }
26189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26190 return resultobj;
26191 fail:
26192 return NULL;
26193 }
26194
26195
26196 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26197 PyObject *resultobj;
26198 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26199 int arg2 ;
26200 wxDateSpan *result;
26201 PyObject * obj0 = 0 ;
26202 PyObject * obj1 = 0 ;
26203 char *kwnames[] = {
26204 (char *) "self",(char *) "factor", NULL
26205 };
26206
26207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26209 if (SWIG_arg_fail(1)) SWIG_fail;
26210 {
26211 arg2 = (int)(SWIG_As_int(obj1));
26212 if (SWIG_arg_fail(2)) SWIG_fail;
26213 }
26214 {
26215 PyThreadState* __tstate = wxPyBeginAllowThreads();
26216 {
26217 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26218 result = (wxDateSpan *) &_result_ref;
26219 }
26220
26221 wxPyEndAllowThreads(__tstate);
26222 if (PyErr_Occurred()) SWIG_fail;
26223 }
26224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26225 return resultobj;
26226 fail:
26227 return NULL;
26228 }
26229
26230
26231 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26232 PyObject *resultobj;
26233 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26234 wxDateSpan *arg2 = 0 ;
26235 wxDateSpan result;
26236 PyObject * obj0 = 0 ;
26237 PyObject * obj1 = 0 ;
26238 char *kwnames[] = {
26239 (char *) "self",(char *) "other", NULL
26240 };
26241
26242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26244 if (SWIG_arg_fail(1)) SWIG_fail;
26245 {
26246 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26247 if (SWIG_arg_fail(2)) SWIG_fail;
26248 if (arg2 == NULL) {
26249 SWIG_null_ref("wxDateSpan");
26250 }
26251 if (SWIG_arg_fail(2)) SWIG_fail;
26252 }
26253 {
26254 PyThreadState* __tstate = wxPyBeginAllowThreads();
26255 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26256
26257 wxPyEndAllowThreads(__tstate);
26258 if (PyErr_Occurred()) SWIG_fail;
26259 }
26260 {
26261 wxDateSpan * resultptr;
26262 resultptr = new wxDateSpan((wxDateSpan &)(result));
26263 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26264 }
26265 return resultobj;
26266 fail:
26267 return NULL;
26268 }
26269
26270
26271 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26272 PyObject *resultobj;
26273 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26274 wxDateSpan *arg2 = 0 ;
26275 wxDateSpan result;
26276 PyObject * obj0 = 0 ;
26277 PyObject * obj1 = 0 ;
26278 char *kwnames[] = {
26279 (char *) "self",(char *) "other", NULL
26280 };
26281
26282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26284 if (SWIG_arg_fail(1)) SWIG_fail;
26285 {
26286 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26287 if (SWIG_arg_fail(2)) SWIG_fail;
26288 if (arg2 == NULL) {
26289 SWIG_null_ref("wxDateSpan");
26290 }
26291 if (SWIG_arg_fail(2)) SWIG_fail;
26292 }
26293 {
26294 PyThreadState* __tstate = wxPyBeginAllowThreads();
26295 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26296
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 {
26301 wxDateSpan * resultptr;
26302 resultptr = new wxDateSpan((wxDateSpan &)(result));
26303 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26304 }
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26312 PyObject *resultobj;
26313 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26314 int arg2 ;
26315 wxDateSpan result;
26316 PyObject * obj0 = 0 ;
26317 PyObject * obj1 = 0 ;
26318 char *kwnames[] = {
26319 (char *) "self",(char *) "n", NULL
26320 };
26321
26322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26324 if (SWIG_arg_fail(1)) SWIG_fail;
26325 {
26326 arg2 = (int)(SWIG_As_int(obj1));
26327 if (SWIG_arg_fail(2)) SWIG_fail;
26328 }
26329 {
26330 PyThreadState* __tstate = wxPyBeginAllowThreads();
26331 result = wxDateSpan___mul__(arg1,arg2);
26332
26333 wxPyEndAllowThreads(__tstate);
26334 if (PyErr_Occurred()) SWIG_fail;
26335 }
26336 {
26337 wxDateSpan * resultptr;
26338 resultptr = new wxDateSpan((wxDateSpan &)(result));
26339 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26340 }
26341 return resultobj;
26342 fail:
26343 return NULL;
26344 }
26345
26346
26347 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26348 PyObject *resultobj;
26349 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26350 int arg2 ;
26351 wxDateSpan result;
26352 PyObject * obj0 = 0 ;
26353 PyObject * obj1 = 0 ;
26354 char *kwnames[] = {
26355 (char *) "self",(char *) "n", NULL
26356 };
26357
26358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26360 if (SWIG_arg_fail(1)) SWIG_fail;
26361 {
26362 arg2 = (int)(SWIG_As_int(obj1));
26363 if (SWIG_arg_fail(2)) SWIG_fail;
26364 }
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 result = wxDateSpan___rmul__(arg1,arg2);
26368
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 {
26373 wxDateSpan * resultptr;
26374 resultptr = new wxDateSpan((wxDateSpan &)(result));
26375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26376 }
26377 return resultobj;
26378 fail:
26379 return NULL;
26380 }
26381
26382
26383 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26384 PyObject *resultobj;
26385 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26386 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26387 bool result;
26388 PyObject * obj0 = 0 ;
26389 PyObject * obj1 = 0 ;
26390 char *kwnames[] = {
26391 (char *) "self",(char *) "other", NULL
26392 };
26393
26394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26396 if (SWIG_arg_fail(1)) SWIG_fail;
26397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26398 if (SWIG_arg_fail(2)) SWIG_fail;
26399 {
26400 PyThreadState* __tstate = wxPyBeginAllowThreads();
26401 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26402
26403 wxPyEndAllowThreads(__tstate);
26404 if (PyErr_Occurred()) SWIG_fail;
26405 }
26406 {
26407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26408 }
26409 return resultobj;
26410 fail:
26411 return NULL;
26412 }
26413
26414
26415 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj;
26417 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26418 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26419 bool result;
26420 PyObject * obj0 = 0 ;
26421 PyObject * obj1 = 0 ;
26422 char *kwnames[] = {
26423 (char *) "self",(char *) "other", NULL
26424 };
26425
26426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26428 if (SWIG_arg_fail(1)) SWIG_fail;
26429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26430 if (SWIG_arg_fail(2)) SWIG_fail;
26431 {
26432 PyThreadState* __tstate = wxPyBeginAllowThreads();
26433 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26434
26435 wxPyEndAllowThreads(__tstate);
26436 if (PyErr_Occurred()) SWIG_fail;
26437 }
26438 {
26439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26440 }
26441 return resultobj;
26442 fail:
26443 return NULL;
26444 }
26445
26446
26447 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26448 PyObject *obj;
26449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26450 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26451 Py_INCREF(obj);
26452 return Py_BuildValue((char *)"");
26453 }
26454 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26455 PyObject *resultobj;
26456 long result;
26457 char *kwnames[] = {
26458 NULL
26459 };
26460
26461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26462 {
26463 PyThreadState* __tstate = wxPyBeginAllowThreads();
26464 result = (long)wxGetLocalTime();
26465
26466 wxPyEndAllowThreads(__tstate);
26467 if (PyErr_Occurred()) SWIG_fail;
26468 }
26469 {
26470 resultobj = SWIG_From_long((long)(result));
26471 }
26472 return resultobj;
26473 fail:
26474 return NULL;
26475 }
26476
26477
26478 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26479 PyObject *resultobj;
26480 long result;
26481 char *kwnames[] = {
26482 NULL
26483 };
26484
26485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26486 {
26487 PyThreadState* __tstate = wxPyBeginAllowThreads();
26488 result = (long)wxGetUTCTime();
26489
26490 wxPyEndAllowThreads(__tstate);
26491 if (PyErr_Occurred()) SWIG_fail;
26492 }
26493 {
26494 resultobj = SWIG_From_long((long)(result));
26495 }
26496 return resultobj;
26497 fail:
26498 return NULL;
26499 }
26500
26501
26502 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26503 PyObject *resultobj;
26504 long result;
26505 char *kwnames[] = {
26506 NULL
26507 };
26508
26509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26510 {
26511 PyThreadState* __tstate = wxPyBeginAllowThreads();
26512 result = (long)wxGetCurrentTime();
26513
26514 wxPyEndAllowThreads(__tstate);
26515 if (PyErr_Occurred()) SWIG_fail;
26516 }
26517 {
26518 resultobj = SWIG_From_long((long)(result));
26519 }
26520 return resultobj;
26521 fail:
26522 return NULL;
26523 }
26524
26525
26526 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26527 PyObject *resultobj;
26528 wxLongLong result;
26529 char *kwnames[] = {
26530 NULL
26531 };
26532
26533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = wxGetLocalTimeMillis();
26537
26538 wxPyEndAllowThreads(__tstate);
26539 if (PyErr_Occurred()) SWIG_fail;
26540 }
26541 {
26542 PyObject *hi, *lo, *shifter, *shifted;
26543 hi = PyLong_FromLong( (&result)->GetHi() );
26544 lo = PyLong_FromLong( (&result)->GetLo() );
26545 shifter = PyLong_FromLong(32);
26546 shifted = PyNumber_Lshift(hi, shifter);
26547 resultobj = PyNumber_Or(shifted, lo);
26548 Py_DECREF(hi);
26549 Py_DECREF(lo);
26550 Py_DECREF(shifter);
26551 Py_DECREF(shifted);
26552 }
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 static int _wrap_DefaultDateTime_set(PyObject *) {
26560 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26561 return 1;
26562 }
26563
26564
26565 static PyObject *_wrap_DefaultDateTime_get(void) {
26566 PyObject *pyobj;
26567
26568 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26569 return pyobj;
26570 }
26571
26572
26573 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26574 PyObject *resultobj;
26575 wxDataFormatId arg1 ;
26576 wxDataFormat *result;
26577 PyObject * obj0 = 0 ;
26578 char *kwnames[] = {
26579 (char *) "type", NULL
26580 };
26581
26582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26583 {
26584 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26585 if (SWIG_arg_fail(1)) SWIG_fail;
26586 }
26587 {
26588 PyThreadState* __tstate = wxPyBeginAllowThreads();
26589 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26590
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26595 return resultobj;
26596 fail:
26597 return NULL;
26598 }
26599
26600
26601 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26602 PyObject *resultobj;
26603 wxString *arg1 = 0 ;
26604 wxDataFormat *result;
26605 bool temp1 = false ;
26606 PyObject * obj0 = 0 ;
26607 char *kwnames[] = {
26608 (char *) "format", NULL
26609 };
26610
26611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26612 {
26613 arg1 = wxString_in_helper(obj0);
26614 if (arg1 == NULL) SWIG_fail;
26615 temp1 = true;
26616 }
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26620
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26625 {
26626 if (temp1)
26627 delete arg1;
26628 }
26629 return resultobj;
26630 fail:
26631 {
26632 if (temp1)
26633 delete arg1;
26634 }
26635 return NULL;
26636 }
26637
26638
26639 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj;
26641 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26642 PyObject * obj0 = 0 ;
26643 char *kwnames[] = {
26644 (char *) "self", NULL
26645 };
26646
26647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26649 if (SWIG_arg_fail(1)) SWIG_fail;
26650 {
26651 PyThreadState* __tstate = wxPyBeginAllowThreads();
26652 delete arg1;
26653
26654 wxPyEndAllowThreads(__tstate);
26655 if (PyErr_Occurred()) SWIG_fail;
26656 }
26657 Py_INCREF(Py_None); resultobj = Py_None;
26658 return resultobj;
26659 fail:
26660 return NULL;
26661 }
26662
26663
26664 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26665 PyObject *resultobj;
26666 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26667 wxDataFormatId arg2 ;
26668 bool result;
26669 PyObject * obj0 = 0 ;
26670 PyObject * obj1 = 0 ;
26671
26672 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26674 if (SWIG_arg_fail(1)) SWIG_fail;
26675 {
26676 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26677 if (SWIG_arg_fail(2)) SWIG_fail;
26678 }
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26682
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 {
26687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26688 }
26689 return resultobj;
26690 fail:
26691 return NULL;
26692 }
26693
26694
26695 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26696 PyObject *resultobj;
26697 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26698 wxDataFormatId arg2 ;
26699 bool result;
26700 PyObject * obj0 = 0 ;
26701 PyObject * obj1 = 0 ;
26702
26703 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26705 if (SWIG_arg_fail(1)) SWIG_fail;
26706 {
26707 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26708 if (SWIG_arg_fail(2)) SWIG_fail;
26709 }
26710 {
26711 PyThreadState* __tstate = wxPyBeginAllowThreads();
26712 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26713
26714 wxPyEndAllowThreads(__tstate);
26715 if (PyErr_Occurred()) SWIG_fail;
26716 }
26717 {
26718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26719 }
26720 return resultobj;
26721 fail:
26722 return NULL;
26723 }
26724
26725
26726 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26727 PyObject *resultobj;
26728 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26729 wxDataFormat *arg2 = 0 ;
26730 bool result;
26731 PyObject * obj0 = 0 ;
26732 PyObject * obj1 = 0 ;
26733
26734 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26736 if (SWIG_arg_fail(1)) SWIG_fail;
26737 {
26738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26739 if (SWIG_arg_fail(2)) SWIG_fail;
26740 if (arg2 == NULL) {
26741 SWIG_null_ref("wxDataFormat");
26742 }
26743 if (SWIG_arg_fail(2)) SWIG_fail;
26744 }
26745 {
26746 PyThreadState* __tstate = wxPyBeginAllowThreads();
26747 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26748
26749 wxPyEndAllowThreads(__tstate);
26750 if (PyErr_Occurred()) SWIG_fail;
26751 }
26752 {
26753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26754 }
26755 return resultobj;
26756 fail:
26757 return NULL;
26758 }
26759
26760
26761 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26762 int argc;
26763 PyObject *argv[3];
26764 int ii;
26765
26766 argc = PyObject_Length(args);
26767 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26768 argv[ii] = PyTuple_GetItem(args,ii);
26769 }
26770 if (argc == 2) {
26771 int _v;
26772 {
26773 void *ptr;
26774 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26775 _v = 0;
26776 PyErr_Clear();
26777 } else {
26778 _v = 1;
26779 }
26780 }
26781 if (_v) {
26782 {
26783 void *ptr = 0;
26784 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26785 _v = 0;
26786 PyErr_Clear();
26787 } else {
26788 _v = (ptr != 0);
26789 }
26790 }
26791 if (_v) {
26792 return _wrap_DataFormat___eq____SWIG_1(self,args);
26793 }
26794 }
26795 }
26796 if (argc == 2) {
26797 int _v;
26798 {
26799 void *ptr;
26800 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26801 _v = 0;
26802 PyErr_Clear();
26803 } else {
26804 _v = 1;
26805 }
26806 }
26807 if (_v) {
26808 _v = SWIG_Check_int(argv[1]);
26809 if (_v) {
26810 return _wrap_DataFormat___eq____SWIG_0(self,args);
26811 }
26812 }
26813 }
26814
26815 Py_INCREF(Py_NotImplemented);
26816 return Py_NotImplemented;
26817 }
26818
26819
26820 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26821 PyObject *resultobj;
26822 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26823 wxDataFormat *arg2 = 0 ;
26824 bool result;
26825 PyObject * obj0 = 0 ;
26826 PyObject * obj1 = 0 ;
26827
26828 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26830 if (SWIG_arg_fail(1)) SWIG_fail;
26831 {
26832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26833 if (SWIG_arg_fail(2)) SWIG_fail;
26834 if (arg2 == NULL) {
26835 SWIG_null_ref("wxDataFormat");
26836 }
26837 if (SWIG_arg_fail(2)) SWIG_fail;
26838 }
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26842
26843 wxPyEndAllowThreads(__tstate);
26844 if (PyErr_Occurred()) SWIG_fail;
26845 }
26846 {
26847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26848 }
26849 return resultobj;
26850 fail:
26851 return NULL;
26852 }
26853
26854
26855 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26856 int argc;
26857 PyObject *argv[3];
26858 int ii;
26859
26860 argc = PyObject_Length(args);
26861 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26862 argv[ii] = PyTuple_GetItem(args,ii);
26863 }
26864 if (argc == 2) {
26865 int _v;
26866 {
26867 void *ptr;
26868 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26869 _v = 0;
26870 PyErr_Clear();
26871 } else {
26872 _v = 1;
26873 }
26874 }
26875 if (_v) {
26876 {
26877 void *ptr = 0;
26878 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26879 _v = 0;
26880 PyErr_Clear();
26881 } else {
26882 _v = (ptr != 0);
26883 }
26884 }
26885 if (_v) {
26886 return _wrap_DataFormat___ne____SWIG_1(self,args);
26887 }
26888 }
26889 }
26890 if (argc == 2) {
26891 int _v;
26892 {
26893 void *ptr;
26894 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26895 _v = 0;
26896 PyErr_Clear();
26897 } else {
26898 _v = 1;
26899 }
26900 }
26901 if (_v) {
26902 _v = SWIG_Check_int(argv[1]);
26903 if (_v) {
26904 return _wrap_DataFormat___ne____SWIG_0(self,args);
26905 }
26906 }
26907 }
26908
26909 Py_INCREF(Py_NotImplemented);
26910 return Py_NotImplemented;
26911 }
26912
26913
26914 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26915 PyObject *resultobj;
26916 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26917 wxDataFormatId arg2 ;
26918 PyObject * obj0 = 0 ;
26919 PyObject * obj1 = 0 ;
26920 char *kwnames[] = {
26921 (char *) "self",(char *) "format", NULL
26922 };
26923
26924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26926 if (SWIG_arg_fail(1)) SWIG_fail;
26927 {
26928 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26929 if (SWIG_arg_fail(2)) SWIG_fail;
26930 }
26931 {
26932 PyThreadState* __tstate = wxPyBeginAllowThreads();
26933 (arg1)->SetType((wxDataFormatId )arg2);
26934
26935 wxPyEndAllowThreads(__tstate);
26936 if (PyErr_Occurred()) SWIG_fail;
26937 }
26938 Py_INCREF(Py_None); resultobj = Py_None;
26939 return resultobj;
26940 fail:
26941 return NULL;
26942 }
26943
26944
26945 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26946 PyObject *resultobj;
26947 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26948 wxDataFormatId result;
26949 PyObject * obj0 = 0 ;
26950 char *kwnames[] = {
26951 (char *) "self", NULL
26952 };
26953
26954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26956 if (SWIG_arg_fail(1)) SWIG_fail;
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26960
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 resultobj = SWIG_From_int((result));
26965 return resultobj;
26966 fail:
26967 return NULL;
26968 }
26969
26970
26971 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26972 PyObject *resultobj;
26973 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26974 wxString result;
26975 PyObject * obj0 = 0 ;
26976 char *kwnames[] = {
26977 (char *) "self", NULL
26978 };
26979
26980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26982 if (SWIG_arg_fail(1)) SWIG_fail;
26983 {
26984 PyThreadState* __tstate = wxPyBeginAllowThreads();
26985 result = ((wxDataFormat const *)arg1)->GetId();
26986
26987 wxPyEndAllowThreads(__tstate);
26988 if (PyErr_Occurred()) SWIG_fail;
26989 }
26990 {
26991 #if wxUSE_UNICODE
26992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26993 #else
26994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26995 #endif
26996 }
26997 return resultobj;
26998 fail:
26999 return NULL;
27000 }
27001
27002
27003 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27004 PyObject *resultobj;
27005 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27006 wxString *arg2 = 0 ;
27007 bool temp2 = false ;
27008 PyObject * obj0 = 0 ;
27009 PyObject * obj1 = 0 ;
27010 char *kwnames[] = {
27011 (char *) "self",(char *) "format", NULL
27012 };
27013
27014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27016 if (SWIG_arg_fail(1)) SWIG_fail;
27017 {
27018 arg2 = wxString_in_helper(obj1);
27019 if (arg2 == NULL) SWIG_fail;
27020 temp2 = true;
27021 }
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 (arg1)->SetId((wxString const &)*arg2);
27025
27026 wxPyEndAllowThreads(__tstate);
27027 if (PyErr_Occurred()) SWIG_fail;
27028 }
27029 Py_INCREF(Py_None); resultobj = Py_None;
27030 {
27031 if (temp2)
27032 delete arg2;
27033 }
27034 return resultobj;
27035 fail:
27036 {
27037 if (temp2)
27038 delete arg2;
27039 }
27040 return NULL;
27041 }
27042
27043
27044 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27045 PyObject *obj;
27046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27047 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27048 Py_INCREF(obj);
27049 return Py_BuildValue((char *)"");
27050 }
27051 static int _wrap_FormatInvalid_set(PyObject *) {
27052 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27053 return 1;
27054 }
27055
27056
27057 static PyObject *_wrap_FormatInvalid_get(void) {
27058 PyObject *pyobj;
27059
27060 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27061 return pyobj;
27062 }
27063
27064
27065 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27066 PyObject *resultobj;
27067 wxDataObject *arg1 = (wxDataObject *) 0 ;
27068 PyObject * obj0 = 0 ;
27069 char *kwnames[] = {
27070 (char *) "self", NULL
27071 };
27072
27073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27075 if (SWIG_arg_fail(1)) SWIG_fail;
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 delete arg1;
27079
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 Py_INCREF(Py_None); resultobj = Py_None;
27084 return resultobj;
27085 fail:
27086 return NULL;
27087 }
27088
27089
27090 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27091 PyObject *resultobj;
27092 wxDataObject *arg1 = (wxDataObject *) 0 ;
27093 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27094 SwigValueWrapper<wxDataFormat > result;
27095 PyObject * obj0 = 0 ;
27096 PyObject * obj1 = 0 ;
27097 char *kwnames[] = {
27098 (char *) "self",(char *) "dir", NULL
27099 };
27100
27101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27103 if (SWIG_arg_fail(1)) SWIG_fail;
27104 if (obj1) {
27105 {
27106 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27107 if (SWIG_arg_fail(2)) SWIG_fail;
27108 }
27109 }
27110 {
27111 PyThreadState* __tstate = wxPyBeginAllowThreads();
27112 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27113
27114 wxPyEndAllowThreads(__tstate);
27115 if (PyErr_Occurred()) SWIG_fail;
27116 }
27117 {
27118 wxDataFormat * resultptr;
27119 resultptr = new wxDataFormat((wxDataFormat &)(result));
27120 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27121 }
27122 return resultobj;
27123 fail:
27124 return NULL;
27125 }
27126
27127
27128 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27129 PyObject *resultobj;
27130 wxDataObject *arg1 = (wxDataObject *) 0 ;
27131 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27132 size_t result;
27133 PyObject * obj0 = 0 ;
27134 PyObject * obj1 = 0 ;
27135 char *kwnames[] = {
27136 (char *) "self",(char *) "dir", NULL
27137 };
27138
27139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27141 if (SWIG_arg_fail(1)) SWIG_fail;
27142 if (obj1) {
27143 {
27144 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27145 if (SWIG_arg_fail(2)) SWIG_fail;
27146 }
27147 }
27148 {
27149 PyThreadState* __tstate = wxPyBeginAllowThreads();
27150 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27151
27152 wxPyEndAllowThreads(__tstate);
27153 if (PyErr_Occurred()) SWIG_fail;
27154 }
27155 {
27156 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27157 }
27158 return resultobj;
27159 fail:
27160 return NULL;
27161 }
27162
27163
27164 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27165 PyObject *resultobj;
27166 wxDataObject *arg1 = (wxDataObject *) 0 ;
27167 wxDataFormat *arg2 = 0 ;
27168 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27169 bool result;
27170 PyObject * obj0 = 0 ;
27171 PyObject * obj1 = 0 ;
27172 PyObject * obj2 = 0 ;
27173 char *kwnames[] = {
27174 (char *) "self",(char *) "format",(char *) "dir", NULL
27175 };
27176
27177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27179 if (SWIG_arg_fail(1)) SWIG_fail;
27180 {
27181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27182 if (SWIG_arg_fail(2)) SWIG_fail;
27183 if (arg2 == NULL) {
27184 SWIG_null_ref("wxDataFormat");
27185 }
27186 if (SWIG_arg_fail(2)) SWIG_fail;
27187 }
27188 if (obj2) {
27189 {
27190 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27191 if (SWIG_arg_fail(3)) SWIG_fail;
27192 }
27193 }
27194 {
27195 PyThreadState* __tstate = wxPyBeginAllowThreads();
27196 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27197
27198 wxPyEndAllowThreads(__tstate);
27199 if (PyErr_Occurred()) SWIG_fail;
27200 }
27201 {
27202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27203 }
27204 return resultobj;
27205 fail:
27206 return NULL;
27207 }
27208
27209
27210 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27211 PyObject *resultobj;
27212 wxDataObject *arg1 = (wxDataObject *) 0 ;
27213 wxDataFormat *arg2 = 0 ;
27214 size_t result;
27215 PyObject * obj0 = 0 ;
27216 PyObject * obj1 = 0 ;
27217 char *kwnames[] = {
27218 (char *) "self",(char *) "format", NULL
27219 };
27220
27221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27223 if (SWIG_arg_fail(1)) SWIG_fail;
27224 {
27225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27226 if (SWIG_arg_fail(2)) SWIG_fail;
27227 if (arg2 == NULL) {
27228 SWIG_null_ref("wxDataFormat");
27229 }
27230 if (SWIG_arg_fail(2)) SWIG_fail;
27231 }
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27235
27236 wxPyEndAllowThreads(__tstate);
27237 if (PyErr_Occurred()) SWIG_fail;
27238 }
27239 {
27240 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27241 }
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27249 PyObject *resultobj;
27250 wxDataObject *arg1 = (wxDataObject *) 0 ;
27251 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27252 PyObject *result;
27253 PyObject * obj0 = 0 ;
27254 PyObject * obj1 = 0 ;
27255 char *kwnames[] = {
27256 (char *) "self",(char *) "dir", NULL
27257 };
27258
27259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27261 if (SWIG_arg_fail(1)) SWIG_fail;
27262 if (obj1) {
27263 {
27264 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27265 if (SWIG_arg_fail(2)) SWIG_fail;
27266 }
27267 }
27268 {
27269 PyThreadState* __tstate = wxPyBeginAllowThreads();
27270 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27271
27272 wxPyEndAllowThreads(__tstate);
27273 if (PyErr_Occurred()) SWIG_fail;
27274 }
27275 resultobj = result;
27276 return resultobj;
27277 fail:
27278 return NULL;
27279 }
27280
27281
27282 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27283 PyObject *resultobj;
27284 wxDataObject *arg1 = (wxDataObject *) 0 ;
27285 wxDataFormat *arg2 = 0 ;
27286 PyObject *result;
27287 PyObject * obj0 = 0 ;
27288 PyObject * obj1 = 0 ;
27289 char *kwnames[] = {
27290 (char *) "self",(char *) "format", NULL
27291 };
27292
27293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27295 if (SWIG_arg_fail(1)) SWIG_fail;
27296 {
27297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(2)) SWIG_fail;
27299 if (arg2 == NULL) {
27300 SWIG_null_ref("wxDataFormat");
27301 }
27302 if (SWIG_arg_fail(2)) SWIG_fail;
27303 }
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27307
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 resultobj = result;
27312 return resultobj;
27313 fail:
27314 return NULL;
27315 }
27316
27317
27318 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27319 PyObject *resultobj;
27320 wxDataObject *arg1 = (wxDataObject *) 0 ;
27321 wxDataFormat *arg2 = 0 ;
27322 PyObject *arg3 = (PyObject *) 0 ;
27323 bool result;
27324 PyObject * obj0 = 0 ;
27325 PyObject * obj1 = 0 ;
27326 PyObject * obj2 = 0 ;
27327 char *kwnames[] = {
27328 (char *) "self",(char *) "format",(char *) "data", NULL
27329 };
27330
27331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27333 if (SWIG_arg_fail(1)) SWIG_fail;
27334 {
27335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27336 if (SWIG_arg_fail(2)) SWIG_fail;
27337 if (arg2 == NULL) {
27338 SWIG_null_ref("wxDataFormat");
27339 }
27340 if (SWIG_arg_fail(2)) SWIG_fail;
27341 }
27342 arg3 = obj2;
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27346
27347 wxPyEndAllowThreads(__tstate);
27348 if (PyErr_Occurred()) SWIG_fail;
27349 }
27350 {
27351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27352 }
27353 return resultobj;
27354 fail:
27355 return NULL;
27356 }
27357
27358
27359 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27360 PyObject *obj;
27361 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27362 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27363 Py_INCREF(obj);
27364 return Py_BuildValue((char *)"");
27365 }
27366 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27367 PyObject *resultobj;
27368 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27369 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27370 wxDataObjectSimple *result;
27371 PyObject * obj0 = 0 ;
27372 char *kwnames[] = {
27373 (char *) "format", NULL
27374 };
27375
27376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27377 if (obj0) {
27378 {
27379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27380 if (SWIG_arg_fail(1)) SWIG_fail;
27381 if (arg1 == NULL) {
27382 SWIG_null_ref("wxDataFormat");
27383 }
27384 if (SWIG_arg_fail(1)) SWIG_fail;
27385 }
27386 }
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27390
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27395 return resultobj;
27396 fail:
27397 return NULL;
27398 }
27399
27400
27401 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27402 PyObject *resultobj;
27403 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27404 wxDataFormat *result;
27405 PyObject * obj0 = 0 ;
27406 char *kwnames[] = {
27407 (char *) "self", NULL
27408 };
27409
27410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27412 if (SWIG_arg_fail(1)) SWIG_fail;
27413 {
27414 PyThreadState* __tstate = wxPyBeginAllowThreads();
27415 {
27416 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27417 result = (wxDataFormat *) &_result_ref;
27418 }
27419
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj;
27432 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27433 wxDataFormat *arg2 = 0 ;
27434 PyObject * obj0 = 0 ;
27435 PyObject * obj1 = 0 ;
27436 char *kwnames[] = {
27437 (char *) "self",(char *) "format", NULL
27438 };
27439
27440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27442 if (SWIG_arg_fail(1)) SWIG_fail;
27443 {
27444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27445 if (SWIG_arg_fail(2)) SWIG_fail;
27446 if (arg2 == NULL) {
27447 SWIG_null_ref("wxDataFormat");
27448 }
27449 if (SWIG_arg_fail(2)) SWIG_fail;
27450 }
27451 {
27452 PyThreadState* __tstate = wxPyBeginAllowThreads();
27453 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27454
27455 wxPyEndAllowThreads(__tstate);
27456 if (PyErr_Occurred()) SWIG_fail;
27457 }
27458 Py_INCREF(Py_None); resultobj = Py_None;
27459 return resultobj;
27460 fail:
27461 return NULL;
27462 }
27463
27464
27465 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27466 PyObject *resultobj;
27467 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27468 size_t result;
27469 PyObject * obj0 = 0 ;
27470 char *kwnames[] = {
27471 (char *) "self", NULL
27472 };
27473
27474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27476 if (SWIG_arg_fail(1)) SWIG_fail;
27477 {
27478 PyThreadState* __tstate = wxPyBeginAllowThreads();
27479 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27480
27481 wxPyEndAllowThreads(__tstate);
27482 if (PyErr_Occurred()) SWIG_fail;
27483 }
27484 {
27485 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27486 }
27487 return resultobj;
27488 fail:
27489 return NULL;
27490 }
27491
27492
27493 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27494 PyObject *resultobj;
27495 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27496 PyObject *result;
27497 PyObject * obj0 = 0 ;
27498 char *kwnames[] = {
27499 (char *) "self", NULL
27500 };
27501
27502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27504 if (SWIG_arg_fail(1)) SWIG_fail;
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27508
27509 wxPyEndAllowThreads(__tstate);
27510 if (PyErr_Occurred()) SWIG_fail;
27511 }
27512 resultobj = result;
27513 return resultobj;
27514 fail:
27515 return NULL;
27516 }
27517
27518
27519 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27520 PyObject *resultobj;
27521 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27522 PyObject *arg2 = (PyObject *) 0 ;
27523 bool result;
27524 PyObject * obj0 = 0 ;
27525 PyObject * obj1 = 0 ;
27526 char *kwnames[] = {
27527 (char *) "self",(char *) "data", NULL
27528 };
27529
27530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27532 if (SWIG_arg_fail(1)) SWIG_fail;
27533 arg2 = obj1;
27534 {
27535 PyThreadState* __tstate = wxPyBeginAllowThreads();
27536 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27537
27538 wxPyEndAllowThreads(__tstate);
27539 if (PyErr_Occurred()) SWIG_fail;
27540 }
27541 {
27542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27543 }
27544 return resultobj;
27545 fail:
27546 return NULL;
27547 }
27548
27549
27550 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27551 PyObject *obj;
27552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27553 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27554 Py_INCREF(obj);
27555 return Py_BuildValue((char *)"");
27556 }
27557 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27558 PyObject *resultobj;
27559 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27560 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27561 wxPyDataObjectSimple *result;
27562 PyObject * obj0 = 0 ;
27563 char *kwnames[] = {
27564 (char *) "format", NULL
27565 };
27566
27567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27568 if (obj0) {
27569 {
27570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27571 if (SWIG_arg_fail(1)) SWIG_fail;
27572 if (arg1 == NULL) {
27573 SWIG_null_ref("wxDataFormat");
27574 }
27575 if (SWIG_arg_fail(1)) SWIG_fail;
27576 }
27577 }
27578 {
27579 PyThreadState* __tstate = wxPyBeginAllowThreads();
27580 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27581
27582 wxPyEndAllowThreads(__tstate);
27583 if (PyErr_Occurred()) SWIG_fail;
27584 }
27585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27586 return resultobj;
27587 fail:
27588 return NULL;
27589 }
27590
27591
27592 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27593 PyObject *resultobj;
27594 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27595 PyObject *arg2 = (PyObject *) 0 ;
27596 PyObject *arg3 = (PyObject *) 0 ;
27597 PyObject * obj0 = 0 ;
27598 PyObject * obj1 = 0 ;
27599 PyObject * obj2 = 0 ;
27600 char *kwnames[] = {
27601 (char *) "self",(char *) "self",(char *) "_class", NULL
27602 };
27603
27604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27606 if (SWIG_arg_fail(1)) SWIG_fail;
27607 arg2 = obj1;
27608 arg3 = obj2;
27609 {
27610 PyThreadState* __tstate = wxPyBeginAllowThreads();
27611 (arg1)->_setCallbackInfo(arg2,arg3);
27612
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 Py_INCREF(Py_None); resultobj = Py_None;
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27624 PyObject *obj;
27625 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27626 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27627 Py_INCREF(obj);
27628 return Py_BuildValue((char *)"");
27629 }
27630 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27631 PyObject *resultobj;
27632 wxDataObjectComposite *result;
27633 char *kwnames[] = {
27634 NULL
27635 };
27636
27637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27638 {
27639 PyThreadState* __tstate = wxPyBeginAllowThreads();
27640 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27641
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27646 return resultobj;
27647 fail:
27648 return NULL;
27649 }
27650
27651
27652 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27653 PyObject *resultobj;
27654 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27655 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27656 bool arg3 = (bool) false ;
27657 PyObject * obj0 = 0 ;
27658 PyObject * obj1 = 0 ;
27659 PyObject * obj2 = 0 ;
27660 char *kwnames[] = {
27661 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27662 };
27663
27664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27666 if (SWIG_arg_fail(1)) SWIG_fail;
27667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27668 if (SWIG_arg_fail(2)) SWIG_fail;
27669 if (obj2) {
27670 {
27671 arg3 = (bool)(SWIG_As_bool(obj2));
27672 if (SWIG_arg_fail(3)) SWIG_fail;
27673 }
27674 }
27675 {
27676 PyThreadState* __tstate = wxPyBeginAllowThreads();
27677 (arg1)->Add(arg2,arg3);
27678
27679 wxPyEndAllowThreads(__tstate);
27680 if (PyErr_Occurred()) SWIG_fail;
27681 }
27682 Py_INCREF(Py_None); resultobj = Py_None;
27683 return resultobj;
27684 fail:
27685 return NULL;
27686 }
27687
27688
27689 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27690 PyObject *obj;
27691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27692 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27693 Py_INCREF(obj);
27694 return Py_BuildValue((char *)"");
27695 }
27696 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27697 PyObject *resultobj;
27698 wxString const &arg1_defvalue = wxPyEmptyString ;
27699 wxString *arg1 = (wxString *) &arg1_defvalue ;
27700 wxTextDataObject *result;
27701 bool temp1 = false ;
27702 PyObject * obj0 = 0 ;
27703 char *kwnames[] = {
27704 (char *) "text", NULL
27705 };
27706
27707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27708 if (obj0) {
27709 {
27710 arg1 = wxString_in_helper(obj0);
27711 if (arg1 == NULL) SWIG_fail;
27712 temp1 = true;
27713 }
27714 }
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27718
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27723 {
27724 if (temp1)
27725 delete arg1;
27726 }
27727 return resultobj;
27728 fail:
27729 {
27730 if (temp1)
27731 delete arg1;
27732 }
27733 return NULL;
27734 }
27735
27736
27737 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27738 PyObject *resultobj;
27739 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27740 size_t result;
27741 PyObject * obj0 = 0 ;
27742 char *kwnames[] = {
27743 (char *) "self", NULL
27744 };
27745
27746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27748 if (SWIG_arg_fail(1)) SWIG_fail;
27749 {
27750 PyThreadState* __tstate = wxPyBeginAllowThreads();
27751 result = (size_t)(arg1)->GetTextLength();
27752
27753 wxPyEndAllowThreads(__tstate);
27754 if (PyErr_Occurred()) SWIG_fail;
27755 }
27756 {
27757 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27758 }
27759 return resultobj;
27760 fail:
27761 return NULL;
27762 }
27763
27764
27765 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27766 PyObject *resultobj;
27767 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27768 wxString result;
27769 PyObject * obj0 = 0 ;
27770 char *kwnames[] = {
27771 (char *) "self", NULL
27772 };
27773
27774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(1)) SWIG_fail;
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 result = (arg1)->GetText();
27780
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 #if wxUSE_UNICODE
27786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27787 #else
27788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27789 #endif
27790 }
27791 return resultobj;
27792 fail:
27793 return NULL;
27794 }
27795
27796
27797 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27798 PyObject *resultobj;
27799 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27800 wxString *arg2 = 0 ;
27801 bool temp2 = false ;
27802 PyObject * obj0 = 0 ;
27803 PyObject * obj1 = 0 ;
27804 char *kwnames[] = {
27805 (char *) "self",(char *) "text", NULL
27806 };
27807
27808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27810 if (SWIG_arg_fail(1)) SWIG_fail;
27811 {
27812 arg2 = wxString_in_helper(obj1);
27813 if (arg2 == NULL) SWIG_fail;
27814 temp2 = true;
27815 }
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 (arg1)->SetText((wxString const &)*arg2);
27819
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 Py_INCREF(Py_None); resultobj = Py_None;
27824 {
27825 if (temp2)
27826 delete arg2;
27827 }
27828 return resultobj;
27829 fail:
27830 {
27831 if (temp2)
27832 delete arg2;
27833 }
27834 return NULL;
27835 }
27836
27837
27838 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27839 PyObject *obj;
27840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27841 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27842 Py_INCREF(obj);
27843 return Py_BuildValue((char *)"");
27844 }
27845 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27846 PyObject *resultobj;
27847 wxString const &arg1_defvalue = wxPyEmptyString ;
27848 wxString *arg1 = (wxString *) &arg1_defvalue ;
27849 wxPyTextDataObject *result;
27850 bool temp1 = false ;
27851 PyObject * obj0 = 0 ;
27852 char *kwnames[] = {
27853 (char *) "text", NULL
27854 };
27855
27856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27857 if (obj0) {
27858 {
27859 arg1 = wxString_in_helper(obj0);
27860 if (arg1 == NULL) SWIG_fail;
27861 temp1 = true;
27862 }
27863 }
27864 {
27865 PyThreadState* __tstate = wxPyBeginAllowThreads();
27866 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27867
27868 wxPyEndAllowThreads(__tstate);
27869 if (PyErr_Occurred()) SWIG_fail;
27870 }
27871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27872 {
27873 if (temp1)
27874 delete arg1;
27875 }
27876 return resultobj;
27877 fail:
27878 {
27879 if (temp1)
27880 delete arg1;
27881 }
27882 return NULL;
27883 }
27884
27885
27886 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj;
27888 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27889 PyObject *arg2 = (PyObject *) 0 ;
27890 PyObject *arg3 = (PyObject *) 0 ;
27891 PyObject * obj0 = 0 ;
27892 PyObject * obj1 = 0 ;
27893 PyObject * obj2 = 0 ;
27894 char *kwnames[] = {
27895 (char *) "self",(char *) "self",(char *) "_class", NULL
27896 };
27897
27898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27900 if (SWIG_arg_fail(1)) SWIG_fail;
27901 arg2 = obj1;
27902 arg3 = obj2;
27903 {
27904 PyThreadState* __tstate = wxPyBeginAllowThreads();
27905 (arg1)->_setCallbackInfo(arg2,arg3);
27906
27907 wxPyEndAllowThreads(__tstate);
27908 if (PyErr_Occurred()) SWIG_fail;
27909 }
27910 Py_INCREF(Py_None); resultobj = Py_None;
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27918 PyObject *obj;
27919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27920 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27921 Py_INCREF(obj);
27922 return Py_BuildValue((char *)"");
27923 }
27924 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27925 PyObject *resultobj;
27926 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27927 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27928 wxBitmapDataObject *result;
27929 PyObject * obj0 = 0 ;
27930 char *kwnames[] = {
27931 (char *) "bitmap", NULL
27932 };
27933
27934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27935 if (obj0) {
27936 {
27937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27938 if (SWIG_arg_fail(1)) SWIG_fail;
27939 if (arg1 == NULL) {
27940 SWIG_null_ref("wxBitmap");
27941 }
27942 if (SWIG_arg_fail(1)) SWIG_fail;
27943 }
27944 }
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj;
27961 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27962 wxBitmap result;
27963 PyObject * obj0 = 0 ;
27964 char *kwnames[] = {
27965 (char *) "self", NULL
27966 };
27967
27968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27970 if (SWIG_arg_fail(1)) SWIG_fail;
27971 {
27972 PyThreadState* __tstate = wxPyBeginAllowThreads();
27973 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27974
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 {
27979 wxBitmap * resultptr;
27980 resultptr = new wxBitmap((wxBitmap &)(result));
27981 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27982 }
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj;
27991 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27992 wxBitmap *arg2 = 0 ;
27993 PyObject * obj0 = 0 ;
27994 PyObject * obj1 = 0 ;
27995 char *kwnames[] = {
27996 (char *) "self",(char *) "bitmap", NULL
27997 };
27998
27999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28001 if (SWIG_arg_fail(1)) SWIG_fail;
28002 {
28003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28004 if (SWIG_arg_fail(2)) SWIG_fail;
28005 if (arg2 == NULL) {
28006 SWIG_null_ref("wxBitmap");
28007 }
28008 if (SWIG_arg_fail(2)) SWIG_fail;
28009 }
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28013
28014 wxPyEndAllowThreads(__tstate);
28015 if (PyErr_Occurred()) SWIG_fail;
28016 }
28017 Py_INCREF(Py_None); resultobj = Py_None;
28018 return resultobj;
28019 fail:
28020 return NULL;
28021 }
28022
28023
28024 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28025 PyObject *obj;
28026 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28027 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28028 Py_INCREF(obj);
28029 return Py_BuildValue((char *)"");
28030 }
28031 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj;
28033 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28034 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28035 wxPyBitmapDataObject *result;
28036 PyObject * obj0 = 0 ;
28037 char *kwnames[] = {
28038 (char *) "bitmap", NULL
28039 };
28040
28041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28042 if (obj0) {
28043 {
28044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28045 if (SWIG_arg_fail(1)) SWIG_fail;
28046 if (arg1 == NULL) {
28047 SWIG_null_ref("wxBitmap");
28048 }
28049 if (SWIG_arg_fail(1)) SWIG_fail;
28050 }
28051 }
28052 {
28053 PyThreadState* __tstate = wxPyBeginAllowThreads();
28054 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28055
28056 wxPyEndAllowThreads(__tstate);
28057 if (PyErr_Occurred()) SWIG_fail;
28058 }
28059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28060 return resultobj;
28061 fail:
28062 return NULL;
28063 }
28064
28065
28066 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28067 PyObject *resultobj;
28068 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28069 PyObject *arg2 = (PyObject *) 0 ;
28070 PyObject *arg3 = (PyObject *) 0 ;
28071 PyObject * obj0 = 0 ;
28072 PyObject * obj1 = 0 ;
28073 PyObject * obj2 = 0 ;
28074 char *kwnames[] = {
28075 (char *) "self",(char *) "self",(char *) "_class", NULL
28076 };
28077
28078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28080 if (SWIG_arg_fail(1)) SWIG_fail;
28081 arg2 = obj1;
28082 arg3 = obj2;
28083 {
28084 PyThreadState* __tstate = wxPyBeginAllowThreads();
28085 (arg1)->_setCallbackInfo(arg2,arg3);
28086
28087 wxPyEndAllowThreads(__tstate);
28088 if (PyErr_Occurred()) SWIG_fail;
28089 }
28090 Py_INCREF(Py_None); resultobj = Py_None;
28091 return resultobj;
28092 fail:
28093 return NULL;
28094 }
28095
28096
28097 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28098 PyObject *obj;
28099 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28100 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28101 Py_INCREF(obj);
28102 return Py_BuildValue((char *)"");
28103 }
28104 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28105 PyObject *resultobj;
28106 wxFileDataObject *result;
28107 char *kwnames[] = {
28108 NULL
28109 };
28110
28111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28112 {
28113 PyThreadState* __tstate = wxPyBeginAllowThreads();
28114 result = (wxFileDataObject *)new wxFileDataObject();
28115
28116 wxPyEndAllowThreads(__tstate);
28117 if (PyErr_Occurred()) SWIG_fail;
28118 }
28119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28120 return resultobj;
28121 fail:
28122 return NULL;
28123 }
28124
28125
28126 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28127 PyObject *resultobj;
28128 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28129 wxArrayString *result;
28130 PyObject * obj0 = 0 ;
28131 char *kwnames[] = {
28132 (char *) "self", NULL
28133 };
28134
28135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28137 if (SWIG_arg_fail(1)) SWIG_fail;
28138 {
28139 PyThreadState* __tstate = wxPyBeginAllowThreads();
28140 {
28141 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28142 result = (wxArrayString *) &_result_ref;
28143 }
28144
28145 wxPyEndAllowThreads(__tstate);
28146 if (PyErr_Occurred()) SWIG_fail;
28147 }
28148 {
28149 resultobj = wxArrayString2PyList_helper(*result);
28150 }
28151 return resultobj;
28152 fail:
28153 return NULL;
28154 }
28155
28156
28157 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28158 PyObject *resultobj;
28159 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28160 wxString *arg2 = 0 ;
28161 bool temp2 = false ;
28162 PyObject * obj0 = 0 ;
28163 PyObject * obj1 = 0 ;
28164 char *kwnames[] = {
28165 (char *) "self",(char *) "filename", NULL
28166 };
28167
28168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28170 if (SWIG_arg_fail(1)) SWIG_fail;
28171 {
28172 arg2 = wxString_in_helper(obj1);
28173 if (arg2 == NULL) SWIG_fail;
28174 temp2 = true;
28175 }
28176 {
28177 PyThreadState* __tstate = wxPyBeginAllowThreads();
28178 (arg1)->AddFile((wxString const &)*arg2);
28179
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 Py_INCREF(Py_None); resultobj = Py_None;
28184 {
28185 if (temp2)
28186 delete arg2;
28187 }
28188 return resultobj;
28189 fail:
28190 {
28191 if (temp2)
28192 delete arg2;
28193 }
28194 return NULL;
28195 }
28196
28197
28198 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28199 PyObject *obj;
28200 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28201 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28202 Py_INCREF(obj);
28203 return Py_BuildValue((char *)"");
28204 }
28205 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28206 PyObject *resultobj;
28207 wxDataFormat *arg1 = 0 ;
28208 wxCustomDataObject *result;
28209 PyObject * obj0 = 0 ;
28210
28211 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28212 {
28213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28214 if (SWIG_arg_fail(1)) SWIG_fail;
28215 if (arg1 == NULL) {
28216 SWIG_null_ref("wxDataFormat");
28217 }
28218 if (SWIG_arg_fail(1)) SWIG_fail;
28219 }
28220 {
28221 PyThreadState* __tstate = wxPyBeginAllowThreads();
28222 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28223
28224 wxPyEndAllowThreads(__tstate);
28225 if (PyErr_Occurred()) SWIG_fail;
28226 }
28227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28228 return resultobj;
28229 fail:
28230 return NULL;
28231 }
28232
28233
28234 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28235 PyObject *resultobj;
28236 wxString *arg1 = 0 ;
28237 wxCustomDataObject *result;
28238 bool temp1 = false ;
28239 PyObject * obj0 = 0 ;
28240
28241 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28242 {
28243 arg1 = wxString_in_helper(obj0);
28244 if (arg1 == NULL) SWIG_fail;
28245 temp1 = true;
28246 }
28247 {
28248 PyThreadState* __tstate = wxPyBeginAllowThreads();
28249 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28250
28251 wxPyEndAllowThreads(__tstate);
28252 if (PyErr_Occurred()) SWIG_fail;
28253 }
28254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28255 {
28256 if (temp1)
28257 delete arg1;
28258 }
28259 return resultobj;
28260 fail:
28261 {
28262 if (temp1)
28263 delete arg1;
28264 }
28265 return NULL;
28266 }
28267
28268
28269 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28270 PyObject *resultobj;
28271 wxCustomDataObject *result;
28272
28273 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28274 {
28275 PyThreadState* __tstate = wxPyBeginAllowThreads();
28276 result = (wxCustomDataObject *)new wxCustomDataObject();
28277
28278 wxPyEndAllowThreads(__tstate);
28279 if (PyErr_Occurred()) SWIG_fail;
28280 }
28281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28289 int argc;
28290 PyObject *argv[2];
28291 int ii;
28292
28293 argc = PyObject_Length(args);
28294 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28295 argv[ii] = PyTuple_GetItem(args,ii);
28296 }
28297 if (argc == 0) {
28298 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28299 }
28300 if (argc == 1) {
28301 int _v;
28302 {
28303 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28304 }
28305 if (_v) {
28306 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28307 }
28308 }
28309 if (argc == 1) {
28310 int _v;
28311 {
28312 void *ptr = 0;
28313 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28314 _v = 0;
28315 PyErr_Clear();
28316 } else {
28317 _v = (ptr != 0);
28318 }
28319 }
28320 if (_v) {
28321 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28322 }
28323 }
28324
28325 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28326 return NULL;
28327 }
28328
28329
28330 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28331 PyObject *resultobj;
28332 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28333 PyObject *arg2 = (PyObject *) 0 ;
28334 bool result;
28335 PyObject * obj0 = 0 ;
28336 PyObject * obj1 = 0 ;
28337 char *kwnames[] = {
28338 (char *) "self",(char *) "data", NULL
28339 };
28340
28341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28343 if (SWIG_arg_fail(1)) SWIG_fail;
28344 arg2 = obj1;
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28348
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 {
28353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28354 }
28355 return resultobj;
28356 fail:
28357 return NULL;
28358 }
28359
28360
28361 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28362 PyObject *resultobj;
28363 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28364 size_t result;
28365 PyObject * obj0 = 0 ;
28366 char *kwnames[] = {
28367 (char *) "self", NULL
28368 };
28369
28370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28372 if (SWIG_arg_fail(1)) SWIG_fail;
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (size_t)(arg1)->GetSize();
28376
28377 wxPyEndAllowThreads(__tstate);
28378 if (PyErr_Occurred()) SWIG_fail;
28379 }
28380 {
28381 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28382 }
28383 return resultobj;
28384 fail:
28385 return NULL;
28386 }
28387
28388
28389 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28390 PyObject *resultobj;
28391 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28392 PyObject *result;
28393 PyObject * obj0 = 0 ;
28394 char *kwnames[] = {
28395 (char *) "self", NULL
28396 };
28397
28398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28400 if (SWIG_arg_fail(1)) SWIG_fail;
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28404
28405 wxPyEndAllowThreads(__tstate);
28406 if (PyErr_Occurred()) SWIG_fail;
28407 }
28408 resultobj = result;
28409 return resultobj;
28410 fail:
28411 return NULL;
28412 }
28413
28414
28415 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28416 PyObject *obj;
28417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28418 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28419 Py_INCREF(obj);
28420 return Py_BuildValue((char *)"");
28421 }
28422 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28423 PyObject *resultobj;
28424 wxURLDataObject *result;
28425 char *kwnames[] = {
28426 NULL
28427 };
28428
28429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (wxURLDataObject *)new wxURLDataObject();
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28445 PyObject *resultobj;
28446 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28447 wxString result;
28448 PyObject * obj0 = 0 ;
28449 char *kwnames[] = {
28450 (char *) "self", NULL
28451 };
28452
28453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28455 if (SWIG_arg_fail(1)) SWIG_fail;
28456 {
28457 PyThreadState* __tstate = wxPyBeginAllowThreads();
28458 result = (arg1)->GetURL();
28459
28460 wxPyEndAllowThreads(__tstate);
28461 if (PyErr_Occurred()) SWIG_fail;
28462 }
28463 {
28464 #if wxUSE_UNICODE
28465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28466 #else
28467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28468 #endif
28469 }
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28477 PyObject *resultobj;
28478 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28479 wxString *arg2 = 0 ;
28480 bool temp2 = false ;
28481 PyObject * obj0 = 0 ;
28482 PyObject * obj1 = 0 ;
28483 char *kwnames[] = {
28484 (char *) "self",(char *) "url", NULL
28485 };
28486
28487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28489 if (SWIG_arg_fail(1)) SWIG_fail;
28490 {
28491 arg2 = wxString_in_helper(obj1);
28492 if (arg2 == NULL) SWIG_fail;
28493 temp2 = true;
28494 }
28495 {
28496 PyThreadState* __tstate = wxPyBeginAllowThreads();
28497 (arg1)->SetURL((wxString const &)*arg2);
28498
28499 wxPyEndAllowThreads(__tstate);
28500 if (PyErr_Occurred()) SWIG_fail;
28501 }
28502 Py_INCREF(Py_None); resultobj = Py_None;
28503 {
28504 if (temp2)
28505 delete arg2;
28506 }
28507 return resultobj;
28508 fail:
28509 {
28510 if (temp2)
28511 delete arg2;
28512 }
28513 return NULL;
28514 }
28515
28516
28517 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28518 PyObject *obj;
28519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28520 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28521 Py_INCREF(obj);
28522 return Py_BuildValue((char *)"");
28523 }
28524 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28525 PyObject *resultobj;
28526 wxMetafileDataObject *result;
28527 char *kwnames[] = {
28528 NULL
28529 };
28530
28531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28535
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj;
28548 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28549 wxMetafile *arg2 = 0 ;
28550 PyObject * obj0 = 0 ;
28551 PyObject * obj1 = 0 ;
28552 char *kwnames[] = {
28553 (char *) "self",(char *) "metafile", NULL
28554 };
28555
28556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28558 if (SWIG_arg_fail(1)) SWIG_fail;
28559 {
28560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28561 if (SWIG_arg_fail(2)) SWIG_fail;
28562 if (arg2 == NULL) {
28563 SWIG_null_ref("wxMetafile");
28564 }
28565 if (SWIG_arg_fail(2)) SWIG_fail;
28566 }
28567 {
28568 PyThreadState* __tstate = wxPyBeginAllowThreads();
28569 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28570
28571 wxPyEndAllowThreads(__tstate);
28572 if (PyErr_Occurred()) SWIG_fail;
28573 }
28574 Py_INCREF(Py_None); resultobj = Py_None;
28575 return resultobj;
28576 fail:
28577 return NULL;
28578 }
28579
28580
28581 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28582 PyObject *resultobj;
28583 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28584 wxMetafile result;
28585 PyObject * obj0 = 0 ;
28586 char *kwnames[] = {
28587 (char *) "self", NULL
28588 };
28589
28590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28592 if (SWIG_arg_fail(1)) SWIG_fail;
28593 {
28594 PyThreadState* __tstate = wxPyBeginAllowThreads();
28595 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28596
28597 wxPyEndAllowThreads(__tstate);
28598 if (PyErr_Occurred()) SWIG_fail;
28599 }
28600 {
28601 wxMetafile * resultptr;
28602 resultptr = new wxMetafile((wxMetafile &)(result));
28603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28604 }
28605 return resultobj;
28606 fail:
28607 return NULL;
28608 }
28609
28610
28611 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28612 PyObject *obj;
28613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28614 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28615 Py_INCREF(obj);
28616 return Py_BuildValue((char *)"");
28617 }
28618 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28619 PyObject *resultobj;
28620 wxDragResult arg1 ;
28621 bool result;
28622 PyObject * obj0 = 0 ;
28623 char *kwnames[] = {
28624 (char *) "res", NULL
28625 };
28626
28627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28628 {
28629 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28630 if (SWIG_arg_fail(1)) SWIG_fail;
28631 }
28632 {
28633 PyThreadState* __tstate = wxPyBeginAllowThreads();
28634 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28635
28636 wxPyEndAllowThreads(__tstate);
28637 if (PyErr_Occurred()) SWIG_fail;
28638 }
28639 {
28640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28641 }
28642 return resultobj;
28643 fail:
28644 return NULL;
28645 }
28646
28647
28648 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28649 PyObject *resultobj;
28650 wxWindow *arg1 = (wxWindow *) 0 ;
28651 wxCursor const &arg2_defvalue = wxNullCursor ;
28652 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28653 wxCursor const &arg3_defvalue = wxNullCursor ;
28654 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28655 wxCursor const &arg4_defvalue = wxNullCursor ;
28656 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28657 wxPyDropSource *result;
28658 PyObject * obj0 = 0 ;
28659 PyObject * obj1 = 0 ;
28660 PyObject * obj2 = 0 ;
28661 PyObject * obj3 = 0 ;
28662 char *kwnames[] = {
28663 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28664 };
28665
28666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28668 if (SWIG_arg_fail(1)) SWIG_fail;
28669 if (obj1) {
28670 {
28671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28672 if (SWIG_arg_fail(2)) SWIG_fail;
28673 if (arg2 == NULL) {
28674 SWIG_null_ref("wxCursor");
28675 }
28676 if (SWIG_arg_fail(2)) SWIG_fail;
28677 }
28678 }
28679 if (obj2) {
28680 {
28681 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(3)) SWIG_fail;
28683 if (arg3 == NULL) {
28684 SWIG_null_ref("wxCursor");
28685 }
28686 if (SWIG_arg_fail(3)) SWIG_fail;
28687 }
28688 }
28689 if (obj3) {
28690 {
28691 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28692 if (SWIG_arg_fail(4)) SWIG_fail;
28693 if (arg4 == NULL) {
28694 SWIG_null_ref("wxCursor");
28695 }
28696 if (SWIG_arg_fail(4)) SWIG_fail;
28697 }
28698 }
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28702
28703 wxPyEndAllowThreads(__tstate);
28704 if (PyErr_Occurred()) SWIG_fail;
28705 }
28706 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28707 return resultobj;
28708 fail:
28709 return NULL;
28710 }
28711
28712
28713 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28714 PyObject *resultobj;
28715 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28716 PyObject *arg2 = (PyObject *) 0 ;
28717 PyObject *arg3 = (PyObject *) 0 ;
28718 int arg4 ;
28719 PyObject * obj0 = 0 ;
28720 PyObject * obj1 = 0 ;
28721 PyObject * obj2 = 0 ;
28722 PyObject * obj3 = 0 ;
28723 char *kwnames[] = {
28724 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28725 };
28726
28727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28729 if (SWIG_arg_fail(1)) SWIG_fail;
28730 arg2 = obj1;
28731 arg3 = obj2;
28732 {
28733 arg4 = (int)(SWIG_As_int(obj3));
28734 if (SWIG_arg_fail(4)) SWIG_fail;
28735 }
28736 {
28737 PyThreadState* __tstate = wxPyBeginAllowThreads();
28738 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28739
28740 wxPyEndAllowThreads(__tstate);
28741 if (PyErr_Occurred()) SWIG_fail;
28742 }
28743 Py_INCREF(Py_None); resultobj = Py_None;
28744 return resultobj;
28745 fail:
28746 return NULL;
28747 }
28748
28749
28750 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28751 PyObject *resultobj;
28752 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28753 PyObject * obj0 = 0 ;
28754 char *kwnames[] = {
28755 (char *) "self", NULL
28756 };
28757
28758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28760 if (SWIG_arg_fail(1)) SWIG_fail;
28761 {
28762 PyThreadState* __tstate = wxPyBeginAllowThreads();
28763 delete arg1;
28764
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 Py_INCREF(Py_None); resultobj = Py_None;
28769 return resultobj;
28770 fail:
28771 return NULL;
28772 }
28773
28774
28775 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28776 PyObject *resultobj;
28777 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28778 wxDataObject *arg2 = 0 ;
28779 PyObject * obj0 = 0 ;
28780 PyObject * obj1 = 0 ;
28781 char *kwnames[] = {
28782 (char *) "self",(char *) "data", NULL
28783 };
28784
28785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28787 if (SWIG_arg_fail(1)) SWIG_fail;
28788 {
28789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28790 if (SWIG_arg_fail(2)) SWIG_fail;
28791 if (arg2 == NULL) {
28792 SWIG_null_ref("wxDataObject");
28793 }
28794 if (SWIG_arg_fail(2)) SWIG_fail;
28795 }
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 (arg1)->SetData(*arg2);
28799
28800 wxPyEndAllowThreads(__tstate);
28801 if (PyErr_Occurred()) SWIG_fail;
28802 }
28803 Py_INCREF(Py_None); resultobj = Py_None;
28804 return resultobj;
28805 fail:
28806 return NULL;
28807 }
28808
28809
28810 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28811 PyObject *resultobj;
28812 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28813 wxDataObject *result;
28814 PyObject * obj0 = 0 ;
28815 char *kwnames[] = {
28816 (char *) "self", NULL
28817 };
28818
28819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28821 if (SWIG_arg_fail(1)) SWIG_fail;
28822 {
28823 PyThreadState* __tstate = wxPyBeginAllowThreads();
28824 result = (wxDataObject *)(arg1)->GetDataObject();
28825
28826 wxPyEndAllowThreads(__tstate);
28827 if (PyErr_Occurred()) SWIG_fail;
28828 }
28829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28837 PyObject *resultobj;
28838 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28839 wxDragResult arg2 ;
28840 wxCursor *arg3 = 0 ;
28841 PyObject * obj0 = 0 ;
28842 PyObject * obj1 = 0 ;
28843 PyObject * obj2 = 0 ;
28844 char *kwnames[] = {
28845 (char *) "self",(char *) "res",(char *) "cursor", NULL
28846 };
28847
28848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28850 if (SWIG_arg_fail(1)) SWIG_fail;
28851 {
28852 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28853 if (SWIG_arg_fail(2)) SWIG_fail;
28854 }
28855 {
28856 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28857 if (SWIG_arg_fail(3)) SWIG_fail;
28858 if (arg3 == NULL) {
28859 SWIG_null_ref("wxCursor");
28860 }
28861 if (SWIG_arg_fail(3)) SWIG_fail;
28862 }
28863 {
28864 PyThreadState* __tstate = wxPyBeginAllowThreads();
28865 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28866
28867 wxPyEndAllowThreads(__tstate);
28868 if (PyErr_Occurred()) SWIG_fail;
28869 }
28870 Py_INCREF(Py_None); resultobj = Py_None;
28871 return resultobj;
28872 fail:
28873 return NULL;
28874 }
28875
28876
28877 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28878 PyObject *resultobj;
28879 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28880 int arg2 = (int) wxDrag_CopyOnly ;
28881 wxDragResult result;
28882 PyObject * obj0 = 0 ;
28883 PyObject * obj1 = 0 ;
28884 char *kwnames[] = {
28885 (char *) "self",(char *) "flags", NULL
28886 };
28887
28888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28890 if (SWIG_arg_fail(1)) SWIG_fail;
28891 if (obj1) {
28892 {
28893 arg2 = (int)(SWIG_As_int(obj1));
28894 if (SWIG_arg_fail(2)) SWIG_fail;
28895 }
28896 }
28897 {
28898 PyThreadState* __tstate = wxPyBeginAllowThreads();
28899 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28900
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 resultobj = SWIG_From_int((result));
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28912 PyObject *resultobj;
28913 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28914 wxDragResult arg2 ;
28915 bool result;
28916 PyObject * obj0 = 0 ;
28917 PyObject * obj1 = 0 ;
28918 char *kwnames[] = {
28919 (char *) "self",(char *) "effect", NULL
28920 };
28921
28922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28924 if (SWIG_arg_fail(1)) SWIG_fail;
28925 {
28926 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28927 if (SWIG_arg_fail(2)) SWIG_fail;
28928 }
28929 {
28930 PyThreadState* __tstate = wxPyBeginAllowThreads();
28931 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28932
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 {
28937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28938 }
28939 return resultobj;
28940 fail:
28941 return NULL;
28942 }
28943
28944
28945 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28946 PyObject *obj;
28947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28948 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28949 Py_INCREF(obj);
28950 return Py_BuildValue((char *)"");
28951 }
28952 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28953 PyObject *resultobj;
28954 wxDataObject *arg1 = (wxDataObject *) NULL ;
28955 wxPyDropTarget *result;
28956 PyObject * obj0 = 0 ;
28957 char *kwnames[] = {
28958 (char *) "dataObject", NULL
28959 };
28960
28961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28962 if (obj0) {
28963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28964 if (SWIG_arg_fail(1)) SWIG_fail;
28965 }
28966 {
28967 PyThreadState* __tstate = wxPyBeginAllowThreads();
28968 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28969
28970 wxPyEndAllowThreads(__tstate);
28971 if (PyErr_Occurred()) SWIG_fail;
28972 }
28973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28974 return resultobj;
28975 fail:
28976 return NULL;
28977 }
28978
28979
28980 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj;
28982 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28983 PyObject *arg2 = (PyObject *) 0 ;
28984 PyObject *arg3 = (PyObject *) 0 ;
28985 PyObject * obj0 = 0 ;
28986 PyObject * obj1 = 0 ;
28987 PyObject * obj2 = 0 ;
28988 char *kwnames[] = {
28989 (char *) "self",(char *) "self",(char *) "_class", NULL
28990 };
28991
28992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28994 if (SWIG_arg_fail(1)) SWIG_fail;
28995 arg2 = obj1;
28996 arg3 = obj2;
28997 {
28998 PyThreadState* __tstate = wxPyBeginAllowThreads();
28999 (arg1)->_setCallbackInfo(arg2,arg3);
29000
29001 wxPyEndAllowThreads(__tstate);
29002 if (PyErr_Occurred()) SWIG_fail;
29003 }
29004 Py_INCREF(Py_None); resultobj = Py_None;
29005 return resultobj;
29006 fail:
29007 return NULL;
29008 }
29009
29010
29011 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29012 PyObject *resultobj;
29013 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29014 PyObject * obj0 = 0 ;
29015 char *kwnames[] = {
29016 (char *) "self", NULL
29017 };
29018
29019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
29020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29021 if (SWIG_arg_fail(1)) SWIG_fail;
29022 {
29023 PyThreadState* __tstate = wxPyBeginAllowThreads();
29024 delete arg1;
29025
29026 wxPyEndAllowThreads(__tstate);
29027 if (PyErr_Occurred()) SWIG_fail;
29028 }
29029 Py_INCREF(Py_None); resultobj = Py_None;
29030 return resultobj;
29031 fail:
29032 return NULL;
29033 }
29034
29035
29036 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29037 PyObject *resultobj;
29038 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29039 wxDataObject *result;
29040 PyObject * obj0 = 0 ;
29041 char *kwnames[] = {
29042 (char *) "self", NULL
29043 };
29044
29045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29047 if (SWIG_arg_fail(1)) SWIG_fail;
29048 {
29049 PyThreadState* __tstate = wxPyBeginAllowThreads();
29050 result = (wxDataObject *)(arg1)->GetDataObject();
29051
29052 wxPyEndAllowThreads(__tstate);
29053 if (PyErr_Occurred()) SWIG_fail;
29054 }
29055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29056 return resultobj;
29057 fail:
29058 return NULL;
29059 }
29060
29061
29062 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj;
29064 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29065 wxDataObject *arg2 = (wxDataObject *) 0 ;
29066 PyObject * obj0 = 0 ;
29067 PyObject * obj1 = 0 ;
29068 char *kwnames[] = {
29069 (char *) "self",(char *) "dataObject", NULL
29070 };
29071
29072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29074 if (SWIG_arg_fail(1)) SWIG_fail;
29075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29076 if (SWIG_arg_fail(2)) SWIG_fail;
29077 {
29078 PyThreadState* __tstate = wxPyBeginAllowThreads();
29079 (arg1)->SetDataObject(arg2);
29080
29081 wxPyEndAllowThreads(__tstate);
29082 if (PyErr_Occurred()) SWIG_fail;
29083 }
29084 Py_INCREF(Py_None); resultobj = Py_None;
29085 return resultobj;
29086 fail:
29087 return NULL;
29088 }
29089
29090
29091 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29092 PyObject *resultobj;
29093 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29094 int arg2 ;
29095 int arg3 ;
29096 wxDragResult arg4 ;
29097 wxDragResult result;
29098 PyObject * obj0 = 0 ;
29099 PyObject * obj1 = 0 ;
29100 PyObject * obj2 = 0 ;
29101 PyObject * obj3 = 0 ;
29102 char *kwnames[] = {
29103 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29104 };
29105
29106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29108 if (SWIG_arg_fail(1)) SWIG_fail;
29109 {
29110 arg2 = (int)(SWIG_As_int(obj1));
29111 if (SWIG_arg_fail(2)) SWIG_fail;
29112 }
29113 {
29114 arg3 = (int)(SWIG_As_int(obj2));
29115 if (SWIG_arg_fail(3)) SWIG_fail;
29116 }
29117 {
29118 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29119 if (SWIG_arg_fail(4)) SWIG_fail;
29120 }
29121 {
29122 PyThreadState* __tstate = wxPyBeginAllowThreads();
29123 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29124
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 resultobj = SWIG_From_int((result));
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29136 PyObject *resultobj;
29137 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29138 int arg2 ;
29139 int arg3 ;
29140 wxDragResult arg4 ;
29141 wxDragResult result;
29142 PyObject * obj0 = 0 ;
29143 PyObject * obj1 = 0 ;
29144 PyObject * obj2 = 0 ;
29145 PyObject * obj3 = 0 ;
29146 char *kwnames[] = {
29147 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29148 };
29149
29150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29152 if (SWIG_arg_fail(1)) SWIG_fail;
29153 {
29154 arg2 = (int)(SWIG_As_int(obj1));
29155 if (SWIG_arg_fail(2)) SWIG_fail;
29156 }
29157 {
29158 arg3 = (int)(SWIG_As_int(obj2));
29159 if (SWIG_arg_fail(3)) SWIG_fail;
29160 }
29161 {
29162 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29163 if (SWIG_arg_fail(4)) SWIG_fail;
29164 }
29165 {
29166 PyThreadState* __tstate = wxPyBeginAllowThreads();
29167 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29168
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 resultobj = SWIG_From_int((result));
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29180 PyObject *resultobj;
29181 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29182 PyObject * obj0 = 0 ;
29183 char *kwnames[] = {
29184 (char *) "self", NULL
29185 };
29186
29187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29189 if (SWIG_arg_fail(1)) SWIG_fail;
29190 {
29191 PyThreadState* __tstate = wxPyBeginAllowThreads();
29192 (arg1)->base_OnLeave();
29193
29194 wxPyEndAllowThreads(__tstate);
29195 if (PyErr_Occurred()) SWIG_fail;
29196 }
29197 Py_INCREF(Py_None); resultobj = Py_None;
29198 return resultobj;
29199 fail:
29200 return NULL;
29201 }
29202
29203
29204 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29205 PyObject *resultobj;
29206 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29207 int arg2 ;
29208 int arg3 ;
29209 bool result;
29210 PyObject * obj0 = 0 ;
29211 PyObject * obj1 = 0 ;
29212 PyObject * obj2 = 0 ;
29213 char *kwnames[] = {
29214 (char *) "self",(char *) "x",(char *) "y", NULL
29215 };
29216
29217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29219 if (SWIG_arg_fail(1)) SWIG_fail;
29220 {
29221 arg2 = (int)(SWIG_As_int(obj1));
29222 if (SWIG_arg_fail(2)) SWIG_fail;
29223 }
29224 {
29225 arg3 = (int)(SWIG_As_int(obj2));
29226 if (SWIG_arg_fail(3)) SWIG_fail;
29227 }
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29231
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 {
29236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29237 }
29238 return resultobj;
29239 fail:
29240 return NULL;
29241 }
29242
29243
29244 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29245 PyObject *resultobj;
29246 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29247 bool result;
29248 PyObject * obj0 = 0 ;
29249 char *kwnames[] = {
29250 (char *) "self", NULL
29251 };
29252
29253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29255 if (SWIG_arg_fail(1)) SWIG_fail;
29256 {
29257 PyThreadState* __tstate = wxPyBeginAllowThreads();
29258 result = (bool)(arg1)->GetData();
29259
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 {
29264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29265 }
29266 return resultobj;
29267 fail:
29268 return NULL;
29269 }
29270
29271
29272 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29273 PyObject *resultobj;
29274 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29275 wxDragResult arg2 ;
29276 PyObject * obj0 = 0 ;
29277 PyObject * obj1 = 0 ;
29278 char *kwnames[] = {
29279 (char *) "self",(char *) "action", NULL
29280 };
29281
29282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29284 if (SWIG_arg_fail(1)) SWIG_fail;
29285 {
29286 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29287 if (SWIG_arg_fail(2)) SWIG_fail;
29288 }
29289 {
29290 PyThreadState* __tstate = wxPyBeginAllowThreads();
29291 (arg1)->SetDefaultAction((wxDragResult )arg2);
29292
29293 wxPyEndAllowThreads(__tstate);
29294 if (PyErr_Occurred()) SWIG_fail;
29295 }
29296 Py_INCREF(Py_None); resultobj = Py_None;
29297 return resultobj;
29298 fail:
29299 return NULL;
29300 }
29301
29302
29303 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29304 PyObject *resultobj;
29305 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29306 wxDragResult result;
29307 PyObject * obj0 = 0 ;
29308 char *kwnames[] = {
29309 (char *) "self", NULL
29310 };
29311
29312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29314 if (SWIG_arg_fail(1)) SWIG_fail;
29315 {
29316 PyThreadState* __tstate = wxPyBeginAllowThreads();
29317 result = (wxDragResult)(arg1)->GetDefaultAction();
29318
29319 wxPyEndAllowThreads(__tstate);
29320 if (PyErr_Occurred()) SWIG_fail;
29321 }
29322 resultobj = SWIG_From_int((result));
29323 return resultobj;
29324 fail:
29325 return NULL;
29326 }
29327
29328
29329 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29330 PyObject *obj;
29331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29332 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29333 Py_INCREF(obj);
29334 return Py_BuildValue((char *)"");
29335 }
29336 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29337 PyObject *resultobj;
29338 wxPyTextDropTarget *result;
29339 char *kwnames[] = {
29340 NULL
29341 };
29342
29343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29344 {
29345 PyThreadState* __tstate = wxPyBeginAllowThreads();
29346 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29347
29348 wxPyEndAllowThreads(__tstate);
29349 if (PyErr_Occurred()) SWIG_fail;
29350 }
29351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29352 return resultobj;
29353 fail:
29354 return NULL;
29355 }
29356
29357
29358 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29359 PyObject *resultobj;
29360 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29361 PyObject *arg2 = (PyObject *) 0 ;
29362 PyObject *arg3 = (PyObject *) 0 ;
29363 PyObject * obj0 = 0 ;
29364 PyObject * obj1 = 0 ;
29365 PyObject * obj2 = 0 ;
29366 char *kwnames[] = {
29367 (char *) "self",(char *) "self",(char *) "_class", NULL
29368 };
29369
29370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29372 if (SWIG_arg_fail(1)) SWIG_fail;
29373 arg2 = obj1;
29374 arg3 = obj2;
29375 {
29376 PyThreadState* __tstate = wxPyBeginAllowThreads();
29377 (arg1)->_setCallbackInfo(arg2,arg3);
29378
29379 wxPyEndAllowThreads(__tstate);
29380 if (PyErr_Occurred()) SWIG_fail;
29381 }
29382 Py_INCREF(Py_None); resultobj = Py_None;
29383 return resultobj;
29384 fail:
29385 return NULL;
29386 }
29387
29388
29389 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29390 PyObject *resultobj;
29391 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29392 int arg2 ;
29393 int arg3 ;
29394 wxDragResult arg4 ;
29395 wxDragResult result;
29396 PyObject * obj0 = 0 ;
29397 PyObject * obj1 = 0 ;
29398 PyObject * obj2 = 0 ;
29399 PyObject * obj3 = 0 ;
29400 char *kwnames[] = {
29401 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29402 };
29403
29404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29406 if (SWIG_arg_fail(1)) SWIG_fail;
29407 {
29408 arg2 = (int)(SWIG_As_int(obj1));
29409 if (SWIG_arg_fail(2)) SWIG_fail;
29410 }
29411 {
29412 arg3 = (int)(SWIG_As_int(obj2));
29413 if (SWIG_arg_fail(3)) SWIG_fail;
29414 }
29415 {
29416 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29417 if (SWIG_arg_fail(4)) SWIG_fail;
29418 }
29419 {
29420 PyThreadState* __tstate = wxPyBeginAllowThreads();
29421 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29422
29423 wxPyEndAllowThreads(__tstate);
29424 if (PyErr_Occurred()) SWIG_fail;
29425 }
29426 resultobj = SWIG_From_int((result));
29427 return resultobj;
29428 fail:
29429 return NULL;
29430 }
29431
29432
29433 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29434 PyObject *resultobj;
29435 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29436 int arg2 ;
29437 int arg3 ;
29438 wxDragResult arg4 ;
29439 wxDragResult result;
29440 PyObject * obj0 = 0 ;
29441 PyObject * obj1 = 0 ;
29442 PyObject * obj2 = 0 ;
29443 PyObject * obj3 = 0 ;
29444 char *kwnames[] = {
29445 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29446 };
29447
29448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29450 if (SWIG_arg_fail(1)) SWIG_fail;
29451 {
29452 arg2 = (int)(SWIG_As_int(obj1));
29453 if (SWIG_arg_fail(2)) SWIG_fail;
29454 }
29455 {
29456 arg3 = (int)(SWIG_As_int(obj2));
29457 if (SWIG_arg_fail(3)) SWIG_fail;
29458 }
29459 {
29460 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29461 if (SWIG_arg_fail(4)) SWIG_fail;
29462 }
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29466
29467 wxPyEndAllowThreads(__tstate);
29468 if (PyErr_Occurred()) SWIG_fail;
29469 }
29470 resultobj = SWIG_From_int((result));
29471 return resultobj;
29472 fail:
29473 return NULL;
29474 }
29475
29476
29477 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29478 PyObject *resultobj;
29479 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29480 PyObject * obj0 = 0 ;
29481 char *kwnames[] = {
29482 (char *) "self", NULL
29483 };
29484
29485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29487 if (SWIG_arg_fail(1)) SWIG_fail;
29488 {
29489 PyThreadState* __tstate = wxPyBeginAllowThreads();
29490 (arg1)->base_OnLeave();
29491
29492 wxPyEndAllowThreads(__tstate);
29493 if (PyErr_Occurred()) SWIG_fail;
29494 }
29495 Py_INCREF(Py_None); resultobj = Py_None;
29496 return resultobj;
29497 fail:
29498 return NULL;
29499 }
29500
29501
29502 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29503 PyObject *resultobj;
29504 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29505 int arg2 ;
29506 int arg3 ;
29507 bool result;
29508 PyObject * obj0 = 0 ;
29509 PyObject * obj1 = 0 ;
29510 PyObject * obj2 = 0 ;
29511 char *kwnames[] = {
29512 (char *) "self",(char *) "x",(char *) "y", NULL
29513 };
29514
29515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29517 if (SWIG_arg_fail(1)) SWIG_fail;
29518 {
29519 arg2 = (int)(SWIG_As_int(obj1));
29520 if (SWIG_arg_fail(2)) SWIG_fail;
29521 }
29522 {
29523 arg3 = (int)(SWIG_As_int(obj2));
29524 if (SWIG_arg_fail(3)) SWIG_fail;
29525 }
29526 {
29527 PyThreadState* __tstate = wxPyBeginAllowThreads();
29528 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29529
29530 wxPyEndAllowThreads(__tstate);
29531 if (PyErr_Occurred()) SWIG_fail;
29532 }
29533 {
29534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29535 }
29536 return resultobj;
29537 fail:
29538 return NULL;
29539 }
29540
29541
29542 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29543 PyObject *resultobj;
29544 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29545 int arg2 ;
29546 int arg3 ;
29547 wxDragResult arg4 ;
29548 wxDragResult result;
29549 PyObject * obj0 = 0 ;
29550 PyObject * obj1 = 0 ;
29551 PyObject * obj2 = 0 ;
29552 PyObject * obj3 = 0 ;
29553 char *kwnames[] = {
29554 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29555 };
29556
29557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29559 if (SWIG_arg_fail(1)) SWIG_fail;
29560 {
29561 arg2 = (int)(SWIG_As_int(obj1));
29562 if (SWIG_arg_fail(2)) SWIG_fail;
29563 }
29564 {
29565 arg3 = (int)(SWIG_As_int(obj2));
29566 if (SWIG_arg_fail(3)) SWIG_fail;
29567 }
29568 {
29569 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29570 if (SWIG_arg_fail(4)) SWIG_fail;
29571 }
29572 {
29573 PyThreadState* __tstate = wxPyBeginAllowThreads();
29574 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29575
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 resultobj = SWIG_From_int((result));
29580 return resultobj;
29581 fail:
29582 return NULL;
29583 }
29584
29585
29586 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29587 PyObject *obj;
29588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29589 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29590 Py_INCREF(obj);
29591 return Py_BuildValue((char *)"");
29592 }
29593 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29594 PyObject *resultobj;
29595 wxPyFileDropTarget *result;
29596 char *kwnames[] = {
29597 NULL
29598 };
29599
29600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29601 {
29602 PyThreadState* __tstate = wxPyBeginAllowThreads();
29603 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29604
29605 wxPyEndAllowThreads(__tstate);
29606 if (PyErr_Occurred()) SWIG_fail;
29607 }
29608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29616 PyObject *resultobj;
29617 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29618 PyObject *arg2 = (PyObject *) 0 ;
29619 PyObject *arg3 = (PyObject *) 0 ;
29620 PyObject * obj0 = 0 ;
29621 PyObject * obj1 = 0 ;
29622 PyObject * obj2 = 0 ;
29623 char *kwnames[] = {
29624 (char *) "self",(char *) "self",(char *) "_class", NULL
29625 };
29626
29627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29629 if (SWIG_arg_fail(1)) SWIG_fail;
29630 arg2 = obj1;
29631 arg3 = obj2;
29632 {
29633 PyThreadState* __tstate = wxPyBeginAllowThreads();
29634 (arg1)->_setCallbackInfo(arg2,arg3);
29635
29636 wxPyEndAllowThreads(__tstate);
29637 if (PyErr_Occurred()) SWIG_fail;
29638 }
29639 Py_INCREF(Py_None); resultobj = Py_None;
29640 return resultobj;
29641 fail:
29642 return NULL;
29643 }
29644
29645
29646 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29647 PyObject *resultobj;
29648 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29649 int arg2 ;
29650 int arg3 ;
29651 wxDragResult arg4 ;
29652 wxDragResult result;
29653 PyObject * obj0 = 0 ;
29654 PyObject * obj1 = 0 ;
29655 PyObject * obj2 = 0 ;
29656 PyObject * obj3 = 0 ;
29657 char *kwnames[] = {
29658 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29659 };
29660
29661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29663 if (SWIG_arg_fail(1)) SWIG_fail;
29664 {
29665 arg2 = (int)(SWIG_As_int(obj1));
29666 if (SWIG_arg_fail(2)) SWIG_fail;
29667 }
29668 {
29669 arg3 = (int)(SWIG_As_int(obj2));
29670 if (SWIG_arg_fail(3)) SWIG_fail;
29671 }
29672 {
29673 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29674 if (SWIG_arg_fail(4)) SWIG_fail;
29675 }
29676 {
29677 PyThreadState* __tstate = wxPyBeginAllowThreads();
29678 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29679
29680 wxPyEndAllowThreads(__tstate);
29681 if (PyErr_Occurred()) SWIG_fail;
29682 }
29683 resultobj = SWIG_From_int((result));
29684 return resultobj;
29685 fail:
29686 return NULL;
29687 }
29688
29689
29690 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29691 PyObject *resultobj;
29692 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29693 int arg2 ;
29694 int arg3 ;
29695 wxDragResult arg4 ;
29696 wxDragResult result;
29697 PyObject * obj0 = 0 ;
29698 PyObject * obj1 = 0 ;
29699 PyObject * obj2 = 0 ;
29700 PyObject * obj3 = 0 ;
29701 char *kwnames[] = {
29702 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29703 };
29704
29705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29707 if (SWIG_arg_fail(1)) SWIG_fail;
29708 {
29709 arg2 = (int)(SWIG_As_int(obj1));
29710 if (SWIG_arg_fail(2)) SWIG_fail;
29711 }
29712 {
29713 arg3 = (int)(SWIG_As_int(obj2));
29714 if (SWIG_arg_fail(3)) SWIG_fail;
29715 }
29716 {
29717 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29718 if (SWIG_arg_fail(4)) SWIG_fail;
29719 }
29720 {
29721 PyThreadState* __tstate = wxPyBeginAllowThreads();
29722 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29723
29724 wxPyEndAllowThreads(__tstate);
29725 if (PyErr_Occurred()) SWIG_fail;
29726 }
29727 resultobj = SWIG_From_int((result));
29728 return resultobj;
29729 fail:
29730 return NULL;
29731 }
29732
29733
29734 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29735 PyObject *resultobj;
29736 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29737 PyObject * obj0 = 0 ;
29738 char *kwnames[] = {
29739 (char *) "self", NULL
29740 };
29741
29742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29744 if (SWIG_arg_fail(1)) SWIG_fail;
29745 {
29746 PyThreadState* __tstate = wxPyBeginAllowThreads();
29747 (arg1)->base_OnLeave();
29748
29749 wxPyEndAllowThreads(__tstate);
29750 if (PyErr_Occurred()) SWIG_fail;
29751 }
29752 Py_INCREF(Py_None); resultobj = Py_None;
29753 return resultobj;
29754 fail:
29755 return NULL;
29756 }
29757
29758
29759 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29760 PyObject *resultobj;
29761 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29762 int arg2 ;
29763 int arg3 ;
29764 bool result;
29765 PyObject * obj0 = 0 ;
29766 PyObject * obj1 = 0 ;
29767 PyObject * obj2 = 0 ;
29768 char *kwnames[] = {
29769 (char *) "self",(char *) "x",(char *) "y", NULL
29770 };
29771
29772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29774 if (SWIG_arg_fail(1)) SWIG_fail;
29775 {
29776 arg2 = (int)(SWIG_As_int(obj1));
29777 if (SWIG_arg_fail(2)) SWIG_fail;
29778 }
29779 {
29780 arg3 = (int)(SWIG_As_int(obj2));
29781 if (SWIG_arg_fail(3)) SWIG_fail;
29782 }
29783 {
29784 PyThreadState* __tstate = wxPyBeginAllowThreads();
29785 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29786
29787 wxPyEndAllowThreads(__tstate);
29788 if (PyErr_Occurred()) SWIG_fail;
29789 }
29790 {
29791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29792 }
29793 return resultobj;
29794 fail:
29795 return NULL;
29796 }
29797
29798
29799 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29800 PyObject *resultobj;
29801 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29802 int arg2 ;
29803 int arg3 ;
29804 wxDragResult arg4 ;
29805 wxDragResult result;
29806 PyObject * obj0 = 0 ;
29807 PyObject * obj1 = 0 ;
29808 PyObject * obj2 = 0 ;
29809 PyObject * obj3 = 0 ;
29810 char *kwnames[] = {
29811 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29812 };
29813
29814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29816 if (SWIG_arg_fail(1)) SWIG_fail;
29817 {
29818 arg2 = (int)(SWIG_As_int(obj1));
29819 if (SWIG_arg_fail(2)) SWIG_fail;
29820 }
29821 {
29822 arg3 = (int)(SWIG_As_int(obj2));
29823 if (SWIG_arg_fail(3)) SWIG_fail;
29824 }
29825 {
29826 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29827 if (SWIG_arg_fail(4)) SWIG_fail;
29828 }
29829 {
29830 PyThreadState* __tstate = wxPyBeginAllowThreads();
29831 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29832
29833 wxPyEndAllowThreads(__tstate);
29834 if (PyErr_Occurred()) SWIG_fail;
29835 }
29836 resultobj = SWIG_From_int((result));
29837 return resultobj;
29838 fail:
29839 return NULL;
29840 }
29841
29842
29843 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29844 PyObject *obj;
29845 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29846 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29847 Py_INCREF(obj);
29848 return Py_BuildValue((char *)"");
29849 }
29850 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29851 PyObject *resultobj;
29852 wxClipboard *result;
29853 char *kwnames[] = {
29854 NULL
29855 };
29856
29857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29858 {
29859 PyThreadState* __tstate = wxPyBeginAllowThreads();
29860 result = (wxClipboard *)new wxClipboard();
29861
29862 wxPyEndAllowThreads(__tstate);
29863 if (PyErr_Occurred()) SWIG_fail;
29864 }
29865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29866 return resultobj;
29867 fail:
29868 return NULL;
29869 }
29870
29871
29872 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29873 PyObject *resultobj;
29874 wxClipboard *arg1 = (wxClipboard *) 0 ;
29875 PyObject * obj0 = 0 ;
29876 char *kwnames[] = {
29877 (char *) "self", NULL
29878 };
29879
29880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29882 if (SWIG_arg_fail(1)) SWIG_fail;
29883 {
29884 PyThreadState* __tstate = wxPyBeginAllowThreads();
29885 delete arg1;
29886
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 Py_INCREF(Py_None); resultobj = Py_None;
29891 return resultobj;
29892 fail:
29893 return NULL;
29894 }
29895
29896
29897 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29898 PyObject *resultobj;
29899 wxClipboard *arg1 = (wxClipboard *) 0 ;
29900 bool result;
29901 PyObject * obj0 = 0 ;
29902 char *kwnames[] = {
29903 (char *) "self", NULL
29904 };
29905
29906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29908 if (SWIG_arg_fail(1)) SWIG_fail;
29909 {
29910 PyThreadState* __tstate = wxPyBeginAllowThreads();
29911 result = (bool)(arg1)->Open();
29912
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 {
29917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29918 }
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj;
29927 wxClipboard *arg1 = (wxClipboard *) 0 ;
29928 PyObject * obj0 = 0 ;
29929 char *kwnames[] = {
29930 (char *) "self", NULL
29931 };
29932
29933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29935 if (SWIG_arg_fail(1)) SWIG_fail;
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 (arg1)->Close();
29939
29940 wxPyEndAllowThreads(__tstate);
29941 if (PyErr_Occurred()) SWIG_fail;
29942 }
29943 Py_INCREF(Py_None); resultobj = Py_None;
29944 return resultobj;
29945 fail:
29946 return NULL;
29947 }
29948
29949
29950 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29951 PyObject *resultobj;
29952 wxClipboard *arg1 = (wxClipboard *) 0 ;
29953 bool result;
29954 PyObject * obj0 = 0 ;
29955 char *kwnames[] = {
29956 (char *) "self", NULL
29957 };
29958
29959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29961 if (SWIG_arg_fail(1)) SWIG_fail;
29962 {
29963 PyThreadState* __tstate = wxPyBeginAllowThreads();
29964 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29965
29966 wxPyEndAllowThreads(__tstate);
29967 if (PyErr_Occurred()) SWIG_fail;
29968 }
29969 {
29970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29971 }
29972 return resultobj;
29973 fail:
29974 return NULL;
29975 }
29976
29977
29978 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29979 PyObject *resultobj;
29980 wxClipboard *arg1 = (wxClipboard *) 0 ;
29981 wxDataObject *arg2 = (wxDataObject *) 0 ;
29982 bool result;
29983 PyObject * obj0 = 0 ;
29984 PyObject * obj1 = 0 ;
29985 char *kwnames[] = {
29986 (char *) "self",(char *) "data", NULL
29987 };
29988
29989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29991 if (SWIG_arg_fail(1)) SWIG_fail;
29992 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29993 if (SWIG_arg_fail(2)) SWIG_fail;
29994 {
29995 PyThreadState* __tstate = wxPyBeginAllowThreads();
29996 result = (bool)(arg1)->AddData(arg2);
29997
29998 wxPyEndAllowThreads(__tstate);
29999 if (PyErr_Occurred()) SWIG_fail;
30000 }
30001 {
30002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30003 }
30004 return resultobj;
30005 fail:
30006 return NULL;
30007 }
30008
30009
30010 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
30011 PyObject *resultobj;
30012 wxClipboard *arg1 = (wxClipboard *) 0 ;
30013 wxDataObject *arg2 = (wxDataObject *) 0 ;
30014 bool result;
30015 PyObject * obj0 = 0 ;
30016 PyObject * obj1 = 0 ;
30017 char *kwnames[] = {
30018 (char *) "self",(char *) "data", NULL
30019 };
30020
30021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
30022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30023 if (SWIG_arg_fail(1)) SWIG_fail;
30024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30025 if (SWIG_arg_fail(2)) SWIG_fail;
30026 {
30027 PyThreadState* __tstate = wxPyBeginAllowThreads();
30028 result = (bool)(arg1)->SetData(arg2);
30029
30030 wxPyEndAllowThreads(__tstate);
30031 if (PyErr_Occurred()) SWIG_fail;
30032 }
30033 {
30034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30035 }
30036 return resultobj;
30037 fail:
30038 return NULL;
30039 }
30040
30041
30042 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30043 PyObject *resultobj;
30044 wxClipboard *arg1 = (wxClipboard *) 0 ;
30045 wxDataFormat *arg2 = 0 ;
30046 bool result;
30047 PyObject * obj0 = 0 ;
30048 PyObject * obj1 = 0 ;
30049 char *kwnames[] = {
30050 (char *) "self",(char *) "format", NULL
30051 };
30052
30053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30055 if (SWIG_arg_fail(1)) SWIG_fail;
30056 {
30057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30058 if (SWIG_arg_fail(2)) SWIG_fail;
30059 if (arg2 == NULL) {
30060 SWIG_null_ref("wxDataFormat");
30061 }
30062 if (SWIG_arg_fail(2)) SWIG_fail;
30063 }
30064 {
30065 PyThreadState* __tstate = wxPyBeginAllowThreads();
30066 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30067
30068 wxPyEndAllowThreads(__tstate);
30069 if (PyErr_Occurred()) SWIG_fail;
30070 }
30071 {
30072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30073 }
30074 return resultobj;
30075 fail:
30076 return NULL;
30077 }
30078
30079
30080 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30081 PyObject *resultobj;
30082 wxClipboard *arg1 = (wxClipboard *) 0 ;
30083 wxDataObject *arg2 = 0 ;
30084 bool result;
30085 PyObject * obj0 = 0 ;
30086 PyObject * obj1 = 0 ;
30087 char *kwnames[] = {
30088 (char *) "self",(char *) "data", NULL
30089 };
30090
30091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30093 if (SWIG_arg_fail(1)) SWIG_fail;
30094 {
30095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30096 if (SWIG_arg_fail(2)) SWIG_fail;
30097 if (arg2 == NULL) {
30098 SWIG_null_ref("wxDataObject");
30099 }
30100 if (SWIG_arg_fail(2)) SWIG_fail;
30101 }
30102 {
30103 PyThreadState* __tstate = wxPyBeginAllowThreads();
30104 result = (bool)(arg1)->GetData(*arg2);
30105
30106 wxPyEndAllowThreads(__tstate);
30107 if (PyErr_Occurred()) SWIG_fail;
30108 }
30109 {
30110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30111 }
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj;
30120 wxClipboard *arg1 = (wxClipboard *) 0 ;
30121 PyObject * obj0 = 0 ;
30122 char *kwnames[] = {
30123 (char *) "self", NULL
30124 };
30125
30126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30128 if (SWIG_arg_fail(1)) SWIG_fail;
30129 {
30130 PyThreadState* __tstate = wxPyBeginAllowThreads();
30131 (arg1)->Clear();
30132
30133 wxPyEndAllowThreads(__tstate);
30134 if (PyErr_Occurred()) SWIG_fail;
30135 }
30136 Py_INCREF(Py_None); resultobj = Py_None;
30137 return resultobj;
30138 fail:
30139 return NULL;
30140 }
30141
30142
30143 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30144 PyObject *resultobj;
30145 wxClipboard *arg1 = (wxClipboard *) 0 ;
30146 bool result;
30147 PyObject * obj0 = 0 ;
30148 char *kwnames[] = {
30149 (char *) "self", NULL
30150 };
30151
30152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30154 if (SWIG_arg_fail(1)) SWIG_fail;
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = (bool)(arg1)->Flush();
30158
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 {
30163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30164 }
30165 return resultobj;
30166 fail:
30167 return NULL;
30168 }
30169
30170
30171 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30172 PyObject *resultobj;
30173 wxClipboard *arg1 = (wxClipboard *) 0 ;
30174 bool arg2 = (bool) true ;
30175 PyObject * obj0 = 0 ;
30176 PyObject * obj1 = 0 ;
30177 char *kwnames[] = {
30178 (char *) "self",(char *) "primary", NULL
30179 };
30180
30181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30183 if (SWIG_arg_fail(1)) SWIG_fail;
30184 if (obj1) {
30185 {
30186 arg2 = (bool)(SWIG_As_bool(obj1));
30187 if (SWIG_arg_fail(2)) SWIG_fail;
30188 }
30189 }
30190 {
30191 PyThreadState* __tstate = wxPyBeginAllowThreads();
30192 (arg1)->UsePrimarySelection(arg2);
30193
30194 wxPyEndAllowThreads(__tstate);
30195 if (PyErr_Occurred()) SWIG_fail;
30196 }
30197 Py_INCREF(Py_None); resultobj = Py_None;
30198 return resultobj;
30199 fail:
30200 return NULL;
30201 }
30202
30203
30204 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30205 PyObject *resultobj;
30206 wxClipboard *result;
30207 char *kwnames[] = {
30208 NULL
30209 };
30210
30211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30212 {
30213 PyThreadState* __tstate = wxPyBeginAllowThreads();
30214 result = (wxClipboard *)wxClipboard::Get();
30215
30216 wxPyEndAllowThreads(__tstate);
30217 if (PyErr_Occurred()) SWIG_fail;
30218 }
30219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30220 return resultobj;
30221 fail:
30222 return NULL;
30223 }
30224
30225
30226 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30227 PyObject *obj;
30228 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30229 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30230 Py_INCREF(obj);
30231 return Py_BuildValue((char *)"");
30232 }
30233 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30234 PyObject *resultobj;
30235 wxClipboard *arg1 = (wxClipboard *) NULL ;
30236 wxClipboardLocker *result;
30237 PyObject * obj0 = 0 ;
30238 char *kwnames[] = {
30239 (char *) "clipboard", NULL
30240 };
30241
30242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30243 if (obj0) {
30244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30245 if (SWIG_arg_fail(1)) SWIG_fail;
30246 }
30247 {
30248 PyThreadState* __tstate = wxPyBeginAllowThreads();
30249 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30250
30251 wxPyEndAllowThreads(__tstate);
30252 if (PyErr_Occurred()) SWIG_fail;
30253 }
30254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30255 return resultobj;
30256 fail:
30257 return NULL;
30258 }
30259
30260
30261 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30262 PyObject *resultobj;
30263 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30264 PyObject * obj0 = 0 ;
30265 char *kwnames[] = {
30266 (char *) "self", NULL
30267 };
30268
30269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30271 if (SWIG_arg_fail(1)) SWIG_fail;
30272 {
30273 PyThreadState* __tstate = wxPyBeginAllowThreads();
30274 delete arg1;
30275
30276 wxPyEndAllowThreads(__tstate);
30277 if (PyErr_Occurred()) SWIG_fail;
30278 }
30279 Py_INCREF(Py_None); resultobj = Py_None;
30280 return resultobj;
30281 fail:
30282 return NULL;
30283 }
30284
30285
30286 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30287 PyObject *resultobj;
30288 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30289 bool result;
30290 PyObject * obj0 = 0 ;
30291 char *kwnames[] = {
30292 (char *) "self", NULL
30293 };
30294
30295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30297 if (SWIG_arg_fail(1)) SWIG_fail;
30298 {
30299 PyThreadState* __tstate = wxPyBeginAllowThreads();
30300 result = (bool)wxClipboardLocker___nonzero__(arg1);
30301
30302 wxPyEndAllowThreads(__tstate);
30303 if (PyErr_Occurred()) SWIG_fail;
30304 }
30305 {
30306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30307 }
30308 return resultobj;
30309 fail:
30310 return NULL;
30311 }
30312
30313
30314 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30315 PyObject *obj;
30316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30317 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30318 Py_INCREF(obj);
30319 return Py_BuildValue((char *)"");
30320 }
30321 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30322 PyObject *resultobj;
30323 int arg1 = (int) 0 ;
30324 int arg2 = (int) 0 ;
30325 int arg3 = (int) 0 ;
30326 int arg4 = (int) 0 ;
30327 wxVideoMode *result;
30328 PyObject * obj0 = 0 ;
30329 PyObject * obj1 = 0 ;
30330 PyObject * obj2 = 0 ;
30331 PyObject * obj3 = 0 ;
30332 char *kwnames[] = {
30333 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30334 };
30335
30336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30337 if (obj0) {
30338 {
30339 arg1 = (int)(SWIG_As_int(obj0));
30340 if (SWIG_arg_fail(1)) SWIG_fail;
30341 }
30342 }
30343 if (obj1) {
30344 {
30345 arg2 = (int)(SWIG_As_int(obj1));
30346 if (SWIG_arg_fail(2)) SWIG_fail;
30347 }
30348 }
30349 if (obj2) {
30350 {
30351 arg3 = (int)(SWIG_As_int(obj2));
30352 if (SWIG_arg_fail(3)) SWIG_fail;
30353 }
30354 }
30355 if (obj3) {
30356 {
30357 arg4 = (int)(SWIG_As_int(obj3));
30358 if (SWIG_arg_fail(4)) SWIG_fail;
30359 }
30360 }
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30364
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30369 return resultobj;
30370 fail:
30371 return NULL;
30372 }
30373
30374
30375 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30376 PyObject *resultobj;
30377 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30378 PyObject * obj0 = 0 ;
30379 char *kwnames[] = {
30380 (char *) "self", NULL
30381 };
30382
30383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30385 if (SWIG_arg_fail(1)) SWIG_fail;
30386 {
30387 PyThreadState* __tstate = wxPyBeginAllowThreads();
30388 delete arg1;
30389
30390 wxPyEndAllowThreads(__tstate);
30391 if (PyErr_Occurred()) SWIG_fail;
30392 }
30393 Py_INCREF(Py_None); resultobj = Py_None;
30394 return resultobj;
30395 fail:
30396 return NULL;
30397 }
30398
30399
30400 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30401 PyObject *resultobj;
30402 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30403 wxVideoMode *arg2 = 0 ;
30404 bool result;
30405 PyObject * obj0 = 0 ;
30406 PyObject * obj1 = 0 ;
30407 char *kwnames[] = {
30408 (char *) "self",(char *) "other", NULL
30409 };
30410
30411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30413 if (SWIG_arg_fail(1)) SWIG_fail;
30414 {
30415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30416 if (SWIG_arg_fail(2)) SWIG_fail;
30417 if (arg2 == NULL) {
30418 SWIG_null_ref("wxVideoMode");
30419 }
30420 if (SWIG_arg_fail(2)) SWIG_fail;
30421 }
30422 {
30423 PyThreadState* __tstate = wxPyBeginAllowThreads();
30424 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30425
30426 wxPyEndAllowThreads(__tstate);
30427 if (PyErr_Occurred()) SWIG_fail;
30428 }
30429 {
30430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30431 }
30432 return resultobj;
30433 fail:
30434 return NULL;
30435 }
30436
30437
30438 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30439 PyObject *resultobj;
30440 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30441 int result;
30442 PyObject * obj0 = 0 ;
30443 char *kwnames[] = {
30444 (char *) "self", NULL
30445 };
30446
30447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30449 if (SWIG_arg_fail(1)) SWIG_fail;
30450 {
30451 PyThreadState* __tstate = wxPyBeginAllowThreads();
30452 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30453
30454 wxPyEndAllowThreads(__tstate);
30455 if (PyErr_Occurred()) SWIG_fail;
30456 }
30457 {
30458 resultobj = SWIG_From_int((int)(result));
30459 }
30460 return resultobj;
30461 fail:
30462 return NULL;
30463 }
30464
30465
30466 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30467 PyObject *resultobj;
30468 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30469 int result;
30470 PyObject * obj0 = 0 ;
30471 char *kwnames[] = {
30472 (char *) "self", NULL
30473 };
30474
30475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30477 if (SWIG_arg_fail(1)) SWIG_fail;
30478 {
30479 PyThreadState* __tstate = wxPyBeginAllowThreads();
30480 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30481
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 {
30486 resultobj = SWIG_From_int((int)(result));
30487 }
30488 return resultobj;
30489 fail:
30490 return NULL;
30491 }
30492
30493
30494 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30495 PyObject *resultobj;
30496 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30497 int result;
30498 PyObject * obj0 = 0 ;
30499 char *kwnames[] = {
30500 (char *) "self", NULL
30501 };
30502
30503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30505 if (SWIG_arg_fail(1)) SWIG_fail;
30506 {
30507 PyThreadState* __tstate = wxPyBeginAllowThreads();
30508 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30509
30510 wxPyEndAllowThreads(__tstate);
30511 if (PyErr_Occurred()) SWIG_fail;
30512 }
30513 {
30514 resultobj = SWIG_From_int((int)(result));
30515 }
30516 return resultobj;
30517 fail:
30518 return NULL;
30519 }
30520
30521
30522 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30523 PyObject *resultobj;
30524 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30525 bool result;
30526 PyObject * obj0 = 0 ;
30527 char *kwnames[] = {
30528 (char *) "self", NULL
30529 };
30530
30531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30533 if (SWIG_arg_fail(1)) SWIG_fail;
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30537
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 {
30542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30543 }
30544 return resultobj;
30545 fail:
30546 return NULL;
30547 }
30548
30549
30550 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30551 PyObject *resultobj;
30552 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30553 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30554 bool result;
30555 PyObject * obj0 = 0 ;
30556 PyObject * obj1 = 0 ;
30557 char *kwnames[] = {
30558 (char *) "self",(char *) "other", NULL
30559 };
30560
30561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30563 if (SWIG_arg_fail(1)) SWIG_fail;
30564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30565 if (SWIG_arg_fail(2)) SWIG_fail;
30566 {
30567 PyThreadState* __tstate = wxPyBeginAllowThreads();
30568 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30569
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 {
30574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30575 }
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30583 PyObject *resultobj;
30584 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30585 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30586 bool result;
30587 PyObject * obj0 = 0 ;
30588 PyObject * obj1 = 0 ;
30589 char *kwnames[] = {
30590 (char *) "self",(char *) "other", NULL
30591 };
30592
30593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30595 if (SWIG_arg_fail(1)) SWIG_fail;
30596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30597 if (SWIG_arg_fail(2)) SWIG_fail;
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30601
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 {
30606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30607 }
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30615 PyObject *resultobj;
30616 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30617 int arg2 ;
30618 PyObject * obj0 = 0 ;
30619 PyObject * obj1 = 0 ;
30620 char *kwnames[] = {
30621 (char *) "self",(char *) "w", NULL
30622 };
30623
30624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30626 if (SWIG_arg_fail(1)) SWIG_fail;
30627 {
30628 arg2 = (int)(SWIG_As_int(obj1));
30629 if (SWIG_arg_fail(2)) SWIG_fail;
30630 }
30631 if (arg1) (arg1)->w = arg2;
30632
30633 Py_INCREF(Py_None); resultobj = Py_None;
30634 return resultobj;
30635 fail:
30636 return NULL;
30637 }
30638
30639
30640 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30641 PyObject *resultobj;
30642 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30643 int result;
30644 PyObject * obj0 = 0 ;
30645 char *kwnames[] = {
30646 (char *) "self", NULL
30647 };
30648
30649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30651 if (SWIG_arg_fail(1)) SWIG_fail;
30652 result = (int) ((arg1)->w);
30653
30654 {
30655 resultobj = SWIG_From_int((int)(result));
30656 }
30657 return resultobj;
30658 fail:
30659 return NULL;
30660 }
30661
30662
30663 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30664 PyObject *resultobj;
30665 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30666 int arg2 ;
30667 PyObject * obj0 = 0 ;
30668 PyObject * obj1 = 0 ;
30669 char *kwnames[] = {
30670 (char *) "self",(char *) "h", NULL
30671 };
30672
30673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30675 if (SWIG_arg_fail(1)) SWIG_fail;
30676 {
30677 arg2 = (int)(SWIG_As_int(obj1));
30678 if (SWIG_arg_fail(2)) SWIG_fail;
30679 }
30680 if (arg1) (arg1)->h = arg2;
30681
30682 Py_INCREF(Py_None); resultobj = Py_None;
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30690 PyObject *resultobj;
30691 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30692 int result;
30693 PyObject * obj0 = 0 ;
30694 char *kwnames[] = {
30695 (char *) "self", NULL
30696 };
30697
30698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30700 if (SWIG_arg_fail(1)) SWIG_fail;
30701 result = (int) ((arg1)->h);
30702
30703 {
30704 resultobj = SWIG_From_int((int)(result));
30705 }
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30713 PyObject *resultobj;
30714 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30715 int arg2 ;
30716 PyObject * obj0 = 0 ;
30717 PyObject * obj1 = 0 ;
30718 char *kwnames[] = {
30719 (char *) "self",(char *) "bpp", NULL
30720 };
30721
30722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30724 if (SWIG_arg_fail(1)) SWIG_fail;
30725 {
30726 arg2 = (int)(SWIG_As_int(obj1));
30727 if (SWIG_arg_fail(2)) SWIG_fail;
30728 }
30729 if (arg1) (arg1)->bpp = arg2;
30730
30731 Py_INCREF(Py_None); resultobj = Py_None;
30732 return resultobj;
30733 fail:
30734 return NULL;
30735 }
30736
30737
30738 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30739 PyObject *resultobj;
30740 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30741 int result;
30742 PyObject * obj0 = 0 ;
30743 char *kwnames[] = {
30744 (char *) "self", NULL
30745 };
30746
30747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30749 if (SWIG_arg_fail(1)) SWIG_fail;
30750 result = (int) ((arg1)->bpp);
30751
30752 {
30753 resultobj = SWIG_From_int((int)(result));
30754 }
30755 return resultobj;
30756 fail:
30757 return NULL;
30758 }
30759
30760
30761 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30762 PyObject *resultobj;
30763 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30764 int arg2 ;
30765 PyObject * obj0 = 0 ;
30766 PyObject * obj1 = 0 ;
30767 char *kwnames[] = {
30768 (char *) "self",(char *) "refresh", NULL
30769 };
30770
30771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30773 if (SWIG_arg_fail(1)) SWIG_fail;
30774 {
30775 arg2 = (int)(SWIG_As_int(obj1));
30776 if (SWIG_arg_fail(2)) SWIG_fail;
30777 }
30778 if (arg1) (arg1)->refresh = arg2;
30779
30780 Py_INCREF(Py_None); resultobj = Py_None;
30781 return resultobj;
30782 fail:
30783 return NULL;
30784 }
30785
30786
30787 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30788 PyObject *resultobj;
30789 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30790 int result;
30791 PyObject * obj0 = 0 ;
30792 char *kwnames[] = {
30793 (char *) "self", NULL
30794 };
30795
30796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30798 if (SWIG_arg_fail(1)) SWIG_fail;
30799 result = (int) ((arg1)->refresh);
30800
30801 {
30802 resultobj = SWIG_From_int((int)(result));
30803 }
30804 return resultobj;
30805 fail:
30806 return NULL;
30807 }
30808
30809
30810 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30811 PyObject *obj;
30812 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30813 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30814 Py_INCREF(obj);
30815 return Py_BuildValue((char *)"");
30816 }
30817 static int _wrap_DefaultVideoMode_set(PyObject *) {
30818 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30819 return 1;
30820 }
30821
30822
30823 static PyObject *_wrap_DefaultVideoMode_get(void) {
30824 PyObject *pyobj;
30825
30826 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30827 return pyobj;
30828 }
30829
30830
30831 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30832 PyObject *resultobj;
30833 size_t arg1 = (size_t) 0 ;
30834 wxDisplay *result;
30835 PyObject * obj0 = 0 ;
30836 char *kwnames[] = {
30837 (char *) "index", NULL
30838 };
30839
30840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30841 if (obj0) {
30842 {
30843 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30844 if (SWIG_arg_fail(1)) SWIG_fail;
30845 }
30846 }
30847 {
30848 PyThreadState* __tstate = wxPyBeginAllowThreads();
30849 result = (wxDisplay *)new wxDisplay(arg1);
30850
30851 wxPyEndAllowThreads(__tstate);
30852 if (PyErr_Occurred()) SWIG_fail;
30853 }
30854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30855 return resultobj;
30856 fail:
30857 return NULL;
30858 }
30859
30860
30861 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30862 PyObject *resultobj;
30863 wxDisplay *arg1 = (wxDisplay *) 0 ;
30864 PyObject * obj0 = 0 ;
30865 char *kwnames[] = {
30866 (char *) "self", NULL
30867 };
30868
30869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30871 if (SWIG_arg_fail(1)) SWIG_fail;
30872 {
30873 PyThreadState* __tstate = wxPyBeginAllowThreads();
30874 delete arg1;
30875
30876 wxPyEndAllowThreads(__tstate);
30877 if (PyErr_Occurred()) SWIG_fail;
30878 }
30879 Py_INCREF(Py_None); resultobj = Py_None;
30880 return resultobj;
30881 fail:
30882 return NULL;
30883 }
30884
30885
30886 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30887 PyObject *resultobj;
30888 size_t result;
30889 char *kwnames[] = {
30890 NULL
30891 };
30892
30893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30894 {
30895 PyThreadState* __tstate = wxPyBeginAllowThreads();
30896 result = (size_t)wxDisplay::GetCount();
30897
30898 wxPyEndAllowThreads(__tstate);
30899 if (PyErr_Occurred()) SWIG_fail;
30900 }
30901 {
30902 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30903 }
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30911 PyObject *resultobj;
30912 wxPoint *arg1 = 0 ;
30913 int result;
30914 wxPoint temp1 ;
30915 PyObject * obj0 = 0 ;
30916 char *kwnames[] = {
30917 (char *) "pt", NULL
30918 };
30919
30920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30921 {
30922 arg1 = &temp1;
30923 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30924 }
30925 {
30926 PyThreadState* __tstate = wxPyBeginAllowThreads();
30927 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30928
30929 wxPyEndAllowThreads(__tstate);
30930 if (PyErr_Occurred()) SWIG_fail;
30931 }
30932 {
30933 resultobj = SWIG_From_int((int)(result));
30934 }
30935 return resultobj;
30936 fail:
30937 return NULL;
30938 }
30939
30940
30941 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30942 PyObject *resultobj;
30943 wxWindow *arg1 = (wxWindow *) 0 ;
30944 int result;
30945 PyObject * obj0 = 0 ;
30946 char *kwnames[] = {
30947 (char *) "window", NULL
30948 };
30949
30950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30952 if (SWIG_arg_fail(1)) SWIG_fail;
30953 {
30954 PyThreadState* __tstate = wxPyBeginAllowThreads();
30955 result = (int)Display_GetFromWindow(arg1);
30956
30957 wxPyEndAllowThreads(__tstate);
30958 if (PyErr_Occurred()) SWIG_fail;
30959 }
30960 {
30961 resultobj = SWIG_From_int((int)(result));
30962 }
30963 return resultobj;
30964 fail:
30965 return NULL;
30966 }
30967
30968
30969 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30970 PyObject *resultobj;
30971 wxDisplay *arg1 = (wxDisplay *) 0 ;
30972 bool result;
30973 PyObject * obj0 = 0 ;
30974 char *kwnames[] = {
30975 (char *) "self", NULL
30976 };
30977
30978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30980 if (SWIG_arg_fail(1)) SWIG_fail;
30981 {
30982 PyThreadState* __tstate = wxPyBeginAllowThreads();
30983 result = (bool)((wxDisplay const *)arg1)->IsOk();
30984
30985 wxPyEndAllowThreads(__tstate);
30986 if (PyErr_Occurred()) SWIG_fail;
30987 }
30988 {
30989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30990 }
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30998 PyObject *resultobj;
30999 wxDisplay *arg1 = (wxDisplay *) 0 ;
31000 wxRect result;
31001 PyObject * obj0 = 0 ;
31002 char *kwnames[] = {
31003 (char *) "self", NULL
31004 };
31005
31006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
31007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31008 if (SWIG_arg_fail(1)) SWIG_fail;
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 result = ((wxDisplay const *)arg1)->GetGeometry();
31012
31013 wxPyEndAllowThreads(__tstate);
31014 if (PyErr_Occurred()) SWIG_fail;
31015 }
31016 {
31017 wxRect * resultptr;
31018 resultptr = new wxRect((wxRect &)(result));
31019 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
31020 }
31021 return resultobj;
31022 fail:
31023 return NULL;
31024 }
31025
31026
31027 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
31028 PyObject *resultobj;
31029 wxDisplay *arg1 = (wxDisplay *) 0 ;
31030 wxString result;
31031 PyObject * obj0 = 0 ;
31032 char *kwnames[] = {
31033 (char *) "self", NULL
31034 };
31035
31036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31038 if (SWIG_arg_fail(1)) SWIG_fail;
31039 {
31040 PyThreadState* __tstate = wxPyBeginAllowThreads();
31041 result = ((wxDisplay const *)arg1)->GetName();
31042
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 {
31047 #if wxUSE_UNICODE
31048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31049 #else
31050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31051 #endif
31052 }
31053 return resultobj;
31054 fail:
31055 return NULL;
31056 }
31057
31058
31059 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31060 PyObject *resultobj;
31061 wxDisplay *arg1 = (wxDisplay *) 0 ;
31062 bool result;
31063 PyObject * obj0 = 0 ;
31064 char *kwnames[] = {
31065 (char *) "self", NULL
31066 };
31067
31068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31070 if (SWIG_arg_fail(1)) SWIG_fail;
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31074
31075 wxPyEndAllowThreads(__tstate);
31076 if (PyErr_Occurred()) SWIG_fail;
31077 }
31078 {
31079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31080 }
31081 return resultobj;
31082 fail:
31083 return NULL;
31084 }
31085
31086
31087 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31088 PyObject *resultobj;
31089 wxDisplay *arg1 = (wxDisplay *) 0 ;
31090 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31091 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31092 PyObject *result;
31093 PyObject * obj0 = 0 ;
31094 PyObject * obj1 = 0 ;
31095 char *kwnames[] = {
31096 (char *) "self",(char *) "mode", NULL
31097 };
31098
31099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31101 if (SWIG_arg_fail(1)) SWIG_fail;
31102 if (obj1) {
31103 {
31104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31105 if (SWIG_arg_fail(2)) SWIG_fail;
31106 if (arg2 == NULL) {
31107 SWIG_null_ref("wxVideoMode");
31108 }
31109 if (SWIG_arg_fail(2)) SWIG_fail;
31110 }
31111 }
31112 {
31113 PyThreadState* __tstate = wxPyBeginAllowThreads();
31114 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31115
31116 wxPyEndAllowThreads(__tstate);
31117 if (PyErr_Occurred()) SWIG_fail;
31118 }
31119 resultobj = result;
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj;
31128 wxDisplay *arg1 = (wxDisplay *) 0 ;
31129 wxVideoMode result;
31130 PyObject * obj0 = 0 ;
31131 char *kwnames[] = {
31132 (char *) "self", NULL
31133 };
31134
31135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31137 if (SWIG_arg_fail(1)) SWIG_fail;
31138 {
31139 PyThreadState* __tstate = wxPyBeginAllowThreads();
31140 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31141
31142 wxPyEndAllowThreads(__tstate);
31143 if (PyErr_Occurred()) SWIG_fail;
31144 }
31145 {
31146 wxVideoMode * resultptr;
31147 resultptr = new wxVideoMode((wxVideoMode &)(result));
31148 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31149 }
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj;
31158 wxDisplay *arg1 = (wxDisplay *) 0 ;
31159 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31160 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31161 bool result;
31162 PyObject * obj0 = 0 ;
31163 PyObject * obj1 = 0 ;
31164 char *kwnames[] = {
31165 (char *) "self",(char *) "mode", NULL
31166 };
31167
31168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31170 if (SWIG_arg_fail(1)) SWIG_fail;
31171 if (obj1) {
31172 {
31173 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31174 if (SWIG_arg_fail(2)) SWIG_fail;
31175 if (arg2 == NULL) {
31176 SWIG_null_ref("wxVideoMode");
31177 }
31178 if (SWIG_arg_fail(2)) SWIG_fail;
31179 }
31180 }
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31184
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 {
31189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31190 }
31191 return resultobj;
31192 fail:
31193 return NULL;
31194 }
31195
31196
31197 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31198 PyObject *resultobj;
31199 wxDisplay *arg1 = (wxDisplay *) 0 ;
31200 PyObject * obj0 = 0 ;
31201 char *kwnames[] = {
31202 (char *) "self", NULL
31203 };
31204
31205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31207 if (SWIG_arg_fail(1)) SWIG_fail;
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 (arg1)->ResetMode();
31211
31212 wxPyEndAllowThreads(__tstate);
31213 if (PyErr_Occurred()) SWIG_fail;
31214 }
31215 Py_INCREF(Py_None); resultobj = Py_None;
31216 return resultobj;
31217 fail:
31218 return NULL;
31219 }
31220
31221
31222 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31223 PyObject *obj;
31224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31225 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31226 Py_INCREF(obj);
31227 return Py_BuildValue((char *)"");
31228 }
31229 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31230 PyObject *resultobj;
31231 wxStandardPaths *result;
31232 char *kwnames[] = {
31233 NULL
31234 };
31235
31236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 result = (wxStandardPaths *)StandardPaths_Get();
31240
31241 wxPyEndAllowThreads(__tstate);
31242 if (PyErr_Occurred()) SWIG_fail;
31243 }
31244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31245 return resultobj;
31246 fail:
31247 return NULL;
31248 }
31249
31250
31251 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31252 PyObject *resultobj;
31253 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31254 wxString result;
31255 PyObject * obj0 = 0 ;
31256 char *kwnames[] = {
31257 (char *) "self", NULL
31258 };
31259
31260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31262 if (SWIG_arg_fail(1)) SWIG_fail;
31263 {
31264 PyThreadState* __tstate = wxPyBeginAllowThreads();
31265 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31266
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 {
31271 #if wxUSE_UNICODE
31272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31273 #else
31274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31275 #endif
31276 }
31277 return resultobj;
31278 fail:
31279 return NULL;
31280 }
31281
31282
31283 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31284 PyObject *resultobj;
31285 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31286 wxString result;
31287 PyObject * obj0 = 0 ;
31288 char *kwnames[] = {
31289 (char *) "self", NULL
31290 };
31291
31292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31294 if (SWIG_arg_fail(1)) SWIG_fail;
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31298
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 {
31303 #if wxUSE_UNICODE
31304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31305 #else
31306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31307 #endif
31308 }
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31316 PyObject *resultobj;
31317 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31318 wxString result;
31319 PyObject * obj0 = 0 ;
31320 char *kwnames[] = {
31321 (char *) "self", NULL
31322 };
31323
31324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31326 if (SWIG_arg_fail(1)) SWIG_fail;
31327 {
31328 PyThreadState* __tstate = wxPyBeginAllowThreads();
31329 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31330
31331 wxPyEndAllowThreads(__tstate);
31332 if (PyErr_Occurred()) SWIG_fail;
31333 }
31334 {
31335 #if wxUSE_UNICODE
31336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31337 #else
31338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31339 #endif
31340 }
31341 return resultobj;
31342 fail:
31343 return NULL;
31344 }
31345
31346
31347 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31348 PyObject *resultobj;
31349 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31350 wxString result;
31351 PyObject * obj0 = 0 ;
31352 char *kwnames[] = {
31353 (char *) "self", NULL
31354 };
31355
31356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31358 if (SWIG_arg_fail(1)) SWIG_fail;
31359 {
31360 PyThreadState* __tstate = wxPyBeginAllowThreads();
31361 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31362
31363 wxPyEndAllowThreads(__tstate);
31364 if (PyErr_Occurred()) SWIG_fail;
31365 }
31366 {
31367 #if wxUSE_UNICODE
31368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31369 #else
31370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31371 #endif
31372 }
31373 return resultobj;
31374 fail:
31375 return NULL;
31376 }
31377
31378
31379 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31380 PyObject *resultobj;
31381 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31382 wxString result;
31383 PyObject * obj0 = 0 ;
31384 char *kwnames[] = {
31385 (char *) "self", NULL
31386 };
31387
31388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31390 if (SWIG_arg_fail(1)) SWIG_fail;
31391 {
31392 PyThreadState* __tstate = wxPyBeginAllowThreads();
31393 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31394
31395 wxPyEndAllowThreads(__tstate);
31396 if (PyErr_Occurred()) SWIG_fail;
31397 }
31398 {
31399 #if wxUSE_UNICODE
31400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31401 #else
31402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31403 #endif
31404 }
31405 return resultobj;
31406 fail:
31407 return NULL;
31408 }
31409
31410
31411 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31412 PyObject *resultobj;
31413 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31414 wxString result;
31415 PyObject * obj0 = 0 ;
31416 char *kwnames[] = {
31417 (char *) "self", NULL
31418 };
31419
31420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31422 if (SWIG_arg_fail(1)) SWIG_fail;
31423 {
31424 PyThreadState* __tstate = wxPyBeginAllowThreads();
31425 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31426
31427 wxPyEndAllowThreads(__tstate);
31428 if (PyErr_Occurred()) SWIG_fail;
31429 }
31430 {
31431 #if wxUSE_UNICODE
31432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31433 #else
31434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31435 #endif
31436 }
31437 return resultobj;
31438 fail:
31439 return NULL;
31440 }
31441
31442
31443 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31444 PyObject *resultobj;
31445 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31446 wxString result;
31447 PyObject * obj0 = 0 ;
31448 char *kwnames[] = {
31449 (char *) "self", NULL
31450 };
31451
31452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31454 if (SWIG_arg_fail(1)) SWIG_fail;
31455 {
31456 PyThreadState* __tstate = wxPyBeginAllowThreads();
31457 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31458
31459 wxPyEndAllowThreads(__tstate);
31460 if (PyErr_Occurred()) SWIG_fail;
31461 }
31462 {
31463 #if wxUSE_UNICODE
31464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31465 #else
31466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31467 #endif
31468 }
31469 return resultobj;
31470 fail:
31471 return NULL;
31472 }
31473
31474
31475 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31476 PyObject *resultobj;
31477 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31478 wxString *arg2 = 0 ;
31479 bool temp2 = false ;
31480 PyObject * obj0 = 0 ;
31481 PyObject * obj1 = 0 ;
31482 char *kwnames[] = {
31483 (char *) "self",(char *) "prefix", NULL
31484 };
31485
31486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31488 if (SWIG_arg_fail(1)) SWIG_fail;
31489 {
31490 arg2 = wxString_in_helper(obj1);
31491 if (arg2 == NULL) SWIG_fail;
31492 temp2 = true;
31493 }
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31497
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 Py_INCREF(Py_None); resultobj = Py_None;
31502 {
31503 if (temp2)
31504 delete arg2;
31505 }
31506 return resultobj;
31507 fail:
31508 {
31509 if (temp2)
31510 delete arg2;
31511 }
31512 return NULL;
31513 }
31514
31515
31516 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31517 PyObject *resultobj;
31518 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31519 wxString result;
31520 PyObject * obj0 = 0 ;
31521 char *kwnames[] = {
31522 (char *) "self", NULL
31523 };
31524
31525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31527 if (SWIG_arg_fail(1)) SWIG_fail;
31528 {
31529 PyThreadState* __tstate = wxPyBeginAllowThreads();
31530 result = wxStandardPaths_GetInstallPrefix(arg1);
31531
31532 wxPyEndAllowThreads(__tstate);
31533 if (PyErr_Occurred()) SWIG_fail;
31534 }
31535 {
31536 #if wxUSE_UNICODE
31537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31538 #else
31539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31540 #endif
31541 }
31542 return resultobj;
31543 fail:
31544 return NULL;
31545 }
31546
31547
31548 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31549 PyObject *obj;
31550 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31551 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31552 Py_INCREF(obj);
31553 return Py_BuildValue((char *)"");
31554 }
31555 static PyMethodDef SwigMethods[] = {
31556 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31563 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31571 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31637 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31645 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31663 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31666 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31669 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31672 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31678 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31692 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31698 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31704 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31707 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31721 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31724 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31725 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31728 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31755 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31757 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31759 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31761 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31768 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31774 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31788 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31792 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31795 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31812 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31820 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31867 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31885 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31895 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31911 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31927 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31941 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31951 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31994 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31997 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
32000 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
32004 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32097 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32098 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32099 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32100 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32117 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32162 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32196 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32204 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32205 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32210 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32219 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32226 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32229 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32232 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32237 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32240 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32244 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32247 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32251 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32252 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32256 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32260 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32264 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32274 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32287 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32295 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32303 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32311 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32317 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32319 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32320 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32321 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32325 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32330 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32333 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32334 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32335 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32336 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32337 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32338 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32339 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32340 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32341 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32342 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32343 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32344 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32345 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32346 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32347 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32348 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32349 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32350 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32351 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32352 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32353 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32354 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32355 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32356 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32357 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32358 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32359 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32360 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32361 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32362 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32363 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32364 { NULL, NULL, 0, NULL }
32365 };
32366
32367
32368 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32369
32370 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32371 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32372 }
32373 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32374 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32375 }
32376 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32377 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32378 }
32379 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32380 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32381 }
32382 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32383 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32384 }
32385 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32386 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32387 }
32388 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32389 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32390 }
32391 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32392 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32393 }
32394 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32395 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32396 }
32397 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32398 return (void *)((wxEvent *) ((wxPyEvent *) x));
32399 }
32400 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32401 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32402 }
32403 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32404 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32405 }
32406 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32407 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32408 }
32409 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32410 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32411 }
32412 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32413 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32414 }
32415 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32416 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32417 }
32418 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32419 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32420 }
32421 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32422 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32423 }
32424 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32425 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32426 }
32427 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32428 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32429 }
32430 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32431 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32432 }
32433 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32434 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32435 }
32436 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32437 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32438 }
32439 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32440 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32441 }
32442 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32443 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32444 }
32445 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32446 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32447 }
32448 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32449 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32450 }
32451 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32452 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32453 }
32454 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32455 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32456 }
32457 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32458 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32459 }
32460 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32461 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32462 }
32463 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32464 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32465 }
32466 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32467 return (void *)((wxEvent *) ((wxShowEvent *) x));
32468 }
32469 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32470 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32471 }
32472 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32473 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32474 }
32475 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32476 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32477 }
32478 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32479 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32480 }
32481 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32482 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32483 }
32484 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32485 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32486 }
32487 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32488 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32489 }
32490 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32491 return (void *)((wxConfigBase *) ((wxConfig *) x));
32492 }
32493 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32494 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32495 }
32496 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32497 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32498 }
32499 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32500 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32501 }
32502 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32503 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32504 }
32505 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32506 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32507 }
32508 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32509 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32510 }
32511 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32512 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32513 }
32514 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32515 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32516 }
32517 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32518 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32519 }
32520 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32521 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32522 }
32523 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32524 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32525 }
32526 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32527 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32528 }
32529 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32530 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32531 }
32532 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32533 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32534 }
32535 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32536 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32537 }
32538 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32539 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32540 }
32541 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32542 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32543 }
32544 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32545 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32546 }
32547 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32548 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32549 }
32550 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32551 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32552 }
32553 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32554 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32555 }
32556 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32557 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32558 }
32559 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32560 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32561 }
32562 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32563 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32564 }
32565 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32566 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32567 }
32568 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32569 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32570 }
32571 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32572 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32573 }
32574 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32575 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32576 }
32577 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32578 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32579 }
32580 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32581 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32582 }
32583 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32584 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32585 }
32586 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32587 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32588 }
32589 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32590 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32591 }
32592 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32593 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32594 }
32595 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32596 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32597 }
32598 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32599 return (void *)((wxObject *) ((wxSizerItem *) x));
32600 }
32601 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32602 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32603 }
32604 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32605 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32606 }
32607 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32608 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32609 }
32610 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32611 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32612 }
32613 static void *_p_wxSizerTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) ((wxSizer *) x));
32615 }
32616 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32617 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32618 }
32619 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32620 return (void *)((wxObject *) ((wxFileHistory *) x));
32621 }
32622 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32623 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32624 }
32625 static void *_p_wxEventTo_p_wxObject(void *x) {
32626 return (void *)((wxObject *) ((wxEvent *) x));
32627 }
32628 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32629 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32630 }
32631 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32632 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32633 }
32634 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32635 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32636 }
32637 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32638 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32639 }
32640 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32641 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32642 }
32643 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32644 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32645 }
32646 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32647 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32648 }
32649 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32650 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32651 }
32652 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32653 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32654 }
32655 static void *_p_wxControlTo_p_wxObject(void *x) {
32656 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32657 }
32658 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32659 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32660 }
32661 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32662 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32663 }
32664 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32665 return (void *)((wxObject *) ((wxFSFile *) x));
32666 }
32667 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32668 return (void *)((wxObject *) ((wxClipboard *) x));
32669 }
32670 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32671 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32672 }
32673 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32674 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32675 }
32676 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32677 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32678 }
32679 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32680 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32681 }
32682 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32683 return (void *)((wxObject *) ((wxToolTip *) x));
32684 }
32685 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32686 return (void *)((wxObject *) ((wxMenuItem *) x));
32687 }
32688 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32689 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32690 }
32691 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32692 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32693 }
32694 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32695 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32696 }
32697 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32698 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32699 }
32700 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32701 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32702 }
32703 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32704 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32705 }
32706 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32707 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32708 }
32709 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32710 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32711 }
32712 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32713 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32714 }
32715 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32716 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32717 }
32718 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32719 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32720 }
32721 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32722 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32723 }
32724 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32725 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32726 }
32727 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32728 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32729 }
32730 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32731 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32732 }
32733 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32734 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32735 }
32736 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32737 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32738 }
32739 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32740 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32741 }
32742 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32743 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32744 }
32745 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32746 return (void *)((wxObject *) ((wxImageHandler *) x));
32747 }
32748 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32749 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32750 }
32751 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32752 return (void *)((wxObject *) ((wxEvtHandler *) x));
32753 }
32754 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32755 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32756 }
32757 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32758 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32759 }
32760 static void *_p_wxImageTo_p_wxObject(void *x) {
32761 return (void *)((wxObject *) ((wxImage *) x));
32762 }
32763 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32764 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32765 }
32766 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32767 return (void *)((wxObject *) ((wxSystemOptions *) x));
32768 }
32769 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32770 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32771 }
32772 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32773 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32774 }
32775 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32776 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32777 }
32778 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32779 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32780 }
32781 static void *_p_wxWindowTo_p_wxObject(void *x) {
32782 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32783 }
32784 static void *_p_wxMenuTo_p_wxObject(void *x) {
32785 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32786 }
32787 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32788 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32789 }
32790 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32791 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32792 }
32793 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32794 return (void *)((wxObject *) ((wxFileSystem *) x));
32795 }
32796 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32797 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32798 }
32799 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32800 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32801 }
32802 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32803 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32804 }
32805 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32806 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32807 }
32808 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32809 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32810 }
32811 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32812 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32813 }
32814 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32815 return (void *)((wxObject *) ((wxBusyInfo *) x));
32816 }
32817 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32818 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32819 }
32820 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32821 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32822 }
32823 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32824 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32825 }
32826 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32827 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32828 }
32829 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32830 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32831 }
32832 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32833 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32834 }
32835 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32836 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32837 }
32838 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32839 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32840 }
32841 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32842 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32843 }
32844 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32845 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32846 }
32847 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32848 return (void *)((wxLog *) ((wxLogStderr *) x));
32849 }
32850 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32851 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32852 }
32853 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32854 return (void *)((wxLog *) ((wxLogWindow *) x));
32855 }
32856 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32857 return (void *)((wxLog *) ((wxLogChain *) x));
32858 }
32859 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32860 return (void *)((wxLog *) ((wxLogGui *) x));
32861 }
32862 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32863 return (void *)((wxLog *) ((wxPyLog *) x));
32864 }
32865 static void *_p_wxControlTo_p_wxWindow(void *x) {
32866 return (void *)((wxWindow *) ((wxControl *) x));
32867 }
32868 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32869 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32870 }
32871 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32872 return (void *)((wxWindow *) ((wxMenuBar *) x));
32873 }
32874 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32875 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32876 }
32877 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32878 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32879 }
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 static swig_type_info _swigt__p_wxLog[] = {{"_p_wxLog", 0, "wxLog *", 0, 0, 0, 0},{"_p_wxLogStderr", _p_wxLogStderrTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogTextCtrl", _p_wxLogTextCtrlTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogWindow", _p_wxLogWindowTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogChain", _p_wxLogChainTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogGui", _p_wxLogGuiTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxPyLog", _p_wxPyLogTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918 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}};
32919 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}};
32920 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}};
32921 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}};
32922 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}};
32923 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}};
32924 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}};
32925 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}};
32926 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}};
32927 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}};
32928 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}};
32929 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}};
32930 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}};
32931 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}};
32932 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}};
32933 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}};
32934 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}};
32935 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}};
32936 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}};
32937 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}};
32938 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}};
32939 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}};
32940 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}};
32941 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}};
32942 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}};
32943 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}};
32944 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}};
32945 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}};
32946 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}};
32947 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}};
32948 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}};
32949 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}};
32950 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}};
32951 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}};
32952 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}};
32953 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}};
32954 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}};
32955 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}};
32956 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}};
32957 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}};
32958 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}};
32959 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}};
32960 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}};
32961 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}};
32962 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}};
32963 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}};
32964 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}};
32965 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}};
32966 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}};
32967 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}};
32968 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}};
32969 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}};
32970 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}};
32971 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}};
32972 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}};
32973 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}};
32974 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}};
32975 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}};
32976 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}};
32977 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}};
32978
32979 static swig_type_info *swig_types_initial[] = {
32980 _swigt__p_wxLogChain,
32981 _swigt__p_wxMutexGuiLocker,
32982 _swigt__p_wxMetafile,
32983 _swigt__p_wxFileHistory,
32984 _swigt__p_wxLog,
32985 _swigt__p_wxMenu,
32986 _swigt__p_wxEvent,
32987 _swigt__p_wxDateTime__TimeZone,
32988 _swigt__p_wxConfigBase,
32989 _swigt__p_wxDisplay,
32990 _swigt__p_wxFileType,
32991 _swigt__p_wxLogGui,
32992 _swigt__p_wxFont,
32993 _swigt__p_wxDataFormat,
32994 _swigt__p_wxTimerEvent,
32995 _swigt__p_wxCaret,
32996 _swigt__ptrdiff_t,
32997 _swigt__std__ptrdiff_t,
32998 _swigt__p_void,
32999 _swigt__p_int,
33000 _swigt__p_wxSize,
33001 _swigt__p_wxClipboard,
33002 _swigt__p_wxStopWatch,
33003 _swigt__p_wxDC,
33004 _swigt__p_wxClipboardLocker,
33005 _swigt__p_wxIcon,
33006 _swigt__p_wxLogStderr,
33007 _swigt__p_wxLogTextCtrl,
33008 _swigt__p_wxTextCtrl,
33009 _swigt__p_wxBusyCursor,
33010 _swigt__p_wxBitmapDataObject,
33011 _swigt__p_wxTextDataObject,
33012 _swigt__p_wxDataObject,
33013 _swigt__p_wxPyTextDataObject,
33014 _swigt__p_wxPyBitmapDataObject,
33015 _swigt__p_wxFileDataObject,
33016 _swigt__p_wxCustomDataObject,
33017 _swigt__p_wxURLDataObject,
33018 _swigt__p_wxMetafileDataObject,
33019 _swigt__p_wxSound,
33020 _swigt__p_wxTimerRunner,
33021 _swigt__p_wxLogWindow,
33022 _swigt__p_wxTimeSpan,
33023 _swigt__p_wxArrayString,
33024 _swigt__p_wxWindowDisabler,
33025 _swigt__p_form_ops_t,
33026 _swigt__p_wxToolTip,
33027 _swigt__p_wxDataObjectComposite,
33028 _swigt__p_wxSystemSettings,
33029 _swigt__p_wxFileConfig,
33030 _swigt__p_wxVideoMode,
33031 _swigt__p_wxDataObjectSimple,
33032 _swigt__p_wxPyDataObjectSimple,
33033 _swigt__p_wxDuplexMode,
33034 _swigt__p_wxEvtHandler,
33035 _swigt__p_wxRect,
33036 _swigt__p_char,
33037 _swigt__p_wxSingleInstanceChecker,
33038 _swigt__p_wxStandardPaths,
33039 _swigt__p_wxFileTypeInfo,
33040 _swigt__p_wxFrame,
33041 _swigt__p_wxTimer,
33042 _swigt__p_wxPaperSize,
33043 _swigt__p_wxMimeTypesManager,
33044 _swigt__p_wxPyArtProvider,
33045 _swigt__p_wxPyTipProvider,
33046 _swigt__p_wxTipProvider,
33047 _swigt__p_wxJoystick,
33048 _swigt__p_wxSystemOptions,
33049 _swigt__p_wxPoint,
33050 _swigt__p_wxJoystickEvent,
33051 _swigt__p_wxCursor,
33052 _swigt__p_wxObject,
33053 _swigt__p_wxOutputStream,
33054 _swigt__p_wxDateTime,
33055 _swigt__p_wxPyDropSource,
33056 _swigt__p_unsigned_long,
33057 _swigt__p_wxKillError,
33058 _swigt__p_wxWindow,
33059 _swigt__p_wxString,
33060 _swigt__p_wxPyProcess,
33061 _swigt__p_wxBitmap,
33062 _swigt__unsigned_int,
33063 _swigt__p_unsigned_int,
33064 _swigt__p_wxConfig,
33065 _swigt__p_unsigned_char,
33066 _swigt__p_wxChar,
33067 _swigt__p_wxBusyInfo,
33068 _swigt__p_wxPyDropTarget,
33069 _swigt__p_wxPyTextDropTarget,
33070 _swigt__p_wxPyFileDropTarget,
33071 _swigt__p_wxProcessEvent,
33072 _swigt__p_wxPyLog,
33073 _swigt__p_wxLogNull,
33074 _swigt__p_wxColour,
33075 _swigt__p_wxPyTimer,
33076 _swigt__p_wxConfigPathChanger,
33077 _swigt__p_wxDateSpan,
33078 0
33079 };
33080
33081
33082 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33083
33084 static swig_const_info swig_const_table[] = {
33085 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33086 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33087 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33088 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33089 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33090 {0, 0, 0, 0.0, 0, 0}};
33091
33092 #ifdef __cplusplus
33093 }
33094 #endif
33095
33096
33097 #ifdef __cplusplus
33098 extern "C" {
33099 #endif
33100
33101 /* Python-specific SWIG API */
33102 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33103 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33104 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33105
33106 /* -----------------------------------------------------------------------------
33107 * global variable support code.
33108 * ----------------------------------------------------------------------------- */
33109
33110 typedef struct swig_globalvar {
33111 char *name; /* Name of global variable */
33112 PyObject *(*get_attr)(); /* Return the current value */
33113 int (*set_attr)(PyObject *); /* Set the value */
33114 struct swig_globalvar *next;
33115 } swig_globalvar;
33116
33117 typedef struct swig_varlinkobject {
33118 PyObject_HEAD
33119 swig_globalvar *vars;
33120 } swig_varlinkobject;
33121
33122 static PyObject *
33123 swig_varlink_repr(swig_varlinkobject *v) {
33124 v = v;
33125 return PyString_FromString("<Swig global variables>");
33126 }
33127
33128 static int
33129 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33130 swig_globalvar *var;
33131 flags = flags;
33132 fprintf(fp,"Swig global variables { ");
33133 for (var = v->vars; var; var=var->next) {
33134 fprintf(fp,"%s", var->name);
33135 if (var->next) fprintf(fp,", ");
33136 }
33137 fprintf(fp," }\n");
33138 return 0;
33139 }
33140
33141 static PyObject *
33142 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33143 swig_globalvar *var = v->vars;
33144 while (var) {
33145 if (strcmp(var->name,n) == 0) {
33146 return (*var->get_attr)();
33147 }
33148 var = var->next;
33149 }
33150 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33151 return NULL;
33152 }
33153
33154 static int
33155 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33156 swig_globalvar *var = v->vars;
33157 while (var) {
33158 if (strcmp(var->name,n) == 0) {
33159 return (*var->set_attr)(p);
33160 }
33161 var = var->next;
33162 }
33163 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33164 return 1;
33165 }
33166
33167 static PyTypeObject varlinktype = {
33168 PyObject_HEAD_INIT(0)
33169 0, /* Number of items in variable part (ob_size) */
33170 (char *)"swigvarlink", /* Type name (tp_name) */
33171 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33172 0, /* Itemsize (tp_itemsize) */
33173 0, /* Deallocator (tp_dealloc) */
33174 (printfunc) swig_varlink_print, /* Print (tp_print) */
33175 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33176 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33177 0, /* tp_compare */
33178 (reprfunc) swig_varlink_repr, /* tp_repr */
33179 0, /* tp_as_number */
33180 0, /* tp_as_sequence */
33181 0, /* tp_as_mapping */
33182 0, /* tp_hash */
33183 0, /* tp_call */
33184 0, /* tp_str */
33185 0, /* tp_getattro */
33186 0, /* tp_setattro */
33187 0, /* tp_as_buffer */
33188 0, /* tp_flags */
33189 0, /* tp_doc */
33190 #if PY_VERSION_HEX >= 0x02000000
33191 0, /* tp_traverse */
33192 0, /* tp_clear */
33193 #endif
33194 #if PY_VERSION_HEX >= 0x02010000
33195 0, /* tp_richcompare */
33196 0, /* tp_weaklistoffset */
33197 #endif
33198 #if PY_VERSION_HEX >= 0x02020000
33199 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33200 #endif
33201 #if PY_VERSION_HEX >= 0x02030000
33202 0, /* tp_del */
33203 #endif
33204 #ifdef COUNT_ALLOCS
33205 0,0,0,0 /* tp_alloc -> tp_next */
33206 #endif
33207 };
33208
33209 /* Create a variable linking object for use later */
33210 static PyObject *
33211 SWIG_Python_newvarlink(void) {
33212 swig_varlinkobject *result = 0;
33213 result = PyMem_NEW(swig_varlinkobject,1);
33214 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33215 result->ob_type = &varlinktype;
33216 result->vars = 0;
33217 result->ob_refcnt = 0;
33218 Py_XINCREF((PyObject *) result);
33219 return ((PyObject*) result);
33220 }
33221
33222 static void
33223 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33224 swig_varlinkobject *v;
33225 swig_globalvar *gv;
33226 v= (swig_varlinkobject *) p;
33227 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33228 gv->name = (char *) malloc(strlen(name)+1);
33229 strcpy(gv->name,name);
33230 gv->get_attr = get_attr;
33231 gv->set_attr = set_attr;
33232 gv->next = v->vars;
33233 v->vars = gv;
33234 }
33235
33236 /* -----------------------------------------------------------------------------
33237 * constants/methods manipulation
33238 * ----------------------------------------------------------------------------- */
33239
33240 /* Install Constants */
33241 static void
33242 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33243 PyObject *obj = 0;
33244 size_t i;
33245 for (i = 0; constants[i].type; i++) {
33246 switch(constants[i].type) {
33247 case SWIG_PY_INT:
33248 obj = PyInt_FromLong(constants[i].lvalue);
33249 break;
33250 case SWIG_PY_FLOAT:
33251 obj = PyFloat_FromDouble(constants[i].dvalue);
33252 break;
33253 case SWIG_PY_STRING:
33254 if (constants[i].pvalue) {
33255 obj = PyString_FromString((char *) constants[i].pvalue);
33256 } else {
33257 Py_INCREF(Py_None);
33258 obj = Py_None;
33259 }
33260 break;
33261 case SWIG_PY_POINTER:
33262 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33263 break;
33264 case SWIG_PY_BINARY:
33265 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33266 break;
33267 default:
33268 obj = 0;
33269 break;
33270 }
33271 if (obj) {
33272 PyDict_SetItemString(d,constants[i].name,obj);
33273 Py_DECREF(obj);
33274 }
33275 }
33276 }
33277
33278 /* -----------------------------------------------------------------------------*/
33279 /* Fix SwigMethods to carry the callback ptrs when needed */
33280 /* -----------------------------------------------------------------------------*/
33281
33282 static void
33283 SWIG_Python_FixMethods(PyMethodDef *methods,
33284 swig_const_info *const_table,
33285 swig_type_info **types,
33286 swig_type_info **types_initial) {
33287 size_t i;
33288 for (i = 0; methods[i].ml_name; ++i) {
33289 char *c = methods[i].ml_doc;
33290 if (c && (c = strstr(c, "swig_ptr: "))) {
33291 int j;
33292 swig_const_info *ci = 0;
33293 char *name = c + 10;
33294 for (j = 0; const_table[j].type; j++) {
33295 if (strncmp(const_table[j].name, name,
33296 strlen(const_table[j].name)) == 0) {
33297 ci = &(const_table[j]);
33298 break;
33299 }
33300 }
33301 if (ci) {
33302 size_t shift = (ci->ptype) - types;
33303 swig_type_info *ty = types_initial[shift];
33304 size_t ldoc = (c - methods[i].ml_doc);
33305 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33306 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33307 char *buff = ndoc;
33308 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33309 strncpy(buff, methods[i].ml_doc, ldoc);
33310 buff += ldoc;
33311 strncpy(buff, "swig_ptr: ", 10);
33312 buff += 10;
33313 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33314 methods[i].ml_doc = ndoc;
33315 }
33316 }
33317 }
33318 }
33319
33320 /* -----------------------------------------------------------------------------*
33321 * Initialize type list
33322 * -----------------------------------------------------------------------------*/
33323
33324 #if PY_MAJOR_VERSION < 2
33325 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33326 is copied out of Python/modsupport.c in python version 2.3.4 */
33327 static int
33328 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33329 {
33330 PyObject *dict;
33331 if (!PyModule_Check(m)) {
33332 PyErr_SetString(PyExc_TypeError,
33333 "PyModule_AddObject() needs module as first arg");
33334 return -1;
33335 }
33336 if (!o) {
33337 PyErr_SetString(PyExc_TypeError,
33338 "PyModule_AddObject() needs non-NULL value");
33339 return -1;
33340 }
33341
33342 dict = PyModule_GetDict(m);
33343 if (dict == NULL) {
33344 /* Internal error -- modules must have a dict! */
33345 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33346 PyModule_GetName(m));
33347 return -1;
33348 }
33349 if (PyDict_SetItemString(dict, name, o))
33350 return -1;
33351 Py_DECREF(o);
33352 return 0;
33353 }
33354 #endif
33355
33356 static swig_type_info **
33357 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33358 static PyMethodDef swig_empty_runtime_method_table[] = {
33359 {
33360 NULL, NULL, 0, NULL
33361 }
33362 };/* Sentinel */
33363
33364 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33365 swig_empty_runtime_method_table);
33366 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33367 if (pointer && module) {
33368 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33369 }
33370 return type_list_handle;
33371 }
33372
33373 static swig_type_info **
33374 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33375 swig_type_info **type_pointer;
33376
33377 /* first check if module already created */
33378 type_pointer = SWIG_Python_GetTypeListHandle();
33379 if (type_pointer) {
33380 return type_pointer;
33381 } else {
33382 /* create a new module and variable */
33383 return SWIG_Python_SetTypeListHandle(type_list_handle);
33384 }
33385 }
33386
33387 #ifdef __cplusplus
33388 }
33389 #endif
33390
33391 /* -----------------------------------------------------------------------------*
33392 * Partial Init method
33393 * -----------------------------------------------------------------------------*/
33394
33395 #ifdef SWIG_LINK_RUNTIME
33396 #ifdef __cplusplus
33397 extern "C"
33398 #endif
33399 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33400 #endif
33401
33402 #ifdef __cplusplus
33403 extern "C"
33404 #endif
33405 SWIGEXPORT(void) SWIG_init(void) {
33406 static PyObject *SWIG_globals = 0;
33407 static int typeinit = 0;
33408 PyObject *m, *d;
33409 int i;
33410 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33411
33412 /* Fix SwigMethods to carry the callback ptrs when needed */
33413 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33414
33415 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33416 d = PyModule_GetDict(m);
33417
33418 if (!typeinit) {
33419 #ifdef SWIG_LINK_RUNTIME
33420 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33421 #else
33422 # ifndef SWIG_STATIC_RUNTIME
33423 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33424 # endif
33425 #endif
33426 for (i = 0; swig_types_initial[i]; i++) {
33427 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33428 }
33429 typeinit = 1;
33430 }
33431 SWIG_InstallConstants(d,swig_const_table);
33432
33433 {
33434 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33435 }
33436 {
33437 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33438 }
33439 {
33440 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33441 }
33442 {
33443 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33444 }
33445 {
33446 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33447 }
33448 {
33449 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33450 }
33451 {
33452 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33453 }
33454 {
33455 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33492 }
33493 {
33494 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33495 }
33496 {
33497 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33498 }
33499 {
33500 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33546 }
33547 {
33548 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33630 }
33631 {
33632 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33633 }
33634 {
33635 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33636 }
33637 {
33638 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33705 }
33706 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33707 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33708 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33709 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33710 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33711 {
33712 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33722 }
33723 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33724
33725 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33726
33727 {
33728 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33759 }
33760 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33761 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33762 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33763 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33764 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33765 {
33766 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33857 }
33858 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33859 {
33860 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33873 }
33874
33875 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33876
33877 {
33878 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33888 }
33889 {
33890 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33897 }
33898 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33899 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33900 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33901 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33902 {
33903 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33925 }
33926 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33927 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33928 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33929 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33930 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33931 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33932 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33933 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33934 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33935 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33936 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33937 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33938 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33939 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33940 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33941 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33942 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33943 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33944 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33945 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33946 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33947 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33948 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33949 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33950 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33951 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33952 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33953 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33954 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33955 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33956 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33957 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33958 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33959 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33960 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33961 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33962 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33963 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33964 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33965 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33966 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33967 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33968 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33969 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33970 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33971 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33972 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33973 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33974 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33975 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33976 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33977 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33978 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33979 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33980 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33981 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33982
33983 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33984
33985 {
33986 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
34011 }
34012 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
34013 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
34014 {
34015 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34403 }
34404 {
34405 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34406 }
34407 {
34408 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34409 }
34410 {
34411 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34412 }
34413 {
34414 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34415 }
34416 {
34417 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34418 }
34419 {
34420 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34460 }
34461 {
34462 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34463 }
34464 {
34465 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34466 }
34467 {
34468 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34469 }
34470 {
34471 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34472 }
34473 {
34474 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34475 }
34476 {
34477 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34478 }
34479 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34480 {
34481 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34482 }
34483 {
34484 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34485 }
34486 {
34487 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34488 }
34489 {
34490 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34491 }
34492 {
34493 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34494 }
34495 {
34496 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34497 }
34498 {
34499 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34500 }
34501 {
34502 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34503 }
34504 {
34505 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34506 }
34507 {
34508 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34509 }
34510 {
34511 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34512 }
34513 {
34514 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34515 }
34516 {
34517 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34518 }
34519 {
34520 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34521 }
34522 {
34523 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34524 }
34525 {
34526 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34527 }
34528 {
34529 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34530 }
34531 {
34532 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34533 }
34534 {
34535 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34536 }
34537 {
34538 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34539 }
34540 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34541 {
34542 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34543 }
34544 {
34545 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34546 }
34547 {
34548 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34549 }
34550 {
34551 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34552 }
34553 {
34554 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34555 }
34556 {
34557 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34558 }
34559 {
34560 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34561 }
34562 {
34563 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34564 }
34565 {
34566 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34567 }
34568 {
34569 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34570 }
34571 {
34572 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34573 }
34574 {
34575 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34576 }
34577
34578 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34579 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34580 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34581 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34582
34583 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34584 }
34585
wxWidgets (Impactor)