]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_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 / gtk / _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_wxFileHistory swig_types[2]
1345 #define SWIGTYPE_p_wxLog swig_types[3]
1346 #define SWIGTYPE_p_wxMenu swig_types[4]
1347 #define SWIGTYPE_p_wxEvent swig_types[5]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1350 #define SWIGTYPE_p_wxDisplay swig_types[8]
1351 #define SWIGTYPE_p_wxFileType swig_types[9]
1352 #define SWIGTYPE_p_wxLogGui swig_types[10]
1353 #define SWIGTYPE_p_wxFont swig_types[11]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1356 #define SWIGTYPE_p_wxCaret swig_types[14]
1357 #define SWIGTYPE_ptrdiff_t swig_types[15]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1359 #define SWIGTYPE_p_void swig_types[17]
1360 #define SWIGTYPE_p_int swig_types[18]
1361 #define SWIGTYPE_p_wxSize swig_types[19]
1362 #define SWIGTYPE_p_wxClipboard swig_types[20]
1363 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1364 #define SWIGTYPE_p_wxDC swig_types[22]
1365 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1366 #define SWIGTYPE_p_wxIcon swig_types[24]
1367 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1368 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1369 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1370 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1371 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1372 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxSound swig_types[38]
1381 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1382 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1383 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1384 #define SWIGTYPE_p_wxArrayString swig_types[42]
1385 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxToolTip swig_types[45]
1388 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1389 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1390 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1391 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1392 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1393 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1394 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1395 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1396 #define SWIGTYPE_p_wxRect swig_types[54]
1397 #define SWIGTYPE_p_char swig_types[55]
1398 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1399 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1400 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1401 #define SWIGTYPE_p_wxFrame swig_types[59]
1402 #define SWIGTYPE_p_wxTimer swig_types[60]
1403 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1404 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1405 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1406 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1407 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1408 #define SWIGTYPE_p_wxJoystick swig_types[66]
1409 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1410 #define SWIGTYPE_p_wxPoint swig_types[68]
1411 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1412 #define SWIGTYPE_p_wxCursor swig_types[70]
1413 #define SWIGTYPE_p_wxObject swig_types[71]
1414 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1415 #define SWIGTYPE_p_wxDateTime swig_types[73]
1416 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1417 #define SWIGTYPE_p_unsigned_long swig_types[75]
1418 #define SWIGTYPE_p_wxKillError swig_types[76]
1419 #define SWIGTYPE_p_wxWindow swig_types[77]
1420 #define SWIGTYPE_p_wxString swig_types[78]
1421 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1422 #define SWIGTYPE_p_wxBitmap swig_types[80]
1423 #define SWIGTYPE_unsigned_int swig_types[81]
1424 #define SWIGTYPE_p_unsigned_int swig_types[82]
1425 #define SWIGTYPE_p_wxConfig swig_types[83]
1426 #define SWIGTYPE_p_unsigned_char swig_types[84]
1427 #define SWIGTYPE_p_wxChar swig_types[85]
1428 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1429 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1430 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1431 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPyLog swig_types[91]
1434 #define SWIGTYPE_p_wxLogNull swig_types[92]
1435 #define SWIGTYPE_p_wxColour swig_types[93]
1436 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1437 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1438 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1439 static swig_type_info *swig_types[98];
1440
1441 /* -------- TYPES TABLE (END) -------- */
1442
1443
1444 /*-----------------------------------------------
1445 @(target):= _misc_.so
1446 ------------------------------------------------*/
1447 #define SWIG_init init_misc_
1448
1449 #define SWIG_name "_misc_"
1450
1451 #include "wx/wxPython/wxPython.h"
1452 #include "wx/wxPython/pyclasses.h"
1453 #include "wx/wxPython/pyistream.h"
1454
1455 static const wxString wxPyEmptyString(wxEmptyString);
1456
1457
1458
1459 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1460 #define SWIG_From_int PyInt_FromLong
1461 /*@@*/
1462
1463
1464 #include <limits.h>
1465
1466
1467 SWIGINTERN int
1468 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1469 const char *errmsg)
1470 {
1471 if (value < min_value) {
1472 if (errmsg) {
1473 PyErr_Format(PyExc_OverflowError,
1474 "value %ld is less than '%s' minimum %ld",
1475 value, errmsg, min_value);
1476 }
1477 return 0;
1478 } else if (value > max_value) {
1479 if (errmsg) {
1480 PyErr_Format(PyExc_OverflowError,
1481 "value %ld is greater than '%s' maximum %ld",
1482 value, errmsg, max_value);
1483 }
1484 return 0;
1485 }
1486 return 1;
1487 }
1488
1489
1490 SWIGINTERN int
1491 SWIG_AsVal_long(PyObject* obj, long* val)
1492 {
1493 if (PyNumber_Check(obj)) {
1494 if (val) *val = PyInt_AsLong(obj);
1495 return 1;
1496 }
1497 else {
1498 SWIG_type_error("number", obj);
1499 }
1500 return 0;
1501 }
1502
1503
1504 #if INT_MAX != LONG_MAX
1505 SWIGINTERN int
1506 SWIG_AsVal_int(PyObject *obj, int *val)
1507 {
1508 const char* errmsg = val ? "int" : (char*)0;
1509 long v;
1510 if (SWIG_AsVal_long(obj, &v)) {
1511 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1512 if (val) *val = (int)(v);
1513 return 1;
1514 } else {
1515 return 0;
1516 }
1517 } else {
1518 PyErr_Clear();
1519 }
1520 if (val) {
1521 SWIG_type_error(errmsg, obj);
1522 }
1523 return 0;
1524 }
1525 #else
1526 SWIGINTERNSHORT int
1527 SWIG_AsVal_int(PyObject *obj, int *val)
1528 {
1529 return SWIG_AsVal_long(obj,(long*)val);
1530 }
1531 #endif
1532
1533
1534 SWIGINTERNSHORT int
1535 SWIG_As_int(PyObject* obj)
1536 {
1537 int v;
1538 if (!SWIG_AsVal_int(obj, &v)) {
1539 /*
1540 this is needed to make valgrind/purify happier.
1541 */
1542 memset((void*)&v, 0, sizeof(int));
1543 }
1544 return v;
1545 }
1546
1547
1548 SWIGINTERNSHORT int
1549 SWIG_Check_int(PyObject* obj)
1550 {
1551 return SWIG_AsVal_int(obj, (int*)0);
1552 }
1553
1554 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1555
1556 #include <wx/stockitem.h>
1557
1558 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1559 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1560 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1561
1562 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1563 #define SWIG_From_long PyInt_FromLong
1564 /*@@*/
1565
1566
1567 SWIGINTERNSHORT long
1568 SWIG_As_long(PyObject* obj)
1569 {
1570 long v;
1571 if (!SWIG_AsVal_long(obj, &v)) {
1572 /*
1573 this is needed to make valgrind/purify happier.
1574 */
1575 memset((void*)&v, 0, sizeof(long));
1576 }
1577 return v;
1578 }
1579
1580
1581 SWIGINTERNSHORT int
1582 SWIG_Check_long(PyObject* obj)
1583 {
1584 return SWIG_AsVal_long(obj, (long*)0);
1585 }
1586
1587
1588 SWIGINTERN int
1589 SWIG_AsVal_bool(PyObject *obj, bool *val)
1590 {
1591 if (obj == Py_True) {
1592 if (val) *val = true;
1593 return 1;
1594 }
1595 if (obj == Py_False) {
1596 if (val) *val = false;
1597 return 1;
1598 }
1599 int res = 0;
1600 if (SWIG_AsVal_int(obj, &res)) {
1601 if (val) *val = res ? true : false;
1602 return 1;
1603 } else {
1604 PyErr_Clear();
1605 }
1606 if (val) {
1607 SWIG_type_error("bool", obj);
1608 }
1609 return 0;
1610 }
1611
1612
1613 SWIGINTERNSHORT bool
1614 SWIG_As_bool(PyObject* obj)
1615 {
1616 bool v;
1617 if (!SWIG_AsVal_bool(obj, &v)) {
1618 /*
1619 this is needed to make valgrind/purify happier.
1620 */
1621 memset((void*)&v, 0, sizeof(bool));
1622 }
1623 return v;
1624 }
1625
1626
1627 SWIGINTERNSHORT int
1628 SWIG_Check_bool(PyObject* obj)
1629 {
1630 return SWIG_AsVal_bool(obj, (bool*)0);
1631 }
1632
1633
1634 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1635 PyObject* o2;
1636 PyObject* o3;
1637
1638 if (!target) {
1639 target = o;
1640 } else if (target == Py_None) {
1641 Py_DECREF(Py_None);
1642 target = o;
1643 } else {
1644 if (!PyTuple_Check(target)) {
1645 o2 = target;
1646 target = PyTuple_New(1);
1647 PyTuple_SetItem(target, 0, o2);
1648 }
1649 o3 = PyTuple_New(1);
1650 PyTuple_SetItem(o3, 0, o);
1651
1652 o2 = target;
1653 target = PySequence_Concat(o2, o3);
1654 Py_DECREF(o2);
1655 Py_DECREF(o3);
1656 }
1657 return target;
1658 }
1659
1660
1661
1662 long wxGetFreeMemory()
1663 { wxPyRaiseNotImplemented(); return 0; }
1664
1665
1666 SWIGINTERN int
1667 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1668 {
1669 long v = 0;
1670 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1671 SWIG_type_error("unsigned number", obj);
1672 }
1673 else if (val)
1674 *val = (unsigned long)v;
1675 return 1;
1676 }
1677
1678
1679 SWIGINTERNSHORT unsigned long
1680 SWIG_As_unsigned_SS_long(PyObject* obj)
1681 {
1682 unsigned long v;
1683 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1684 /*
1685 this is needed to make valgrind/purify happier.
1686 */
1687 memset((void*)&v, 0, sizeof(unsigned long));
1688 }
1689 return v;
1690 }
1691
1692
1693 SWIGINTERNSHORT int
1694 SWIG_Check_unsigned_SS_long(PyObject* obj)
1695 {
1696 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1697 }
1698
1699
1700 SWIGINTERNSHORT PyObject*
1701 SWIG_From_unsigned_SS_long(unsigned long value)
1702 {
1703 return (value > LONG_MAX) ?
1704 PyLong_FromUnsignedLong(value)
1705 : PyInt_FromLong((long)(value));
1706 }
1707
1708
1709 void* wxGetXDisplay()
1710 {
1711 #ifdef __WXGTK__
1712 return wxGetDisplay();
1713 #else
1714 return NULL;
1715 #endif
1716 }
1717
1718
1719 void wxWakeUpMainThread() {}
1720
1721
1722 bool wxThread_IsMain() {
1723 #ifdef WXP_WITH_THREAD
1724 return wxThread::IsMain();
1725 #else
1726 return true;
1727 #endif
1728 }
1729
1730 static void wxCaret_Destroy(wxCaret *self){
1731 delete self;
1732 }
1733
1734 #include <wx/snglinst.h>
1735
1736
1737 #ifdef __WXMSW__
1738 #include <wx/msw/private.h>
1739 #include <wx/dynload.h>
1740 #endif
1741
1742
1743
1744 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1745 #if 0
1746 , int method
1747 #endif
1748 )
1749 {
1750 #ifdef __WXMSW__
1751 #if 0
1752 switch (method)
1753 {
1754 case 1:
1755 // This one only partially works. Appears to be an undocumented
1756 // "standard" convention that not all widgets adhear to. For
1757 // example, for some widgets backgrounds or non-client areas may
1758 // not be painted.
1759 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1760 break;
1761
1762 case 2:
1763 #endif
1764 // This one works much better, nearly all widgets and their
1765 // children are captured correctly[**]. Prior to the big
1766 // background erase changes that Vadim did in 2004-2005 this
1767 // method failed badly on XP with Themes activated, most native
1768 // widgets draw only partially, if at all. Without themes it
1769 // worked just like on Win2k. After those changes this method
1770 // works very well.
1771 //
1772 // ** For example the radio buttons in a wxRadioBox are not its
1773 // children by default, but you can capture it via the panel
1774 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1775 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1776 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1777 PRF_ERASEBKGND | PRF_OWNED );
1778 return true;
1779 #if 0
1780 break;
1781
1782 case 3:
1783 // This one is only defined in the latest SDK and is only
1784 // available on XP. MSDN says it is similar to sending WM_PRINT
1785 // so I expect that it will work similar to the above. Since it
1786 // is avaialble only on XP, it can't be compiled like this and
1787 // will have to be loaded dynamically.
1788 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1789
1790 // fall through
1791
1792 case 4:
1793 // Use PrintWindow if available, or fallback to WM_PRINT
1794 // otherwise. Unfortunately using PrintWindow is even worse than
1795 // WM_PRINT. For most native widgets nothing is drawn to the dc
1796 // at all, with or without Themes.
1797 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1798 static bool s_triedToLoad = false;
1799 static PrintWindow_t pfnPrintWindow = NULL;
1800 if ( !s_triedToLoad )
1801 {
1802
1803 s_triedToLoad = true;
1804 wxDynamicLibrary dllUser32(_T("user32.dll"));
1805 if ( dllUser32.IsLoaded() )
1806 {
1807 wxLogNull nolog; // Don't report errors here
1808 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1809 }
1810 }
1811 if (pfnPrintWindow)
1812 {
1813 //printf("Using PrintWindow\n");
1814 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1815 }
1816 else
1817 {
1818 //printf("Using WM_PRINT\n");
1819 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1820 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1821 PRF_ERASEBKGND | PRF_OWNED );
1822 }
1823 }
1824 #endif // 0
1825 #else
1826 return false;
1827 #endif // __WXMSW__
1828 }
1829
1830
1831
1832 #include <wx/tipdlg.h>
1833
1834
1835 class wxPyTipProvider : public wxTipProvider {
1836 public:
1837 wxPyTipProvider(size_t currentTip)
1838 : wxTipProvider(currentTip) {}
1839
1840 DEC_PYCALLBACK_STRING__pure(GetTip);
1841 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1842 PYPRIVATE;
1843 };
1844
1845 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1846 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1847
1848
1849 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1850
1851 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1852
1853 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1854 : wxTimer(owner, id)
1855 {
1856 if (owner == NULL) SetOwner(this);
1857 }
1858
1859
1860 void wxPyTimer::Notify() {
1861 bool found;
1862 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1863 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1864 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1865 wxPyEndBlockThreads(blocked);
1866 if (! found)
1867 wxTimer::Notify();
1868 }
1869 void wxPyTimer::base_Notify() {
1870 wxTimer::Notify();
1871 }
1872
1873
1874
1875 SWIGINTERN PyObject *
1876 SWIG_FromCharPtr(const char* cptr)
1877 {
1878 if (cptr) {
1879 size_t size = strlen(cptr);
1880 if (size > INT_MAX) {
1881 return SWIG_NewPointerObj((char*)(cptr),
1882 SWIG_TypeQuery("char *"), 0);
1883 } else {
1884 if (size != 0) {
1885 return PyString_FromStringAndSize(cptr, size);
1886 } else {
1887 return PyString_FromString(cptr);
1888 }
1889 }
1890 }
1891 Py_INCREF(Py_None);
1892 return Py_None;
1893 }
1894
1895
1896 SWIGINTERNSHORT int
1897 SWIG_CheckUnsignedLongInRange(unsigned long value,
1898 unsigned long max_value,
1899 const char *errmsg)
1900 {
1901 if (value > max_value) {
1902 if (errmsg) {
1903 PyErr_Format(PyExc_OverflowError,
1904 "value %lu is greater than '%s' minimum %lu",
1905 value, errmsg, max_value);
1906 }
1907 return 0;
1908 }
1909 return 1;
1910 }
1911
1912
1913 #if UINT_MAX != ULONG_MAX
1914 SWIGINTERN int
1915 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1916 {
1917 const char* errmsg = val ? "unsigned int" : (char*)0;
1918 unsigned long v;
1919 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1920 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1921 if (val) *val = (unsigned int)(v);
1922 return 1;
1923 }
1924 } else {
1925 PyErr_Clear();
1926 }
1927 if (val) {
1928 SWIG_type_error(errmsg, obj);
1929 }
1930 return 0;
1931 }
1932 #else
1933 SWIGINTERNSHORT unsigned int
1934 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1935 {
1936 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1937 }
1938 #endif
1939
1940
1941 SWIGINTERNSHORT unsigned int
1942 SWIG_As_unsigned_SS_int(PyObject* obj)
1943 {
1944 unsigned int v;
1945 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1946 /*
1947 this is needed to make valgrind/purify happier.
1948 */
1949 memset((void*)&v, 0, sizeof(unsigned int));
1950 }
1951 return v;
1952 }
1953
1954
1955 SWIGINTERNSHORT int
1956 SWIG_Check_unsigned_SS_int(PyObject* obj)
1957 {
1958 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1959 }
1960
1961 static wxString Log_TimeStamp(){
1962 wxString msg;
1963 wxLog::TimeStamp(&msg);
1964 return msg;
1965 }
1966 static void wxLog_Destroy(wxLog *self){ delete self; }
1967 // Make somce wrappers that double any % signs so they are 'escaped'
1968 void wxPyLogFatalError(const wxString& msg)
1969 {
1970 wxString m(msg);
1971 m.Replace(wxT("%"), wxT("%%"));
1972 wxLogFatalError(m);
1973 }
1974
1975 void wxPyLogError(const wxString& msg)
1976 {
1977 wxString m(msg);
1978 m.Replace(wxT("%"), wxT("%%"));
1979 wxLogError(m);
1980 }
1981
1982 void wxPyLogWarning(const wxString& msg)
1983 {
1984 wxString m(msg);
1985 m.Replace(wxT("%"), wxT("%%"));
1986 wxLogWarning(m);
1987 }
1988
1989 void wxPyLogMessage(const wxString& msg)
1990 {
1991 wxString m(msg);
1992 m.Replace(wxT("%"), wxT("%%"));
1993 wxLogMessage(m);
1994 }
1995
1996 void wxPyLogInfo(const wxString& msg)
1997 {
1998 wxString m(msg);
1999 m.Replace(wxT("%"), wxT("%%"));
2000 wxLogInfo(m);
2001 }
2002
2003 void wxPyLogDebug(const wxString& msg)
2004 {
2005 wxString m(msg);
2006 m.Replace(wxT("%"), wxT("%%"));
2007 wxLogDebug(m);
2008 }
2009
2010 void wxPyLogVerbose(const wxString& msg)
2011 {
2012 wxString m(msg);
2013 m.Replace(wxT("%"), wxT("%%"));
2014 wxLogVerbose(m);
2015 }
2016
2017 void wxPyLogStatus(const wxString& msg)
2018 {
2019 wxString m(msg);
2020 m.Replace(wxT("%"), wxT("%%"));
2021 wxLogStatus(m);
2022 }
2023
2024 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2025 {
2026 wxString m(msg);
2027 m.Replace(wxT("%"), wxT("%%"));
2028 wxLogStatus(pFrame, m);
2029 }
2030
2031 void wxPyLogSysError(const wxString& msg)
2032 {
2033 wxString m(msg);
2034 m.Replace(wxT("%"), wxT("%%"));
2035 wxLogSysError(m);
2036 }
2037
2038 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2039 {
2040 wxString m(msg);
2041 m.Replace(wxT("%"), wxT("%%"));
2042 wxLogGeneric(level, m);
2043 }
2044
2045 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2046 {
2047 wxString m(msg);
2048 m.Replace(wxT("%"), wxT("%%"));
2049 wxLogTrace(mask, m);
2050 }
2051
2052 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2053 {
2054 wxString m(msg);
2055 m.Replace(wxT("%"), wxT("%%"));
2056 wxLogTrace(mask, m);
2057 }
2058
2059
2060
2061 // A wxLog class that can be derived from in wxPython
2062 class wxPyLog : public wxLog {
2063 public:
2064 wxPyLog() : wxLog() {}
2065
2066 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2067 bool found;
2068 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2069 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2070 PyObject* s = wx2PyString(szString);
2071 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2072 Py_DECREF(s);
2073 }
2074 wxPyEndBlockThreads(blocked);
2075 if (! found)
2076 wxLog::DoLog(level, szString, t);
2077 }
2078
2079 virtual void DoLogString(const wxChar *szString, time_t t) {
2080 bool found;
2081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2082 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2083 PyObject* s = wx2PyString(szString);
2084 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2085 Py_DECREF(s);
2086 }
2087 wxPyEndBlockThreads(blocked);
2088 if (! found)
2089 wxLog::DoLogString(szString, t);
2090 }
2091
2092 PYPRIVATE;
2093 };
2094
2095
2096
2097
2098 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2099
2100
2101 #include <wx/joystick.h>
2102
2103
2104 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2105 // A C++ stub class for wxJoystick for platforms that don't have it.
2106 class wxJoystick : public wxObject {
2107 public:
2108 wxJoystick(int joystick = wxJOYSTICK1) {
2109 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2110 PyErr_SetString(PyExc_NotImplementedError,
2111 "wxJoystick is not available on this platform.");
2112 wxPyEndBlockThreads(blocked);
2113 }
2114 wxPoint GetPosition() { return wxPoint(-1,-1); }
2115 int GetZPosition() { return -1; }
2116 int GetButtonState() { return -1; }
2117 int GetPOVPosition() { return -1; }
2118 int GetPOVCTSPosition() { return -1; }
2119 int GetRudderPosition() { return -1; }
2120 int GetUPosition() { return -1; }
2121 int GetVPosition() { return -1; }
2122 int GetMovementThreshold() { return -1; }
2123 void SetMovementThreshold(int threshold) {}
2124
2125 bool IsOk(void) { return false; }
2126 int GetNumberJoysticks() { return -1; }
2127 int GetManufacturerId() { return -1; }
2128 int GetProductId() { return -1; }
2129 wxString GetProductName() { return wxEmptyString; }
2130 int GetXMin() { return -1; }
2131 int GetYMin() { return -1; }
2132 int GetZMin() { return -1; }
2133 int GetXMax() { return -1; }
2134 int GetYMax() { return -1; }
2135 int GetZMax() { return -1; }
2136 int GetNumberButtons() { return -1; }
2137 int GetNumberAxes() { return -1; }
2138 int GetMaxButtons() { return -1; }
2139 int GetMaxAxes() { return -1; }
2140 int GetPollingMin() { return -1; }
2141 int GetPollingMax() { return -1; }
2142 int GetRudderMin() { return -1; }
2143 int GetRudderMax() { return -1; }
2144 int GetUMin() { return -1; }
2145 int GetUMax() { return -1; }
2146 int GetVMin() { return -1; }
2147 int GetVMax() { return -1; }
2148
2149 bool HasRudder() { return false; }
2150 bool HasZ() { return false; }
2151 bool HasU() { return false; }
2152 bool HasV() { return false; }
2153 bool HasPOV() { return false; }
2154 bool HasPOV4Dir() { return false; }
2155 bool HasPOVCTS() { return false; }
2156
2157 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2158 bool ReleaseCapture() { return false; }
2159 };
2160 #endif
2161
2162
2163 #include <wx/sound.h>
2164
2165
2166 #if !wxUSE_SOUND
2167 // A C++ stub class for wxWave for platforms that don't have it.
2168 class wxSound : public wxObject
2169 {
2170 public:
2171 wxSound() {
2172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177 wxSound(const wxString&/*, bool*/) {
2178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2179 PyErr_SetString(PyExc_NotImplementedError,
2180 "wxSound is not available on this platform.");
2181 wxPyEndBlockThreads(blocked);
2182 }
2183 wxSound(int, const wxByte*) {
2184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2185 PyErr_SetString(PyExc_NotImplementedError,
2186 "wxSound is not available on this platform.");
2187 wxPyEndBlockThreads(blocked);
2188 }
2189
2190 ~wxSound() {};
2191
2192 bool Create(const wxString&/*, bool*/) { return false; }
2193 bool Create(int, const wxByte*) { return false; };
2194 bool IsOk() { return false; };
2195 bool Play(unsigned) const { return false; }
2196 static bool Play(const wxString&, unsigned) { return false; }
2197 static void Stop() {}
2198 };
2199
2200 #endif
2201
2202 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2203 if (fileName.Length() == 0)
2204 return new wxSound;
2205 else
2206 return new wxSound(fileName);
2207 }
2208 static wxSound *new_wxSound(PyObject *data){
2209 unsigned char* buffer; int size;
2210 wxSound *sound = NULL;
2211
2212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2213 if (!PyArg_Parse(data, "t#", &buffer, &size))
2214 goto done;
2215 sound = new wxSound(size, buffer);
2216 done:
2217 wxPyEndBlockThreads(blocked);
2218 return sound;
2219 }
2220 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2221 #ifndef __WXMAC__
2222 unsigned char* buffer;
2223 int size;
2224 bool rv = false;
2225
2226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2227 if (!PyArg_Parse(data, "t#", &buffer, &size))
2228 goto done;
2229 rv = self->Create(size, buffer);
2230 done:
2231 wxPyEndBlockThreads(blocked);
2232 return rv;
2233 #else
2234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2235 PyErr_SetString(PyExc_NotImplementedError,
2236 "Create from data is not available on this platform.");
2237 wxPyEndBlockThreads(blocked);
2238 return false;
2239 #endif
2240 }
2241
2242 #include <wx/mimetype.h>
2243
2244 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2245 wxString str;
2246 if (self->GetMimeType(&str))
2247 return wx2PyString(str);
2248 else
2249 RETURN_NONE();
2250 }
2251 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2252 wxArrayString arr;
2253 if (self->GetMimeTypes(arr))
2254 return wxArrayString2PyList_helper(arr);
2255 else
2256 RETURN_NONE();
2257 }
2258 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2259 wxArrayString arr;
2260 if (self->GetExtensions(arr))
2261 return wxArrayString2PyList_helper(arr);
2262 else
2263 RETURN_NONE();
2264 }
2265 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2266 wxIconLocation loc;
2267 if (self->GetIcon(&loc))
2268 return new wxIcon(loc);
2269 else
2270 return NULL;
2271 }
2272 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2273 wxIconLocation loc;
2274 if (self->GetIcon(&loc)) {
2275 wxString iconFile = loc.GetFileName();
2276 int iconIndex = -1;
2277
2278
2279
2280 // Make a tuple and put the values in it
2281 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2282 PyObject* tuple = PyTuple_New(3);
2283 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2284 wxT("wxIcon"), true));
2285 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2286 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2287 wxPyEndBlockThreads(blocked);
2288 return tuple;
2289 }
2290 else
2291 RETURN_NONE();
2292 }
2293 static PyObject *wxFileType_GetDescription(wxFileType *self){
2294 wxString str;
2295 if (self->GetDescription(&str))
2296 return wx2PyString(str);
2297 else
2298 RETURN_NONE();
2299 }
2300 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2301 wxString str;
2302 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2303 return wx2PyString(str);
2304 else
2305 RETURN_NONE();
2306 }
2307 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2308 wxString str;
2309 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2310 return wx2PyString(str);
2311 else
2312 RETURN_NONE();
2313 }
2314 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2315 wxArrayString verbs;
2316 wxArrayString commands;
2317 if (self->GetAllCommands(&verbs, &commands,
2318 wxFileType::MessageParameters(filename, mimetype))) {
2319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2320 PyObject* tuple = PyTuple_New(2);
2321 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2322 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2323 wxPyEndBlockThreads(blocked);
2324 return tuple;
2325 }
2326 else
2327 RETURN_NONE();
2328 }
2329 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2330 return wxFileType::ExpandCommand(command,
2331 wxFileType::MessageParameters(filename, mimetype));
2332 }
2333 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2334 wxArrayString arr;
2335 self->EnumAllFileTypes(arr);
2336 return wxArrayString2PyList_helper(arr);
2337 }
2338
2339 #include <wx/artprov.h>
2340
2341 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2342 static const wxString wxPyART_MENU(wxART_MENU);
2343 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2344 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2345 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2346 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2347 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2348 static const wxString wxPyART_OTHER(wxART_OTHER);
2349 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2350 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2351 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2352 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2353 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2354 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2355 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2356 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2357 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2358 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2359 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2360 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2361 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2362 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2363 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2364 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2365 static const wxString wxPyART_PRINT(wxART_PRINT);
2366 static const wxString wxPyART_HELP(wxART_HELP);
2367 static const wxString wxPyART_TIP(wxART_TIP);
2368 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2369 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2370 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2371 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2372 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2373 static const wxString wxPyART_CDROM(wxART_CDROM);
2374 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2375 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2376 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2377 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2378 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2379 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2380 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2381 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2382 static const wxString wxPyART_ERROR(wxART_ERROR);
2383 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2384 static const wxString wxPyART_WARNING(wxART_WARNING);
2385 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2386 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2387 static const wxString wxPyART_COPY(wxART_COPY);
2388 static const wxString wxPyART_CUT(wxART_CUT);
2389 static const wxString wxPyART_PASTE(wxART_PASTE);
2390 static const wxString wxPyART_DELETE(wxART_DELETE);
2391 static const wxString wxPyART_UNDO(wxART_UNDO);
2392 static const wxString wxPyART_REDO(wxART_REDO);
2393 static const wxString wxPyART_QUIT(wxART_QUIT);
2394 static const wxString wxPyART_FIND(wxART_FIND);
2395 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2396 // Python aware wxArtProvider
2397 class wxPyArtProvider : public wxArtProvider {
2398 public:
2399
2400 virtual wxBitmap CreateBitmap(const wxArtID& id,
2401 const wxArtClient& client,
2402 const wxSize& size) {
2403 wxBitmap rval = wxNullBitmap;
2404 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2405 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2406 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2407 PyObject* ro;
2408 wxBitmap* ptr;
2409 PyObject* s1, *s2;
2410 s1 = wx2PyString(id);
2411 s2 = wx2PyString(client);
2412 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2413 Py_DECREF(so);
2414 Py_DECREF(s1);
2415 Py_DECREF(s2);
2416 if (ro) {
2417 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2418 rval = *ptr;
2419 Py_DECREF(ro);
2420 }
2421 }
2422 wxPyEndBlockThreads(blocked);
2423 return rval;
2424 }
2425
2426 PYPRIVATE;
2427 };
2428
2429 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2430
2431
2432
2433 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2434 PyObject* ret = PyTuple_New(3);
2435 if (ret) {
2436 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2437 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2438 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2439 }
2440 return ret;
2441 }
2442
2443 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2444 bool cont;
2445 long index = 0;
2446 wxString value;
2447
2448 cont = self->GetFirstGroup(value, index);
2449 return __EnumerationHelper(cont, value, index);
2450 }
2451 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2452 bool cont;
2453 wxString value;
2454
2455 cont = self->GetNextGroup(value, index);
2456 return __EnumerationHelper(cont, value, index);
2457 }
2458 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2459 bool cont;
2460 long index = 0;
2461 wxString value;
2462
2463 cont = self->GetFirstEntry(value, index);
2464 return __EnumerationHelper(cont, value, index);
2465 }
2466 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2467 bool cont;
2468 wxString value;
2469
2470 cont = self->GetNextEntry(value, index);
2471 return __EnumerationHelper(cont, value, index);
2472 }
2473 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2474 long rv;
2475 self->Read(key, &rv, defaultVal);
2476 return rv;
2477 }
2478
2479 SWIGINTERN int
2480 SWIG_AsVal_double(PyObject *obj, double* val)
2481 {
2482 if (PyNumber_Check(obj)) {
2483 if (val) *val = PyFloat_AsDouble(obj);
2484 return 1;
2485 }
2486 else {
2487 SWIG_type_error("number", obj);
2488 }
2489 return 0;
2490 }
2491
2492
2493 SWIGINTERNSHORT double
2494 SWIG_As_double(PyObject* obj)
2495 {
2496 double v;
2497 if (!SWIG_AsVal_double(obj, &v)) {
2498 /*
2499 this is needed to make valgrind/purify happier.
2500 */
2501 memset((void*)&v, 0, sizeof(double));
2502 }
2503 return v;
2504 }
2505
2506
2507 SWIGINTERNSHORT int
2508 SWIG_Check_double(PyObject* obj)
2509 {
2510 return SWIG_AsVal_double(obj, (double*)0);
2511 }
2512
2513 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2514 double rv;
2515 self->Read(key, &rv, defaultVal);
2516 return rv;
2517 }
2518
2519 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2520 #define SWIG_From_double PyFloat_FromDouble
2521 /*@@*/
2522
2523 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2524 bool rv;
2525 self->Read(key, &rv, defaultVal);
2526 return rv;
2527 }
2528
2529 #include <wx/datetime.h>
2530
2531 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2532 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2533
2534 #define LOCAL_TZ wxDateTime::Local
2535
2536 static PyObject *DateTime_GetAmPmStrings(){
2537 wxString am;
2538 wxString pm;
2539 wxDateTime::GetAmPmStrings(&am, &pm);
2540 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2541 PyObject* tup = PyTuple_New(2);
2542 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2543 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2544 wxPyEndBlockThreads(blocked);
2545 return tup;
2546 }
2547
2548 #if UINT_MAX < LONG_MAX
2549 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2550 #define SWIG_From_unsigned_SS_int SWIG_From_long
2551 /*@@*/
2552 #else
2553 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2554 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2555 /*@@*/
2556 #endif
2557
2558 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2559 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2560 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2561 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2562 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2563 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2564 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2565 return (*self < *other);
2566 }
2567 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2568 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2569 return (*self <= *other);
2570 }
2571 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2572 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2573 return (*self > *other);
2574 }
2575 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2576 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2577 return (*self >= *other);
2578 }
2579 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2580 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2581 return (*self == *other);
2582 }
2583 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2584 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2585 return (*self != *other);
2586 }
2587 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2588 const wxChar* rv;
2589 const wxChar* _date = date;
2590 rv = self->ParseRfc822Date(_date);
2591 if (rv == NULL) return -1;
2592 return rv - _date;
2593 }
2594 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2595 const wxChar* rv;
2596 const wxChar* _date = date;
2597 rv = self->ParseFormat(_date, format, dateDef);
2598 if (rv == NULL) return -1;
2599 return rv - _date;
2600 }
2601 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2602 const wxChar* rv;
2603 const wxChar* _datetime = datetime;
2604 rv = self->ParseDateTime(_datetime);
2605 if (rv == NULL) return -1;
2606 return rv - _datetime;
2607 }
2608 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2609 const wxChar* rv;
2610 const wxChar* _date = date;
2611 rv = self->ParseDate(_date);
2612 if (rv == NULL) return -1;
2613 return rv - _date;
2614 }
2615 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2616 const wxChar* rv;
2617 const wxChar* _time = time;
2618 rv = self->ParseTime(_time);
2619 if (rv == NULL) return -1;
2620 return rv - _time;
2621 }
2622 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2623 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2624 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2625 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2626 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2627 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2628 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2629 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2630 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2631 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2632 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2633 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2634 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2635 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2636 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2637 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2638
2639 #include <wx/dataobj.h>
2640
2641 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2642 size_t count = self->GetFormatCount(dir);
2643 wxDataFormat* formats = new wxDataFormat[count];
2644 self->GetAllFormats(formats, dir);
2645
2646 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2647 PyObject* list = PyList_New(count);
2648 for (size_t i=0; i<count; i++) {
2649 wxDataFormat* format = new wxDataFormat(formats[i]);
2650 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2651 PyList_Append(list, obj);
2652 Py_DECREF(obj);
2653 }
2654 wxPyEndBlockThreads(blocked);
2655 delete [] formats;
2656 return list;
2657 }
2658 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2659 PyObject* rval = NULL;
2660 size_t size = self->GetDataSize(format);
2661 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2662 if (size) {
2663 char* buf = new char[size];
2664 if (self->GetDataHere(format, buf))
2665 rval = PyString_FromStringAndSize(buf, size);
2666 delete [] buf;
2667 }
2668 if (! rval) {
2669 rval = Py_None;
2670 Py_INCREF(rval);
2671 }
2672 wxPyEndBlockThreads(blocked);
2673 return rval;
2674 }
2675 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2676 bool rval;
2677 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2678 if (PyString_Check(data)) {
2679 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2680 }
2681 else {
2682 // raise a TypeError if not a string
2683 PyErr_SetString(PyExc_TypeError, "String expected.");
2684 rval = false;
2685 }
2686 wxPyEndBlockThreads(blocked);
2687 return rval;
2688 }
2689 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2690 PyObject* rval = NULL;
2691 size_t size = self->GetDataSize();
2692 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2693 if (size) {
2694 char* buf = new char[size];
2695 if (self->GetDataHere(buf))
2696 rval = PyString_FromStringAndSize(buf, size);
2697 delete [] buf;
2698 }
2699 if (! rval) {
2700 rval = Py_None;
2701 Py_INCREF(rval);
2702 }
2703 wxPyEndBlockThreads(blocked);
2704 return rval;
2705 }
2706 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2707 bool rval;
2708 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2709 if (PyString_Check(data)) {
2710 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2711 }
2712 else {
2713 // raise a TypeError if not a string
2714 PyErr_SetString(PyExc_TypeError, "String expected.");
2715 rval = false;
2716 }
2717 wxPyEndBlockThreads(blocked);
2718 return rval;
2719 }
2720 // Create a new class for wxPython to use
2721 class wxPyDataObjectSimple : public wxDataObjectSimple {
2722 public:
2723 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2724 : wxDataObjectSimple(format) {}
2725
2726 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2727 bool GetDataHere(void *buf) const;
2728 bool SetData(size_t len, const void *buf) const;
2729 PYPRIVATE;
2730 };
2731
2732 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2733
2734 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2735 // We need to get the data for this object and write it to buf. I think
2736 // the best way to do this for wxPython is to have the Python method
2737 // return either a string or None and then act appropriately with the
2738 // C++ version.
2739
2740 bool rval = false;
2741 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2742 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2743 PyObject* ro;
2744 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2745 if (ro) {
2746 rval = (ro != Py_None && PyString_Check(ro));
2747 if (rval)
2748 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2749 Py_DECREF(ro);
2750 }
2751 }
2752 wxPyEndBlockThreads(blocked);
2753 return rval;
2754 }
2755
2756 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2757 // For this one we simply need to make a string from buf and len
2758 // and send it to the Python method.
2759 bool rval = false;
2760 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2761 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2762 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2763 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2764 Py_DECREF(data);
2765 }
2766 wxPyEndBlockThreads(blocked);
2767 return rval;
2768 }
2769
2770 // Create a new class for wxPython to use
2771 class wxPyTextDataObject : public wxTextDataObject {
2772 public:
2773 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2774 : wxTextDataObject(text) {}
2775
2776 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2777 DEC_PYCALLBACK_STRING__const(GetText);
2778 DEC_PYCALLBACK__STRING(SetText);
2779 PYPRIVATE;
2780 };
2781
2782 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2783 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2784 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2785
2786
2787 // Create a new class for wxPython to use
2788 class wxPyBitmapDataObject : public wxBitmapDataObject {
2789 public:
2790 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2791 : wxBitmapDataObject(bitmap) {}
2792
2793 wxBitmap GetBitmap() const;
2794 void SetBitmap(const wxBitmap& bitmap);
2795 PYPRIVATE;
2796 };
2797
2798 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2799 wxBitmap* rval = &wxNullBitmap;
2800 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2801 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2802 PyObject* ro;
2803 wxBitmap* ptr;
2804 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2805 if (ro) {
2806 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2807 rval = ptr;
2808 Py_DECREF(ro);
2809 }
2810 }
2811 wxPyEndBlockThreads(blocked);
2812 return *rval;
2813 }
2814
2815 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2816 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2817 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2818 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2819 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2820 Py_DECREF(bo);
2821 }
2822 wxPyEndBlockThreads(blocked);
2823 }
2824
2825 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2826 return new wxCustomDataObject(wxDataFormat(formatName));
2827 }
2828 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2829 bool rval;
2830 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2831 if (PyString_Check(data)) {
2832 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2833 }
2834 else {
2835 // raise a TypeError if not a string
2836 PyErr_SetString(PyExc_TypeError, "String expected.");
2837 rval = false;
2838 }
2839 wxPyEndBlockThreads(blocked);
2840 return rval;
2841 }
2842 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2843 PyObject* obj;
2844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2845 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2846 wxPyEndBlockThreads(blocked);
2847 return obj;
2848 }
2849
2850 class wxMetafileDataObject : public wxDataObjectSimple
2851 {
2852 public:
2853 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2854 };
2855
2856
2857 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2858
2859
2860 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2861 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2862 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2863 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2864 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2865
2866
2867 class wxPyTextDropTarget : public wxTextDropTarget {
2868 public:
2869 wxPyTextDropTarget() {}
2870
2871 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2872
2873 DEC_PYCALLBACK__(OnLeave);
2874 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2875 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2877 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2878
2879 PYPRIVATE;
2880 };
2881
2882 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2883 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2884 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2885 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2886 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2887 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2888
2889
2890
2891 class wxPyFileDropTarget : public wxFileDropTarget {
2892 public:
2893 wxPyFileDropTarget() {}
2894
2895 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2896
2897 DEC_PYCALLBACK__(OnLeave);
2898 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2899 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2900 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2901 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2902
2903 PYPRIVATE;
2904 };
2905
2906 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2907 const wxArrayString& filenames) {
2908 bool rval = false;
2909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2910 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2911 PyObject* list = wxArrayString2PyList_helper(filenames);
2912 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2913 Py_DECREF(list);
2914 }
2915 wxPyEndBlockThreads(blocked);
2916 return rval;
2917 }
2918
2919
2920
2921 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2922 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2923 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2924 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2925 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2926
2927
2928
2929
2930 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2931
2932 #include <wx/display.h>
2933
2934 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2935 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2936
2937 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2938 #if !wxUSE_DISPLAY
2939 #include <wx/dynarray.h>
2940 #include <wx/vidmode.h>
2941
2942 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2943 #include "wx/arrimpl.cpp"
2944 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2945 const wxVideoMode wxDefaultVideoMode;
2946
2947 class wxDisplay
2948 {
2949 public:
2950 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2951 ~wxDisplay() {}
2952
2953 static size_t GetCount()
2954 { wxPyRaiseNotImplemented(); return 0; }
2955
2956 static int GetFromPoint(const wxPoint& pt)
2957 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2958 static int GetFromWindow(wxWindow *window)
2959 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2960
2961 virtual bool IsOk() const { return false; }
2962 virtual wxRect GetGeometry() const { wxRect r; return r; }
2963 virtual wxString GetName() const { return wxEmptyString; }
2964 bool IsPrimary() const { return false; }
2965
2966 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2967 { wxArrayVideoModes a; return a; }
2968
2969 virtual wxVideoMode GetCurrentMode() const
2970 { return wxDefaultVideoMode; }
2971
2972 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2973 { return false; }
2974
2975 void ResetMode() {}
2976 };
2977 #endif
2978
2979 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2980 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2981 PyObject* pyList = NULL;
2982 wxArrayVideoModes arr = self->GetModes(mode);
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 pyList = PyList_New(0);
2985 for (int i=0; i < arr.GetCount(); i++) {
2986 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2987 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2988 PyList_Append(pyList, pyObj);
2989 Py_DECREF(pyObj);
2990 }
2991 wxPyEndBlockThreads(blocked);
2992 return pyList;
2993 }
2994
2995 #include <wx/stdpaths.h>
2996
2997 static wxStandardPaths *StandardPaths_Get(){
2998 return (wxStandardPaths*) &wxStandardPaths::Get();
2999 }
3000 #ifdef __cplusplus
3001 extern "C" {
3002 #endif
3003 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3004 PyObject *resultobj;
3005 wxSystemColour arg1 ;
3006 wxColour result;
3007 PyObject * obj0 = 0 ;
3008 char *kwnames[] = {
3009 (char *) "index", NULL
3010 };
3011
3012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3013 {
3014 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3015 if (SWIG_arg_fail(1)) SWIG_fail;
3016 }
3017 {
3018 if (!wxPyCheckForApp()) SWIG_fail;
3019 PyThreadState* __tstate = wxPyBeginAllowThreads();
3020 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3021
3022 wxPyEndAllowThreads(__tstate);
3023 if (PyErr_Occurred()) SWIG_fail;
3024 }
3025 {
3026 wxColour * resultptr;
3027 resultptr = new wxColour((wxColour &)(result));
3028 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3029 }
3030 return resultobj;
3031 fail:
3032 return NULL;
3033 }
3034
3035
3036 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3037 PyObject *resultobj;
3038 wxSystemFont arg1 ;
3039 wxFont result;
3040 PyObject * obj0 = 0 ;
3041 char *kwnames[] = {
3042 (char *) "index", NULL
3043 };
3044
3045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3046 {
3047 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3048 if (SWIG_arg_fail(1)) SWIG_fail;
3049 }
3050 {
3051 if (!wxPyCheckForApp()) SWIG_fail;
3052 PyThreadState* __tstate = wxPyBeginAllowThreads();
3053 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3054
3055 wxPyEndAllowThreads(__tstate);
3056 if (PyErr_Occurred()) SWIG_fail;
3057 }
3058 {
3059 wxFont * resultptr;
3060 resultptr = new wxFont((wxFont &)(result));
3061 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3062 }
3063 return resultobj;
3064 fail:
3065 return NULL;
3066 }
3067
3068
3069 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3070 PyObject *resultobj;
3071 wxSystemMetric arg1 ;
3072 wxWindow *arg2 = (wxWindow *) NULL ;
3073 int result;
3074 PyObject * obj0 = 0 ;
3075 PyObject * obj1 = 0 ;
3076 char *kwnames[] = {
3077 (char *) "index",(char *) "win", NULL
3078 };
3079
3080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3081 {
3082 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3083 if (SWIG_arg_fail(1)) SWIG_fail;
3084 }
3085 if (obj1) {
3086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3087 if (SWIG_arg_fail(2)) SWIG_fail;
3088 }
3089 {
3090 if (!wxPyCheckForApp()) SWIG_fail;
3091 PyThreadState* __tstate = wxPyBeginAllowThreads();
3092 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3093
3094 wxPyEndAllowThreads(__tstate);
3095 if (PyErr_Occurred()) SWIG_fail;
3096 }
3097 {
3098 resultobj = SWIG_From_int((int)(result));
3099 }
3100 return resultobj;
3101 fail:
3102 return NULL;
3103 }
3104
3105
3106 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3107 PyObject *resultobj;
3108 wxSystemFeature arg1 ;
3109 bool result;
3110 PyObject * obj0 = 0 ;
3111 char *kwnames[] = {
3112 (char *) "index", NULL
3113 };
3114
3115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3116 {
3117 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3118 if (SWIG_arg_fail(1)) SWIG_fail;
3119 }
3120 {
3121 if (!wxPyCheckForApp()) SWIG_fail;
3122 PyThreadState* __tstate = wxPyBeginAllowThreads();
3123 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3124
3125 wxPyEndAllowThreads(__tstate);
3126 if (PyErr_Occurred()) SWIG_fail;
3127 }
3128 {
3129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3130 }
3131 return resultobj;
3132 fail:
3133 return NULL;
3134 }
3135
3136
3137 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3138 PyObject *resultobj;
3139 wxSystemScreenType result;
3140 char *kwnames[] = {
3141 NULL
3142 };
3143
3144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3145 {
3146 if (!wxPyCheckForApp()) SWIG_fail;
3147 PyThreadState* __tstate = wxPyBeginAllowThreads();
3148 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3149
3150 wxPyEndAllowThreads(__tstate);
3151 if (PyErr_Occurred()) SWIG_fail;
3152 }
3153 resultobj = SWIG_From_int((result));
3154 return resultobj;
3155 fail:
3156 return NULL;
3157 }
3158
3159
3160 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3161 PyObject *resultobj;
3162 wxSystemScreenType arg1 ;
3163 PyObject * obj0 = 0 ;
3164 char *kwnames[] = {
3165 (char *) "screen", NULL
3166 };
3167
3168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3169 {
3170 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3171 if (SWIG_arg_fail(1)) SWIG_fail;
3172 }
3173 {
3174 if (!wxPyCheckForApp()) SWIG_fail;
3175 PyThreadState* __tstate = wxPyBeginAllowThreads();
3176 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3177
3178 wxPyEndAllowThreads(__tstate);
3179 if (PyErr_Occurred()) SWIG_fail;
3180 }
3181 Py_INCREF(Py_None); resultobj = Py_None;
3182 return resultobj;
3183 fail:
3184 return NULL;
3185 }
3186
3187
3188 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3189 PyObject *obj;
3190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3191 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3192 Py_INCREF(obj);
3193 return Py_BuildValue((char *)"");
3194 }
3195 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3196 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3197 return 1;
3198 }
3199
3200
3201 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3202 PyObject *pyobj;
3203
3204 {
3205 #if wxUSE_UNICODE
3206 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3207 #else
3208 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3209 #endif
3210 }
3211 return pyobj;
3212 }
3213
3214
3215 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3216 PyObject *resultobj;
3217 wxSystemOptions *result;
3218 char *kwnames[] = {
3219 NULL
3220 };
3221
3222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3223 {
3224 PyThreadState* __tstate = wxPyBeginAllowThreads();
3225 result = (wxSystemOptions *)new wxSystemOptions();
3226
3227 wxPyEndAllowThreads(__tstate);
3228 if (PyErr_Occurred()) SWIG_fail;
3229 }
3230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3231 return resultobj;
3232 fail:
3233 return NULL;
3234 }
3235
3236
3237 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3238 PyObject *resultobj;
3239 wxString *arg1 = 0 ;
3240 wxString *arg2 = 0 ;
3241 bool temp1 = false ;
3242 bool temp2 = false ;
3243 PyObject * obj0 = 0 ;
3244 PyObject * obj1 = 0 ;
3245 char *kwnames[] = {
3246 (char *) "name",(char *) "value", NULL
3247 };
3248
3249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3250 {
3251 arg1 = wxString_in_helper(obj0);
3252 if (arg1 == NULL) SWIG_fail;
3253 temp1 = true;
3254 }
3255 {
3256 arg2 = wxString_in_helper(obj1);
3257 if (arg2 == NULL) SWIG_fail;
3258 temp2 = true;
3259 }
3260 {
3261 PyThreadState* __tstate = wxPyBeginAllowThreads();
3262 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3263
3264 wxPyEndAllowThreads(__tstate);
3265 if (PyErr_Occurred()) SWIG_fail;
3266 }
3267 Py_INCREF(Py_None); resultobj = Py_None;
3268 {
3269 if (temp1)
3270 delete arg1;
3271 }
3272 {
3273 if (temp2)
3274 delete arg2;
3275 }
3276 return resultobj;
3277 fail:
3278 {
3279 if (temp1)
3280 delete arg1;
3281 }
3282 {
3283 if (temp2)
3284 delete arg2;
3285 }
3286 return NULL;
3287 }
3288
3289
3290 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3291 PyObject *resultobj;
3292 wxString *arg1 = 0 ;
3293 int arg2 ;
3294 bool temp1 = false ;
3295 PyObject * obj0 = 0 ;
3296 PyObject * obj1 = 0 ;
3297 char *kwnames[] = {
3298 (char *) "name",(char *) "value", NULL
3299 };
3300
3301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3302 {
3303 arg1 = wxString_in_helper(obj0);
3304 if (arg1 == NULL) SWIG_fail;
3305 temp1 = true;
3306 }
3307 {
3308 arg2 = (int)(SWIG_As_int(obj1));
3309 if (SWIG_arg_fail(2)) SWIG_fail;
3310 }
3311 {
3312 PyThreadState* __tstate = wxPyBeginAllowThreads();
3313 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3314
3315 wxPyEndAllowThreads(__tstate);
3316 if (PyErr_Occurred()) SWIG_fail;
3317 }
3318 Py_INCREF(Py_None); resultobj = Py_None;
3319 {
3320 if (temp1)
3321 delete arg1;
3322 }
3323 return resultobj;
3324 fail:
3325 {
3326 if (temp1)
3327 delete arg1;
3328 }
3329 return NULL;
3330 }
3331
3332
3333 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3334 PyObject *resultobj;
3335 wxString *arg1 = 0 ;
3336 wxString result;
3337 bool temp1 = false ;
3338 PyObject * obj0 = 0 ;
3339 char *kwnames[] = {
3340 (char *) "name", NULL
3341 };
3342
3343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3344 {
3345 arg1 = wxString_in_helper(obj0);
3346 if (arg1 == NULL) SWIG_fail;
3347 temp1 = true;
3348 }
3349 {
3350 PyThreadState* __tstate = wxPyBeginAllowThreads();
3351 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3352
3353 wxPyEndAllowThreads(__tstate);
3354 if (PyErr_Occurred()) SWIG_fail;
3355 }
3356 {
3357 #if wxUSE_UNICODE
3358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3359 #else
3360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3361 #endif
3362 }
3363 {
3364 if (temp1)
3365 delete arg1;
3366 }
3367 return resultobj;
3368 fail:
3369 {
3370 if (temp1)
3371 delete arg1;
3372 }
3373 return NULL;
3374 }
3375
3376
3377 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3378 PyObject *resultobj;
3379 wxString *arg1 = 0 ;
3380 int result;
3381 bool temp1 = false ;
3382 PyObject * obj0 = 0 ;
3383 char *kwnames[] = {
3384 (char *) "name", NULL
3385 };
3386
3387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3388 {
3389 arg1 = wxString_in_helper(obj0);
3390 if (arg1 == NULL) SWIG_fail;
3391 temp1 = true;
3392 }
3393 {
3394 PyThreadState* __tstate = wxPyBeginAllowThreads();
3395 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3396
3397 wxPyEndAllowThreads(__tstate);
3398 if (PyErr_Occurred()) SWIG_fail;
3399 }
3400 {
3401 resultobj = SWIG_From_int((int)(result));
3402 }
3403 {
3404 if (temp1)
3405 delete arg1;
3406 }
3407 return resultobj;
3408 fail:
3409 {
3410 if (temp1)
3411 delete arg1;
3412 }
3413 return NULL;
3414 }
3415
3416
3417 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3418 PyObject *resultobj;
3419 wxString *arg1 = 0 ;
3420 bool result;
3421 bool temp1 = false ;
3422 PyObject * obj0 = 0 ;
3423 char *kwnames[] = {
3424 (char *) "name", NULL
3425 };
3426
3427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3428 {
3429 arg1 = wxString_in_helper(obj0);
3430 if (arg1 == NULL) SWIG_fail;
3431 temp1 = true;
3432 }
3433 {
3434 PyThreadState* __tstate = wxPyBeginAllowThreads();
3435 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3436
3437 wxPyEndAllowThreads(__tstate);
3438 if (PyErr_Occurred()) SWIG_fail;
3439 }
3440 {
3441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3442 }
3443 {
3444 if (temp1)
3445 delete arg1;
3446 }
3447 return resultobj;
3448 fail:
3449 {
3450 if (temp1)
3451 delete arg1;
3452 }
3453 return NULL;
3454 }
3455
3456
3457 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3458 PyObject *resultobj;
3459 wxString *arg1 = 0 ;
3460 bool result;
3461 bool temp1 = false ;
3462 PyObject * obj0 = 0 ;
3463 char *kwnames[] = {
3464 (char *) "name", NULL
3465 };
3466
3467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3468 {
3469 arg1 = wxString_in_helper(obj0);
3470 if (arg1 == NULL) SWIG_fail;
3471 temp1 = true;
3472 }
3473 {
3474 PyThreadState* __tstate = wxPyBeginAllowThreads();
3475 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3476
3477 wxPyEndAllowThreads(__tstate);
3478 if (PyErr_Occurred()) SWIG_fail;
3479 }
3480 {
3481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3482 }
3483 {
3484 if (temp1)
3485 delete arg1;
3486 }
3487 return resultobj;
3488 fail:
3489 {
3490 if (temp1)
3491 delete arg1;
3492 }
3493 return NULL;
3494 }
3495
3496
3497 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3498 PyObject *obj;
3499 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3500 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3501 Py_INCREF(obj);
3502 return Py_BuildValue((char *)"");
3503 }
3504 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3505 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3506 return 1;
3507 }
3508
3509
3510 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3511 PyObject *pyobj;
3512
3513 {
3514 #if wxUSE_UNICODE
3515 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3516 #else
3517 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3518 #endif
3519 }
3520 return pyobj;
3521 }
3522
3523
3524 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3525 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3526 return 1;
3527 }
3528
3529
3530 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3531 PyObject *pyobj;
3532
3533 {
3534 #if wxUSE_UNICODE
3535 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3536 #else
3537 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3538 #endif
3539 }
3540 return pyobj;
3541 }
3542
3543
3544 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3545 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3546 return 1;
3547 }
3548
3549
3550 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3551 PyObject *pyobj;
3552
3553 {
3554 #if wxUSE_UNICODE
3555 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3556 #else
3557 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3558 #endif
3559 }
3560 return pyobj;
3561 }
3562
3563
3564 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3565 PyObject *resultobj;
3566 long result;
3567 char *kwnames[] = {
3568 NULL
3569 };
3570
3571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3572 {
3573 PyThreadState* __tstate = wxPyBeginAllowThreads();
3574 result = (long)wxNewId();
3575
3576 wxPyEndAllowThreads(__tstate);
3577 if (PyErr_Occurred()) SWIG_fail;
3578 }
3579 {
3580 resultobj = SWIG_From_long((long)(result));
3581 }
3582 return resultobj;
3583 fail:
3584 return NULL;
3585 }
3586
3587
3588 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3589 PyObject *resultobj;
3590 long arg1 ;
3591 PyObject * obj0 = 0 ;
3592 char *kwnames[] = {
3593 (char *) "id", NULL
3594 };
3595
3596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3597 {
3598 arg1 = (long)(SWIG_As_long(obj0));
3599 if (SWIG_arg_fail(1)) SWIG_fail;
3600 }
3601 {
3602 PyThreadState* __tstate = wxPyBeginAllowThreads();
3603 wxRegisterId(arg1);
3604
3605 wxPyEndAllowThreads(__tstate);
3606 if (PyErr_Occurred()) SWIG_fail;
3607 }
3608 Py_INCREF(Py_None); resultobj = Py_None;
3609 return resultobj;
3610 fail:
3611 return NULL;
3612 }
3613
3614
3615 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3616 PyObject *resultobj;
3617 long result;
3618 char *kwnames[] = {
3619 NULL
3620 };
3621
3622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3623 {
3624 PyThreadState* __tstate = wxPyBeginAllowThreads();
3625 result = (long)wxGetCurrentId();
3626
3627 wxPyEndAllowThreads(__tstate);
3628 if (PyErr_Occurred()) SWIG_fail;
3629 }
3630 {
3631 resultobj = SWIG_From_long((long)(result));
3632 }
3633 return resultobj;
3634 fail:
3635 return NULL;
3636 }
3637
3638
3639 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3640 PyObject *resultobj;
3641 int arg1 ;
3642 bool result;
3643 PyObject * obj0 = 0 ;
3644 char *kwnames[] = {
3645 (char *) "id", NULL
3646 };
3647
3648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3649 {
3650 arg1 = (int)(SWIG_As_int(obj0));
3651 if (SWIG_arg_fail(1)) SWIG_fail;
3652 }
3653 {
3654 PyThreadState* __tstate = wxPyBeginAllowThreads();
3655 result = (bool)wxIsStockID(arg1);
3656
3657 wxPyEndAllowThreads(__tstate);
3658 if (PyErr_Occurred()) SWIG_fail;
3659 }
3660 {
3661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3662 }
3663 return resultobj;
3664 fail:
3665 return NULL;
3666 }
3667
3668
3669 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3670 PyObject *resultobj;
3671 int arg1 ;
3672 wxString *arg2 = 0 ;
3673 bool result;
3674 bool temp2 = false ;
3675 PyObject * obj0 = 0 ;
3676 PyObject * obj1 = 0 ;
3677 char *kwnames[] = {
3678 (char *) "id",(char *) "label", NULL
3679 };
3680
3681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3682 {
3683 arg1 = (int)(SWIG_As_int(obj0));
3684 if (SWIG_arg_fail(1)) SWIG_fail;
3685 }
3686 {
3687 arg2 = wxString_in_helper(obj1);
3688 if (arg2 == NULL) SWIG_fail;
3689 temp2 = true;
3690 }
3691 {
3692 PyThreadState* __tstate = wxPyBeginAllowThreads();
3693 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3694
3695 wxPyEndAllowThreads(__tstate);
3696 if (PyErr_Occurred()) SWIG_fail;
3697 }
3698 {
3699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3700 }
3701 {
3702 if (temp2)
3703 delete arg2;
3704 }
3705 return resultobj;
3706 fail:
3707 {
3708 if (temp2)
3709 delete arg2;
3710 }
3711 return NULL;
3712 }
3713
3714
3715 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3716 PyObject *resultobj;
3717 int arg1 ;
3718 bool arg2 = (bool) true ;
3719 wxString arg3 = (wxString) wxPyEmptyString ;
3720 wxString result;
3721 PyObject * obj0 = 0 ;
3722 PyObject * obj1 = 0 ;
3723 PyObject * obj2 = 0 ;
3724 char *kwnames[] = {
3725 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3726 };
3727
3728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3729 {
3730 arg1 = (int)(SWIG_As_int(obj0));
3731 if (SWIG_arg_fail(1)) SWIG_fail;
3732 }
3733 if (obj1) {
3734 {
3735 arg2 = (bool)(SWIG_As_bool(obj1));
3736 if (SWIG_arg_fail(2)) SWIG_fail;
3737 }
3738 }
3739 if (obj2) {
3740 {
3741 wxString* sptr = wxString_in_helper(obj2);
3742 if (sptr == NULL) SWIG_fail;
3743 arg3 = *sptr;
3744 delete sptr;
3745 }
3746 }
3747 {
3748 PyThreadState* __tstate = wxPyBeginAllowThreads();
3749 result = wxGetStockLabel(arg1,arg2,arg3);
3750
3751 wxPyEndAllowThreads(__tstate);
3752 if (PyErr_Occurred()) SWIG_fail;
3753 }
3754 {
3755 #if wxUSE_UNICODE
3756 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3757 #else
3758 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3759 #endif
3760 }
3761 return resultobj;
3762 fail:
3763 return NULL;
3764 }
3765
3766
3767 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3768 PyObject *resultobj;
3769 char *kwnames[] = {
3770 NULL
3771 };
3772
3773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3774 {
3775 if (!wxPyCheckForApp()) SWIG_fail;
3776 PyThreadState* __tstate = wxPyBeginAllowThreads();
3777 wxBell();
3778
3779 wxPyEndAllowThreads(__tstate);
3780 if (PyErr_Occurred()) SWIG_fail;
3781 }
3782 Py_INCREF(Py_None); resultobj = Py_None;
3783 return resultobj;
3784 fail:
3785 return NULL;
3786 }
3787
3788
3789 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3790 PyObject *resultobj;
3791 char *kwnames[] = {
3792 NULL
3793 };
3794
3795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3796 {
3797 if (!wxPyCheckForApp()) SWIG_fail;
3798 PyThreadState* __tstate = wxPyBeginAllowThreads();
3799 wxEndBusyCursor();
3800
3801 wxPyEndAllowThreads(__tstate);
3802 if (PyErr_Occurred()) SWIG_fail;
3803 }
3804 Py_INCREF(Py_None); resultobj = Py_None;
3805 return resultobj;
3806 fail:
3807 return NULL;
3808 }
3809
3810
3811 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3812 PyObject *resultobj;
3813 bool arg1 = (bool) true ;
3814 long result;
3815 PyObject * obj0 = 0 ;
3816 char *kwnames[] = {
3817 (char *) "resetTimer", NULL
3818 };
3819
3820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3821 if (obj0) {
3822 {
3823 arg1 = (bool)(SWIG_As_bool(obj0));
3824 if (SWIG_arg_fail(1)) SWIG_fail;
3825 }
3826 }
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 result = (long)wxGetElapsedTime(arg1);
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 {
3835 resultobj = SWIG_From_long((long)(result));
3836 }
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 int *arg1 = (int *) 0 ;
3846 int *arg2 = (int *) 0 ;
3847 int temp1 ;
3848 int res1 = 0 ;
3849 int temp2 ;
3850 int res2 = 0 ;
3851 char *kwnames[] = {
3852 NULL
3853 };
3854
3855 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3856 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3858 {
3859 if (!wxPyCheckForApp()) SWIG_fail;
3860 PyThreadState* __tstate = wxPyBeginAllowThreads();
3861 wxGetMousePosition(arg1,arg2);
3862
3863 wxPyEndAllowThreads(__tstate);
3864 if (PyErr_Occurred()) SWIG_fail;
3865 }
3866 Py_INCREF(Py_None); resultobj = Py_None;
3867 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3868 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3869 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3870 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3871 return resultobj;
3872 fail:
3873 return NULL;
3874 }
3875
3876
3877 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3878 PyObject *resultobj;
3879 bool result;
3880 char *kwnames[] = {
3881 NULL
3882 };
3883
3884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3885 {
3886 PyThreadState* __tstate = wxPyBeginAllowThreads();
3887 result = (bool)wxIsBusy();
3888
3889 wxPyEndAllowThreads(__tstate);
3890 if (PyErr_Occurred()) SWIG_fail;
3891 }
3892 {
3893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3894 }
3895 return resultobj;
3896 fail:
3897 return NULL;
3898 }
3899
3900
3901 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3902 PyObject *resultobj;
3903 wxString result;
3904 char *kwnames[] = {
3905 NULL
3906 };
3907
3908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3909 {
3910 PyThreadState* __tstate = wxPyBeginAllowThreads();
3911 result = wxNow();
3912
3913 wxPyEndAllowThreads(__tstate);
3914 if (PyErr_Occurred()) SWIG_fail;
3915 }
3916 {
3917 #if wxUSE_UNICODE
3918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3919 #else
3920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3921 #endif
3922 }
3923 return resultobj;
3924 fail:
3925 return NULL;
3926 }
3927
3928
3929 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3930 PyObject *resultobj;
3931 wxString const &arg1_defvalue = wxPyEmptyString ;
3932 wxString *arg1 = (wxString *) &arg1_defvalue ;
3933 bool result;
3934 bool temp1 = false ;
3935 PyObject * obj0 = 0 ;
3936 char *kwnames[] = {
3937 (char *) "command", NULL
3938 };
3939
3940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3941 if (obj0) {
3942 {
3943 arg1 = wxString_in_helper(obj0);
3944 if (arg1 == NULL) SWIG_fail;
3945 temp1 = true;
3946 }
3947 }
3948 {
3949 PyThreadState* __tstate = wxPyBeginAllowThreads();
3950 result = (bool)wxShell((wxString const &)*arg1);
3951
3952 wxPyEndAllowThreads(__tstate);
3953 if (PyErr_Occurred()) SWIG_fail;
3954 }
3955 {
3956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3957 }
3958 {
3959 if (temp1)
3960 delete arg1;
3961 }
3962 return resultobj;
3963 fail:
3964 {
3965 if (temp1)
3966 delete arg1;
3967 }
3968 return NULL;
3969 }
3970
3971
3972 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3973 PyObject *resultobj;
3974 char *kwnames[] = {
3975 NULL
3976 };
3977
3978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3979 {
3980 PyThreadState* __tstate = wxPyBeginAllowThreads();
3981 wxStartTimer();
3982
3983 wxPyEndAllowThreads(__tstate);
3984 if (PyErr_Occurred()) SWIG_fail;
3985 }
3986 Py_INCREF(Py_None); resultobj = Py_None;
3987 return resultobj;
3988 fail:
3989 return NULL;
3990 }
3991
3992
3993 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3994 PyObject *resultobj;
3995 int *arg1 = (int *) 0 ;
3996 int *arg2 = (int *) 0 ;
3997 int result;
3998 int temp1 ;
3999 int res1 = 0 ;
4000 int temp2 ;
4001 int res2 = 0 ;
4002 char *kwnames[] = {
4003 NULL
4004 };
4005
4006 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4007 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4009 {
4010 PyThreadState* __tstate = wxPyBeginAllowThreads();
4011 result = (int)wxGetOsVersion(arg1,arg2);
4012
4013 wxPyEndAllowThreads(__tstate);
4014 if (PyErr_Occurred()) SWIG_fail;
4015 }
4016 {
4017 resultobj = SWIG_From_int((int)(result));
4018 }
4019 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4020 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4021 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4022 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4023 return resultobj;
4024 fail:
4025 return NULL;
4026 }
4027
4028
4029 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4030 PyObject *resultobj;
4031 wxString result;
4032 char *kwnames[] = {
4033 NULL
4034 };
4035
4036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4037 {
4038 PyThreadState* __tstate = wxPyBeginAllowThreads();
4039 result = wxGetOsDescription();
4040
4041 wxPyEndAllowThreads(__tstate);
4042 if (PyErr_Occurred()) SWIG_fail;
4043 }
4044 {
4045 #if wxUSE_UNICODE
4046 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4047 #else
4048 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4049 #endif
4050 }
4051 return resultobj;
4052 fail:
4053 return NULL;
4054 }
4055
4056
4057 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4058 PyObject *resultobj;
4059 long result;
4060 char *kwnames[] = {
4061 NULL
4062 };
4063
4064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4065 {
4066 PyThreadState* __tstate = wxPyBeginAllowThreads();
4067 result = (long)wxGetFreeMemory();
4068
4069 wxPyEndAllowThreads(__tstate);
4070 if (PyErr_Occurred()) SWIG_fail;
4071 }
4072 {
4073 resultobj = SWIG_From_long((long)(result));
4074 }
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj;
4083 wxShutdownFlags arg1 ;
4084 bool result;
4085 PyObject * obj0 = 0 ;
4086 char *kwnames[] = {
4087 (char *) "wFlags", NULL
4088 };
4089
4090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4091 {
4092 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4093 if (SWIG_arg_fail(1)) SWIG_fail;
4094 }
4095 {
4096 if (!wxPyCheckForApp()) SWIG_fail;
4097 PyThreadState* __tstate = wxPyBeginAllowThreads();
4098 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4099
4100 wxPyEndAllowThreads(__tstate);
4101 if (PyErr_Occurred()) SWIG_fail;
4102 }
4103 {
4104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4105 }
4106 return resultobj;
4107 fail:
4108 return NULL;
4109 }
4110
4111
4112 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4113 PyObject *resultobj;
4114 int arg1 ;
4115 PyObject * obj0 = 0 ;
4116 char *kwnames[] = {
4117 (char *) "secs", NULL
4118 };
4119
4120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4121 {
4122 arg1 = (int)(SWIG_As_int(obj0));
4123 if (SWIG_arg_fail(1)) SWIG_fail;
4124 }
4125 {
4126 PyThreadState* __tstate = wxPyBeginAllowThreads();
4127 wxSleep(arg1);
4128
4129 wxPyEndAllowThreads(__tstate);
4130 if (PyErr_Occurred()) SWIG_fail;
4131 }
4132 Py_INCREF(Py_None); resultobj = Py_None;
4133 return resultobj;
4134 fail:
4135 return NULL;
4136 }
4137
4138
4139 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4140 PyObject *resultobj;
4141 unsigned long arg1 ;
4142 PyObject * obj0 = 0 ;
4143 char *kwnames[] = {
4144 (char *) "milliseconds", NULL
4145 };
4146
4147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4148 {
4149 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4150 if (SWIG_arg_fail(1)) SWIG_fail;
4151 }
4152 {
4153 PyThreadState* __tstate = wxPyBeginAllowThreads();
4154 wxMilliSleep(arg1);
4155
4156 wxPyEndAllowThreads(__tstate);
4157 if (PyErr_Occurred()) SWIG_fail;
4158 }
4159 Py_INCREF(Py_None); resultobj = Py_None;
4160 return resultobj;
4161 fail:
4162 return NULL;
4163 }
4164
4165
4166 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4167 PyObject *resultobj;
4168 unsigned long arg1 ;
4169 PyObject * obj0 = 0 ;
4170 char *kwnames[] = {
4171 (char *) "microseconds", NULL
4172 };
4173
4174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4175 {
4176 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4177 if (SWIG_arg_fail(1)) SWIG_fail;
4178 }
4179 {
4180 PyThreadState* __tstate = wxPyBeginAllowThreads();
4181 wxMicroSleep(arg1);
4182
4183 wxPyEndAllowThreads(__tstate);
4184 if (PyErr_Occurred()) SWIG_fail;
4185 }
4186 Py_INCREF(Py_None); resultobj = Py_None;
4187 return resultobj;
4188 fail:
4189 return NULL;
4190 }
4191
4192
4193 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4194 PyObject *resultobj;
4195 bool arg1 ;
4196 PyObject * obj0 = 0 ;
4197 char *kwnames[] = {
4198 (char *) "enable", NULL
4199 };
4200
4201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4202 {
4203 arg1 = (bool)(SWIG_As_bool(obj0));
4204 if (SWIG_arg_fail(1)) SWIG_fail;
4205 }
4206 {
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 wxEnableTopLevelWindows(arg1);
4209
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 Py_INCREF(Py_None); resultobj = Py_None;
4214 return resultobj;
4215 fail:
4216 return NULL;
4217 }
4218
4219
4220 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4221 PyObject *resultobj;
4222 wxString *arg1 = 0 ;
4223 wxString result;
4224 bool temp1 = false ;
4225 PyObject * obj0 = 0 ;
4226 char *kwnames[] = {
4227 (char *) "in", NULL
4228 };
4229
4230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4231 {
4232 arg1 = wxString_in_helper(obj0);
4233 if (arg1 == NULL) SWIG_fail;
4234 temp1 = true;
4235 }
4236 {
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 result = wxStripMenuCodes((wxString const &)*arg1);
4239
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 {
4244 #if wxUSE_UNICODE
4245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4246 #else
4247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4248 #endif
4249 }
4250 {
4251 if (temp1)
4252 delete arg1;
4253 }
4254 return resultobj;
4255 fail:
4256 {
4257 if (temp1)
4258 delete arg1;
4259 }
4260 return NULL;
4261 }
4262
4263
4264 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4265 PyObject *resultobj;
4266 wxString result;
4267 char *kwnames[] = {
4268 NULL
4269 };
4270
4271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4272 {
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 result = wxGetEmailAddress();
4275
4276 wxPyEndAllowThreads(__tstate);
4277 if (PyErr_Occurred()) SWIG_fail;
4278 }
4279 {
4280 #if wxUSE_UNICODE
4281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4282 #else
4283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4284 #endif
4285 }
4286 return resultobj;
4287 fail:
4288 return NULL;
4289 }
4290
4291
4292 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4293 PyObject *resultobj;
4294 wxString result;
4295 char *kwnames[] = {
4296 NULL
4297 };
4298
4299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4300 {
4301 PyThreadState* __tstate = wxPyBeginAllowThreads();
4302 result = wxGetHostName();
4303
4304 wxPyEndAllowThreads(__tstate);
4305 if (PyErr_Occurred()) SWIG_fail;
4306 }
4307 {
4308 #if wxUSE_UNICODE
4309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4310 #else
4311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4312 #endif
4313 }
4314 return resultobj;
4315 fail:
4316 return NULL;
4317 }
4318
4319
4320 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4321 PyObject *resultobj;
4322 wxString result;
4323 char *kwnames[] = {
4324 NULL
4325 };
4326
4327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4328 {
4329 PyThreadState* __tstate = wxPyBeginAllowThreads();
4330 result = wxGetFullHostName();
4331
4332 wxPyEndAllowThreads(__tstate);
4333 if (PyErr_Occurred()) SWIG_fail;
4334 }
4335 {
4336 #if wxUSE_UNICODE
4337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4338 #else
4339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4340 #endif
4341 }
4342 return resultobj;
4343 fail:
4344 return NULL;
4345 }
4346
4347
4348 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4349 PyObject *resultobj;
4350 wxString result;
4351 char *kwnames[] = {
4352 NULL
4353 };
4354
4355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4356 {
4357 PyThreadState* __tstate = wxPyBeginAllowThreads();
4358 result = wxGetUserId();
4359
4360 wxPyEndAllowThreads(__tstate);
4361 if (PyErr_Occurred()) SWIG_fail;
4362 }
4363 {
4364 #if wxUSE_UNICODE
4365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4366 #else
4367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4368 #endif
4369 }
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj;
4378 wxString result;
4379 char *kwnames[] = {
4380 NULL
4381 };
4382
4383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4384 {
4385 PyThreadState* __tstate = wxPyBeginAllowThreads();
4386 result = wxGetUserName();
4387
4388 wxPyEndAllowThreads(__tstate);
4389 if (PyErr_Occurred()) SWIG_fail;
4390 }
4391 {
4392 #if wxUSE_UNICODE
4393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4394 #else
4395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4396 #endif
4397 }
4398 return resultobj;
4399 fail:
4400 return NULL;
4401 }
4402
4403
4404 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4405 PyObject *resultobj;
4406 wxString result;
4407 char *kwnames[] = {
4408 NULL
4409 };
4410
4411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 result = wxGetHomeDir();
4415
4416 wxPyEndAllowThreads(__tstate);
4417 if (PyErr_Occurred()) SWIG_fail;
4418 }
4419 {
4420 #if wxUSE_UNICODE
4421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4422 #else
4423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4424 #endif
4425 }
4426 return resultobj;
4427 fail:
4428 return NULL;
4429 }
4430
4431
4432 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4433 PyObject *resultobj;
4434 wxString const &arg1_defvalue = wxPyEmptyString ;
4435 wxString *arg1 = (wxString *) &arg1_defvalue ;
4436 wxString result;
4437 bool temp1 = false ;
4438 PyObject * obj0 = 0 ;
4439 char *kwnames[] = {
4440 (char *) "user", NULL
4441 };
4442
4443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4444 if (obj0) {
4445 {
4446 arg1 = wxString_in_helper(obj0);
4447 if (arg1 == NULL) SWIG_fail;
4448 temp1 = true;
4449 }
4450 }
4451 {
4452 PyThreadState* __tstate = wxPyBeginAllowThreads();
4453 result = wxGetUserHome((wxString const &)*arg1);
4454
4455 wxPyEndAllowThreads(__tstate);
4456 if (PyErr_Occurred()) SWIG_fail;
4457 }
4458 {
4459 #if wxUSE_UNICODE
4460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4461 #else
4462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4463 #endif
4464 }
4465 {
4466 if (temp1)
4467 delete arg1;
4468 }
4469 return resultobj;
4470 fail:
4471 {
4472 if (temp1)
4473 delete arg1;
4474 }
4475 return NULL;
4476 }
4477
4478
4479 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4480 PyObject *resultobj;
4481 unsigned long result;
4482 char *kwnames[] = {
4483 NULL
4484 };
4485
4486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4487 {
4488 PyThreadState* __tstate = wxPyBeginAllowThreads();
4489 result = (unsigned long)wxGetProcessId();
4490
4491 wxPyEndAllowThreads(__tstate);
4492 if (PyErr_Occurred()) SWIG_fail;
4493 }
4494 {
4495 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4496 }
4497 return resultobj;
4498 fail:
4499 return NULL;
4500 }
4501
4502
4503 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj;
4505 char *kwnames[] = {
4506 NULL
4507 };
4508
4509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4510 {
4511 PyThreadState* __tstate = wxPyBeginAllowThreads();
4512 wxTrap();
4513
4514 wxPyEndAllowThreads(__tstate);
4515 if (PyErr_Occurred()) SWIG_fail;
4516 }
4517 Py_INCREF(Py_None); resultobj = Py_None;
4518 return resultobj;
4519 fail:
4520 return NULL;
4521 }
4522
4523
4524 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4525 PyObject *resultobj;
4526 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4527 wxString *arg1 = (wxString *) &arg1_defvalue ;
4528 wxString const &arg2_defvalue = wxPyEmptyString ;
4529 wxString *arg2 = (wxString *) &arg2_defvalue ;
4530 wxString const &arg3_defvalue = wxPyEmptyString ;
4531 wxString *arg3 = (wxString *) &arg3_defvalue ;
4532 wxString const &arg4_defvalue = wxPyEmptyString ;
4533 wxString *arg4 = (wxString *) &arg4_defvalue ;
4534 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4535 wxString *arg5 = (wxString *) &arg5_defvalue ;
4536 int arg6 = (int) 0 ;
4537 wxWindow *arg7 = (wxWindow *) NULL ;
4538 int arg8 = (int) -1 ;
4539 int arg9 = (int) -1 ;
4540 wxString result;
4541 bool temp1 = false ;
4542 bool temp2 = false ;
4543 bool temp3 = false ;
4544 bool temp4 = false ;
4545 bool temp5 = false ;
4546 PyObject * obj0 = 0 ;
4547 PyObject * obj1 = 0 ;
4548 PyObject * obj2 = 0 ;
4549 PyObject * obj3 = 0 ;
4550 PyObject * obj4 = 0 ;
4551 PyObject * obj5 = 0 ;
4552 PyObject * obj6 = 0 ;
4553 PyObject * obj7 = 0 ;
4554 PyObject * obj8 = 0 ;
4555 char *kwnames[] = {
4556 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4557 };
4558
4559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4560 if (obj0) {
4561 {
4562 arg1 = wxString_in_helper(obj0);
4563 if (arg1 == NULL) SWIG_fail;
4564 temp1 = true;
4565 }
4566 }
4567 if (obj1) {
4568 {
4569 arg2 = wxString_in_helper(obj1);
4570 if (arg2 == NULL) SWIG_fail;
4571 temp2 = true;
4572 }
4573 }
4574 if (obj2) {
4575 {
4576 arg3 = wxString_in_helper(obj2);
4577 if (arg3 == NULL) SWIG_fail;
4578 temp3 = true;
4579 }
4580 }
4581 if (obj3) {
4582 {
4583 arg4 = wxString_in_helper(obj3);
4584 if (arg4 == NULL) SWIG_fail;
4585 temp4 = true;
4586 }
4587 }
4588 if (obj4) {
4589 {
4590 arg5 = wxString_in_helper(obj4);
4591 if (arg5 == NULL) SWIG_fail;
4592 temp5 = true;
4593 }
4594 }
4595 if (obj5) {
4596 {
4597 arg6 = (int)(SWIG_As_int(obj5));
4598 if (SWIG_arg_fail(6)) SWIG_fail;
4599 }
4600 }
4601 if (obj6) {
4602 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4603 if (SWIG_arg_fail(7)) SWIG_fail;
4604 }
4605 if (obj7) {
4606 {
4607 arg8 = (int)(SWIG_As_int(obj7));
4608 if (SWIG_arg_fail(8)) SWIG_fail;
4609 }
4610 }
4611 if (obj8) {
4612 {
4613 arg9 = (int)(SWIG_As_int(obj8));
4614 if (SWIG_arg_fail(9)) SWIG_fail;
4615 }
4616 }
4617 {
4618 if (!wxPyCheckForApp()) SWIG_fail;
4619 PyThreadState* __tstate = wxPyBeginAllowThreads();
4620 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4621
4622 wxPyEndAllowThreads(__tstate);
4623 if (PyErr_Occurred()) SWIG_fail;
4624 }
4625 {
4626 #if wxUSE_UNICODE
4627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4628 #else
4629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4630 #endif
4631 }
4632 {
4633 if (temp1)
4634 delete arg1;
4635 }
4636 {
4637 if (temp2)
4638 delete arg2;
4639 }
4640 {
4641 if (temp3)
4642 delete arg3;
4643 }
4644 {
4645 if (temp4)
4646 delete arg4;
4647 }
4648 {
4649 if (temp5)
4650 delete arg5;
4651 }
4652 return resultobj;
4653 fail:
4654 {
4655 if (temp1)
4656 delete arg1;
4657 }
4658 {
4659 if (temp2)
4660 delete arg2;
4661 }
4662 {
4663 if (temp3)
4664 delete arg3;
4665 }
4666 {
4667 if (temp4)
4668 delete arg4;
4669 }
4670 {
4671 if (temp5)
4672 delete arg5;
4673 }
4674 return NULL;
4675 }
4676
4677
4678 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4679 PyObject *resultobj;
4680 wxString *arg1 = 0 ;
4681 wxString *arg2 = 0 ;
4682 wxString const &arg3_defvalue = wxPyEmptyString ;
4683 wxString *arg3 = (wxString *) &arg3_defvalue ;
4684 wxWindow *arg4 = (wxWindow *) NULL ;
4685 wxString result;
4686 bool temp1 = false ;
4687 bool temp2 = false ;
4688 bool temp3 = false ;
4689 PyObject * obj0 = 0 ;
4690 PyObject * obj1 = 0 ;
4691 PyObject * obj2 = 0 ;
4692 PyObject * obj3 = 0 ;
4693 char *kwnames[] = {
4694 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4695 };
4696
4697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4698 {
4699 arg1 = wxString_in_helper(obj0);
4700 if (arg1 == NULL) SWIG_fail;
4701 temp1 = true;
4702 }
4703 {
4704 arg2 = wxString_in_helper(obj1);
4705 if (arg2 == NULL) SWIG_fail;
4706 temp2 = true;
4707 }
4708 if (obj2) {
4709 {
4710 arg3 = wxString_in_helper(obj2);
4711 if (arg3 == NULL) SWIG_fail;
4712 temp3 = true;
4713 }
4714 }
4715 if (obj3) {
4716 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4717 if (SWIG_arg_fail(4)) SWIG_fail;
4718 }
4719 {
4720 if (!wxPyCheckForApp()) SWIG_fail;
4721 PyThreadState* __tstate = wxPyBeginAllowThreads();
4722 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4723
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 {
4728 #if wxUSE_UNICODE
4729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4730 #else
4731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4732 #endif
4733 }
4734 {
4735 if (temp1)
4736 delete arg1;
4737 }
4738 {
4739 if (temp2)
4740 delete arg2;
4741 }
4742 {
4743 if (temp3)
4744 delete arg3;
4745 }
4746 return resultobj;
4747 fail:
4748 {
4749 if (temp1)
4750 delete arg1;
4751 }
4752 {
4753 if (temp2)
4754 delete arg2;
4755 }
4756 {
4757 if (temp3)
4758 delete arg3;
4759 }
4760 return NULL;
4761 }
4762
4763
4764 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4765 PyObject *resultobj;
4766 wxString *arg1 = 0 ;
4767 wxString *arg2 = 0 ;
4768 wxString const &arg3_defvalue = wxPyEmptyString ;
4769 wxString *arg3 = (wxString *) &arg3_defvalue ;
4770 wxWindow *arg4 = (wxWindow *) NULL ;
4771 wxString result;
4772 bool temp1 = false ;
4773 bool temp2 = false ;
4774 bool temp3 = false ;
4775 PyObject * obj0 = 0 ;
4776 PyObject * obj1 = 0 ;
4777 PyObject * obj2 = 0 ;
4778 PyObject * obj3 = 0 ;
4779 char *kwnames[] = {
4780 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4781 };
4782
4783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4784 {
4785 arg1 = wxString_in_helper(obj0);
4786 if (arg1 == NULL) SWIG_fail;
4787 temp1 = true;
4788 }
4789 {
4790 arg2 = wxString_in_helper(obj1);
4791 if (arg2 == NULL) SWIG_fail;
4792 temp2 = true;
4793 }
4794 if (obj2) {
4795 {
4796 arg3 = wxString_in_helper(obj2);
4797 if (arg3 == NULL) SWIG_fail;
4798 temp3 = true;
4799 }
4800 }
4801 if (obj3) {
4802 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4803 if (SWIG_arg_fail(4)) SWIG_fail;
4804 }
4805 {
4806 if (!wxPyCheckForApp()) SWIG_fail;
4807 PyThreadState* __tstate = wxPyBeginAllowThreads();
4808 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4809
4810 wxPyEndAllowThreads(__tstate);
4811 if (PyErr_Occurred()) SWIG_fail;
4812 }
4813 {
4814 #if wxUSE_UNICODE
4815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4816 #else
4817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4818 #endif
4819 }
4820 {
4821 if (temp1)
4822 delete arg1;
4823 }
4824 {
4825 if (temp2)
4826 delete arg2;
4827 }
4828 {
4829 if (temp3)
4830 delete arg3;
4831 }
4832 return resultobj;
4833 fail:
4834 {
4835 if (temp1)
4836 delete arg1;
4837 }
4838 {
4839 if (temp2)
4840 delete arg2;
4841 }
4842 {
4843 if (temp3)
4844 delete arg3;
4845 }
4846 return NULL;
4847 }
4848
4849
4850 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4851 PyObject *resultobj;
4852 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4853 wxString *arg1 = (wxString *) &arg1_defvalue ;
4854 wxString const &arg2_defvalue = wxPyEmptyString ;
4855 wxString *arg2 = (wxString *) &arg2_defvalue ;
4856 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4857 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4858 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4859 wxWindow *arg5 = (wxWindow *) NULL ;
4860 wxString result;
4861 bool temp1 = false ;
4862 bool temp2 = false ;
4863 wxPoint temp4 ;
4864 PyObject * obj0 = 0 ;
4865 PyObject * obj1 = 0 ;
4866 PyObject * obj2 = 0 ;
4867 PyObject * obj3 = 0 ;
4868 PyObject * obj4 = 0 ;
4869 char *kwnames[] = {
4870 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4871 };
4872
4873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4874 if (obj0) {
4875 {
4876 arg1 = wxString_in_helper(obj0);
4877 if (arg1 == NULL) SWIG_fail;
4878 temp1 = true;
4879 }
4880 }
4881 if (obj1) {
4882 {
4883 arg2 = wxString_in_helper(obj1);
4884 if (arg2 == NULL) SWIG_fail;
4885 temp2 = true;
4886 }
4887 }
4888 if (obj2) {
4889 {
4890 arg3 = (long)(SWIG_As_long(obj2));
4891 if (SWIG_arg_fail(3)) SWIG_fail;
4892 }
4893 }
4894 if (obj3) {
4895 {
4896 arg4 = &temp4;
4897 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4898 }
4899 }
4900 if (obj4) {
4901 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4902 if (SWIG_arg_fail(5)) SWIG_fail;
4903 }
4904 {
4905 if (!wxPyCheckForApp()) SWIG_fail;
4906 PyThreadState* __tstate = wxPyBeginAllowThreads();
4907 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4908
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 {
4913 #if wxUSE_UNICODE
4914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4915 #else
4916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4917 #endif
4918 }
4919 {
4920 if (temp1)
4921 delete arg1;
4922 }
4923 {
4924 if (temp2)
4925 delete arg2;
4926 }
4927 return resultobj;
4928 fail:
4929 {
4930 if (temp1)
4931 delete arg1;
4932 }
4933 {
4934 if (temp2)
4935 delete arg2;
4936 }
4937 return NULL;
4938 }
4939
4940
4941 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4942 PyObject *resultobj;
4943 wxString *arg1 = 0 ;
4944 wxString const &arg2_defvalue = wxPyEmptyString ;
4945 wxString *arg2 = (wxString *) &arg2_defvalue ;
4946 wxString const &arg3_defvalue = wxPyEmptyString ;
4947 wxString *arg3 = (wxString *) &arg3_defvalue ;
4948 wxWindow *arg4 = (wxWindow *) NULL ;
4949 int arg5 = (int) -1 ;
4950 int arg6 = (int) -1 ;
4951 bool arg7 = (bool) true ;
4952 wxString result;
4953 bool temp1 = false ;
4954 bool temp2 = false ;
4955 bool temp3 = false ;
4956 PyObject * obj0 = 0 ;
4957 PyObject * obj1 = 0 ;
4958 PyObject * obj2 = 0 ;
4959 PyObject * obj3 = 0 ;
4960 PyObject * obj4 = 0 ;
4961 PyObject * obj5 = 0 ;
4962 PyObject * obj6 = 0 ;
4963 char *kwnames[] = {
4964 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4965 };
4966
4967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4968 {
4969 arg1 = wxString_in_helper(obj0);
4970 if (arg1 == NULL) SWIG_fail;
4971 temp1 = true;
4972 }
4973 if (obj1) {
4974 {
4975 arg2 = wxString_in_helper(obj1);
4976 if (arg2 == NULL) SWIG_fail;
4977 temp2 = true;
4978 }
4979 }
4980 if (obj2) {
4981 {
4982 arg3 = wxString_in_helper(obj2);
4983 if (arg3 == NULL) SWIG_fail;
4984 temp3 = true;
4985 }
4986 }
4987 if (obj3) {
4988 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4989 if (SWIG_arg_fail(4)) SWIG_fail;
4990 }
4991 if (obj4) {
4992 {
4993 arg5 = (int)(SWIG_As_int(obj4));
4994 if (SWIG_arg_fail(5)) SWIG_fail;
4995 }
4996 }
4997 if (obj5) {
4998 {
4999 arg6 = (int)(SWIG_As_int(obj5));
5000 if (SWIG_arg_fail(6)) SWIG_fail;
5001 }
5002 }
5003 if (obj6) {
5004 {
5005 arg7 = (bool)(SWIG_As_bool(obj6));
5006 if (SWIG_arg_fail(7)) SWIG_fail;
5007 }
5008 }
5009 {
5010 if (!wxPyCheckForApp()) SWIG_fail;
5011 PyThreadState* __tstate = wxPyBeginAllowThreads();
5012 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5013
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 {
5018 #if wxUSE_UNICODE
5019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5020 #else
5021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5022 #endif
5023 }
5024 {
5025 if (temp1)
5026 delete arg1;
5027 }
5028 {
5029 if (temp2)
5030 delete arg2;
5031 }
5032 {
5033 if (temp3)
5034 delete arg3;
5035 }
5036 return resultobj;
5037 fail:
5038 {
5039 if (temp1)
5040 delete arg1;
5041 }
5042 {
5043 if (temp2)
5044 delete arg2;
5045 }
5046 {
5047 if (temp3)
5048 delete arg3;
5049 }
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj;
5056 wxString *arg1 = 0 ;
5057 wxString const &arg2_defvalue = wxPyEmptyString ;
5058 wxString *arg2 = (wxString *) &arg2_defvalue ;
5059 wxString const &arg3_defvalue = wxPyEmptyString ;
5060 wxString *arg3 = (wxString *) &arg3_defvalue ;
5061 wxWindow *arg4 = (wxWindow *) NULL ;
5062 wxString result;
5063 bool temp1 = false ;
5064 bool temp2 = false ;
5065 bool temp3 = false ;
5066 PyObject * obj0 = 0 ;
5067 PyObject * obj1 = 0 ;
5068 PyObject * obj2 = 0 ;
5069 PyObject * obj3 = 0 ;
5070 char *kwnames[] = {
5071 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5072 };
5073
5074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5075 {
5076 arg1 = wxString_in_helper(obj0);
5077 if (arg1 == NULL) SWIG_fail;
5078 temp1 = true;
5079 }
5080 if (obj1) {
5081 {
5082 arg2 = wxString_in_helper(obj1);
5083 if (arg2 == NULL) SWIG_fail;
5084 temp2 = true;
5085 }
5086 }
5087 if (obj2) {
5088 {
5089 arg3 = wxString_in_helper(obj2);
5090 if (arg3 == NULL) SWIG_fail;
5091 temp3 = true;
5092 }
5093 }
5094 if (obj3) {
5095 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5096 if (SWIG_arg_fail(4)) SWIG_fail;
5097 }
5098 {
5099 if (!wxPyCheckForApp()) SWIG_fail;
5100 PyThreadState* __tstate = wxPyBeginAllowThreads();
5101 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5102
5103 wxPyEndAllowThreads(__tstate);
5104 if (PyErr_Occurred()) SWIG_fail;
5105 }
5106 {
5107 #if wxUSE_UNICODE
5108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5109 #else
5110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5111 #endif
5112 }
5113 {
5114 if (temp1)
5115 delete arg1;
5116 }
5117 {
5118 if (temp2)
5119 delete arg2;
5120 }
5121 {
5122 if (temp3)
5123 delete arg3;
5124 }
5125 return resultobj;
5126 fail:
5127 {
5128 if (temp1)
5129 delete arg1;
5130 }
5131 {
5132 if (temp2)
5133 delete arg2;
5134 }
5135 {
5136 if (temp3)
5137 delete arg3;
5138 }
5139 return NULL;
5140 }
5141
5142
5143 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj;
5145 wxString *arg1 = 0 ;
5146 wxString *arg2 = 0 ;
5147 int arg3 ;
5148 wxString *arg4 = (wxString *) 0 ;
5149 wxWindow *arg5 = (wxWindow *) NULL ;
5150 int arg6 = (int) -1 ;
5151 int arg7 = (int) -1 ;
5152 bool arg8 = (bool) true ;
5153 int arg9 = (int) 150 ;
5154 int arg10 = (int) 200 ;
5155 wxString result;
5156 bool temp1 = false ;
5157 bool temp2 = false ;
5158 PyObject * obj0 = 0 ;
5159 PyObject * obj1 = 0 ;
5160 PyObject * obj2 = 0 ;
5161 PyObject * obj3 = 0 ;
5162 PyObject * obj4 = 0 ;
5163 PyObject * obj5 = 0 ;
5164 PyObject * obj6 = 0 ;
5165 PyObject * obj7 = 0 ;
5166 PyObject * obj8 = 0 ;
5167 char *kwnames[] = {
5168 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5169 };
5170
5171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5172 {
5173 arg1 = wxString_in_helper(obj0);
5174 if (arg1 == NULL) SWIG_fail;
5175 temp1 = true;
5176 }
5177 {
5178 arg2 = wxString_in_helper(obj1);
5179 if (arg2 == NULL) SWIG_fail;
5180 temp2 = true;
5181 }
5182 {
5183 arg3 = PyList_Size(obj2);
5184 arg4 = wxString_LIST_helper(obj2);
5185 if (arg4 == NULL) SWIG_fail;
5186 }
5187 if (obj3) {
5188 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5189 if (SWIG_arg_fail(5)) SWIG_fail;
5190 }
5191 if (obj4) {
5192 {
5193 arg6 = (int)(SWIG_As_int(obj4));
5194 if (SWIG_arg_fail(6)) SWIG_fail;
5195 }
5196 }
5197 if (obj5) {
5198 {
5199 arg7 = (int)(SWIG_As_int(obj5));
5200 if (SWIG_arg_fail(7)) SWIG_fail;
5201 }
5202 }
5203 if (obj6) {
5204 {
5205 arg8 = (bool)(SWIG_As_bool(obj6));
5206 if (SWIG_arg_fail(8)) SWIG_fail;
5207 }
5208 }
5209 if (obj7) {
5210 {
5211 arg9 = (int)(SWIG_As_int(obj7));
5212 if (SWIG_arg_fail(9)) SWIG_fail;
5213 }
5214 }
5215 if (obj8) {
5216 {
5217 arg10 = (int)(SWIG_As_int(obj8));
5218 if (SWIG_arg_fail(10)) SWIG_fail;
5219 }
5220 }
5221 {
5222 if (!wxPyCheckForApp()) SWIG_fail;
5223 PyThreadState* __tstate = wxPyBeginAllowThreads();
5224 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5225
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 {
5230 #if wxUSE_UNICODE
5231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5232 #else
5233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5234 #endif
5235 }
5236 {
5237 if (temp1)
5238 delete arg1;
5239 }
5240 {
5241 if (temp2)
5242 delete arg2;
5243 }
5244 {
5245 if (arg4) delete [] arg4;
5246 }
5247 return resultobj;
5248 fail:
5249 {
5250 if (temp1)
5251 delete arg1;
5252 }
5253 {
5254 if (temp2)
5255 delete arg2;
5256 }
5257 {
5258 if (arg4) delete [] arg4;
5259 }
5260 return NULL;
5261 }
5262
5263
5264 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5265 PyObject *resultobj;
5266 wxString *arg1 = 0 ;
5267 wxString *arg2 = 0 ;
5268 int arg3 ;
5269 wxString *arg4 = (wxString *) 0 ;
5270 wxWindow *arg5 = (wxWindow *) NULL ;
5271 int arg6 = (int) -1 ;
5272 int arg7 = (int) -1 ;
5273 bool arg8 = (bool) true ;
5274 int arg9 = (int) 150 ;
5275 int arg10 = (int) 200 ;
5276 int result;
5277 bool temp1 = false ;
5278 bool temp2 = false ;
5279 PyObject * obj0 = 0 ;
5280 PyObject * obj1 = 0 ;
5281 PyObject * obj2 = 0 ;
5282 PyObject * obj3 = 0 ;
5283 PyObject * obj4 = 0 ;
5284 PyObject * obj5 = 0 ;
5285 PyObject * obj6 = 0 ;
5286 PyObject * obj7 = 0 ;
5287 PyObject * obj8 = 0 ;
5288 char *kwnames[] = {
5289 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5290 };
5291
5292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5293 {
5294 arg1 = wxString_in_helper(obj0);
5295 if (arg1 == NULL) SWIG_fail;
5296 temp1 = true;
5297 }
5298 {
5299 arg2 = wxString_in_helper(obj1);
5300 if (arg2 == NULL) SWIG_fail;
5301 temp2 = true;
5302 }
5303 {
5304 arg3 = PyList_Size(obj2);
5305 arg4 = wxString_LIST_helper(obj2);
5306 if (arg4 == NULL) SWIG_fail;
5307 }
5308 if (obj3) {
5309 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5310 if (SWIG_arg_fail(5)) SWIG_fail;
5311 }
5312 if (obj4) {
5313 {
5314 arg6 = (int)(SWIG_As_int(obj4));
5315 if (SWIG_arg_fail(6)) SWIG_fail;
5316 }
5317 }
5318 if (obj5) {
5319 {
5320 arg7 = (int)(SWIG_As_int(obj5));
5321 if (SWIG_arg_fail(7)) SWIG_fail;
5322 }
5323 }
5324 if (obj6) {
5325 {
5326 arg8 = (bool)(SWIG_As_bool(obj6));
5327 if (SWIG_arg_fail(8)) SWIG_fail;
5328 }
5329 }
5330 if (obj7) {
5331 {
5332 arg9 = (int)(SWIG_As_int(obj7));
5333 if (SWIG_arg_fail(9)) SWIG_fail;
5334 }
5335 }
5336 if (obj8) {
5337 {
5338 arg10 = (int)(SWIG_As_int(obj8));
5339 if (SWIG_arg_fail(10)) SWIG_fail;
5340 }
5341 }
5342 {
5343 if (!wxPyCheckForApp()) SWIG_fail;
5344 PyThreadState* __tstate = wxPyBeginAllowThreads();
5345 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5346
5347 wxPyEndAllowThreads(__tstate);
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 {
5351 resultobj = SWIG_From_int((int)(result));
5352 }
5353 {
5354 if (temp1)
5355 delete arg1;
5356 }
5357 {
5358 if (temp2)
5359 delete arg2;
5360 }
5361 {
5362 if (arg4) delete [] arg4;
5363 }
5364 return resultobj;
5365 fail:
5366 {
5367 if (temp1)
5368 delete arg1;
5369 }
5370 {
5371 if (temp2)
5372 delete arg2;
5373 }
5374 {
5375 if (arg4) delete [] arg4;
5376 }
5377 return NULL;
5378 }
5379
5380
5381 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5382 PyObject *resultobj;
5383 wxString *arg1 = 0 ;
5384 wxString const &arg2_defvalue = wxPyEmptyString ;
5385 wxString *arg2 = (wxString *) &arg2_defvalue ;
5386 int arg3 = (int) wxOK|wxCENTRE ;
5387 wxWindow *arg4 = (wxWindow *) NULL ;
5388 int arg5 = (int) -1 ;
5389 int arg6 = (int) -1 ;
5390 int result;
5391 bool temp1 = false ;
5392 bool temp2 = false ;
5393 PyObject * obj0 = 0 ;
5394 PyObject * obj1 = 0 ;
5395 PyObject * obj2 = 0 ;
5396 PyObject * obj3 = 0 ;
5397 PyObject * obj4 = 0 ;
5398 PyObject * obj5 = 0 ;
5399 char *kwnames[] = {
5400 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5401 };
5402
5403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5404 {
5405 arg1 = wxString_in_helper(obj0);
5406 if (arg1 == NULL) SWIG_fail;
5407 temp1 = true;
5408 }
5409 if (obj1) {
5410 {
5411 arg2 = wxString_in_helper(obj1);
5412 if (arg2 == NULL) SWIG_fail;
5413 temp2 = true;
5414 }
5415 }
5416 if (obj2) {
5417 {
5418 arg3 = (int)(SWIG_As_int(obj2));
5419 if (SWIG_arg_fail(3)) SWIG_fail;
5420 }
5421 }
5422 if (obj3) {
5423 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5424 if (SWIG_arg_fail(4)) SWIG_fail;
5425 }
5426 if (obj4) {
5427 {
5428 arg5 = (int)(SWIG_As_int(obj4));
5429 if (SWIG_arg_fail(5)) SWIG_fail;
5430 }
5431 }
5432 if (obj5) {
5433 {
5434 arg6 = (int)(SWIG_As_int(obj5));
5435 if (SWIG_arg_fail(6)) SWIG_fail;
5436 }
5437 }
5438 {
5439 if (!wxPyCheckForApp()) SWIG_fail;
5440 PyThreadState* __tstate = wxPyBeginAllowThreads();
5441 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5442
5443 wxPyEndAllowThreads(__tstate);
5444 if (PyErr_Occurred()) SWIG_fail;
5445 }
5446 {
5447 resultobj = SWIG_From_int((int)(result));
5448 }
5449 {
5450 if (temp1)
5451 delete arg1;
5452 }
5453 {
5454 if (temp2)
5455 delete arg2;
5456 }
5457 return resultobj;
5458 fail:
5459 {
5460 if (temp1)
5461 delete arg1;
5462 }
5463 {
5464 if (temp2)
5465 delete arg2;
5466 }
5467 return NULL;
5468 }
5469
5470
5471 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5472 PyObject *resultobj;
5473 wxString *arg1 = 0 ;
5474 wxString *arg2 = 0 ;
5475 wxString *arg3 = 0 ;
5476 long arg4 ;
5477 long arg5 = (long) 0 ;
5478 long arg6 = (long) 100 ;
5479 wxWindow *arg7 = (wxWindow *) NULL ;
5480 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5481 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5482 long result;
5483 bool temp1 = false ;
5484 bool temp2 = false ;
5485 bool temp3 = false ;
5486 wxPoint temp8 ;
5487 PyObject * obj0 = 0 ;
5488 PyObject * obj1 = 0 ;
5489 PyObject * obj2 = 0 ;
5490 PyObject * obj3 = 0 ;
5491 PyObject * obj4 = 0 ;
5492 PyObject * obj5 = 0 ;
5493 PyObject * obj6 = 0 ;
5494 PyObject * obj7 = 0 ;
5495 char *kwnames[] = {
5496 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5497 };
5498
5499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5500 {
5501 arg1 = wxString_in_helper(obj0);
5502 if (arg1 == NULL) SWIG_fail;
5503 temp1 = true;
5504 }
5505 {
5506 arg2 = wxString_in_helper(obj1);
5507 if (arg2 == NULL) SWIG_fail;
5508 temp2 = true;
5509 }
5510 {
5511 arg3 = wxString_in_helper(obj2);
5512 if (arg3 == NULL) SWIG_fail;
5513 temp3 = true;
5514 }
5515 {
5516 arg4 = (long)(SWIG_As_long(obj3));
5517 if (SWIG_arg_fail(4)) SWIG_fail;
5518 }
5519 if (obj4) {
5520 {
5521 arg5 = (long)(SWIG_As_long(obj4));
5522 if (SWIG_arg_fail(5)) SWIG_fail;
5523 }
5524 }
5525 if (obj5) {
5526 {
5527 arg6 = (long)(SWIG_As_long(obj5));
5528 if (SWIG_arg_fail(6)) SWIG_fail;
5529 }
5530 }
5531 if (obj6) {
5532 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5533 if (SWIG_arg_fail(7)) SWIG_fail;
5534 }
5535 if (obj7) {
5536 {
5537 arg8 = &temp8;
5538 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5539 }
5540 }
5541 {
5542 if (!wxPyCheckForApp()) SWIG_fail;
5543 PyThreadState* __tstate = wxPyBeginAllowThreads();
5544 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5545
5546 wxPyEndAllowThreads(__tstate);
5547 if (PyErr_Occurred()) SWIG_fail;
5548 }
5549 {
5550 resultobj = SWIG_From_long((long)(result));
5551 }
5552 {
5553 if (temp1)
5554 delete arg1;
5555 }
5556 {
5557 if (temp2)
5558 delete arg2;
5559 }
5560 {
5561 if (temp3)
5562 delete arg3;
5563 }
5564 return resultobj;
5565 fail:
5566 {
5567 if (temp1)
5568 delete arg1;
5569 }
5570 {
5571 if (temp2)
5572 delete arg2;
5573 }
5574 {
5575 if (temp3)
5576 delete arg3;
5577 }
5578 return NULL;
5579 }
5580
5581
5582 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5583 PyObject *resultobj;
5584 bool result;
5585 char *kwnames[] = {
5586 NULL
5587 };
5588
5589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5590 {
5591 if (!wxPyCheckForApp()) SWIG_fail;
5592 PyThreadState* __tstate = wxPyBeginAllowThreads();
5593 result = (bool)wxColourDisplay();
5594
5595 wxPyEndAllowThreads(__tstate);
5596 if (PyErr_Occurred()) SWIG_fail;
5597 }
5598 {
5599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5600 }
5601 return resultobj;
5602 fail:
5603 return NULL;
5604 }
5605
5606
5607 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5608 PyObject *resultobj;
5609 int result;
5610 char *kwnames[] = {
5611 NULL
5612 };
5613
5614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5615 {
5616 if (!wxPyCheckForApp()) SWIG_fail;
5617 PyThreadState* __tstate = wxPyBeginAllowThreads();
5618 result = (int)wxDisplayDepth();
5619
5620 wxPyEndAllowThreads(__tstate);
5621 if (PyErr_Occurred()) SWIG_fail;
5622 }
5623 {
5624 resultobj = SWIG_From_int((int)(result));
5625 }
5626 return resultobj;
5627 fail:
5628 return NULL;
5629 }
5630
5631
5632 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5633 PyObject *resultobj;
5634 int result;
5635 char *kwnames[] = {
5636 NULL
5637 };
5638
5639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5640 {
5641 if (!wxPyCheckForApp()) SWIG_fail;
5642 PyThreadState* __tstate = wxPyBeginAllowThreads();
5643 result = (int)wxGetDisplayDepth();
5644
5645 wxPyEndAllowThreads(__tstate);
5646 if (PyErr_Occurred()) SWIG_fail;
5647 }
5648 {
5649 resultobj = SWIG_From_int((int)(result));
5650 }
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj;
5659 int *arg1 = (int *) 0 ;
5660 int *arg2 = (int *) 0 ;
5661 int temp1 ;
5662 int res1 = 0 ;
5663 int temp2 ;
5664 int res2 = 0 ;
5665 char *kwnames[] = {
5666 NULL
5667 };
5668
5669 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5670 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5672 {
5673 if (!wxPyCheckForApp()) SWIG_fail;
5674 PyThreadState* __tstate = wxPyBeginAllowThreads();
5675 wxDisplaySize(arg1,arg2);
5676
5677 wxPyEndAllowThreads(__tstate);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 Py_INCREF(Py_None); resultobj = Py_None;
5681 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5682 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5683 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5684 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5685 return resultobj;
5686 fail:
5687 return NULL;
5688 }
5689
5690
5691 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5692 PyObject *resultobj;
5693 wxSize result;
5694 char *kwnames[] = {
5695 NULL
5696 };
5697
5698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5699 {
5700 if (!wxPyCheckForApp()) SWIG_fail;
5701 PyThreadState* __tstate = wxPyBeginAllowThreads();
5702 result = wxGetDisplaySize();
5703
5704 wxPyEndAllowThreads(__tstate);
5705 if (PyErr_Occurred()) SWIG_fail;
5706 }
5707 {
5708 wxSize * resultptr;
5709 resultptr = new wxSize((wxSize &)(result));
5710 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5711 }
5712 return resultobj;
5713 fail:
5714 return NULL;
5715 }
5716
5717
5718 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5719 PyObject *resultobj;
5720 int *arg1 = (int *) 0 ;
5721 int *arg2 = (int *) 0 ;
5722 int temp1 ;
5723 int res1 = 0 ;
5724 int temp2 ;
5725 int res2 = 0 ;
5726 char *kwnames[] = {
5727 NULL
5728 };
5729
5730 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5731 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5733 {
5734 if (!wxPyCheckForApp()) SWIG_fail;
5735 PyThreadState* __tstate = wxPyBeginAllowThreads();
5736 wxDisplaySizeMM(arg1,arg2);
5737
5738 wxPyEndAllowThreads(__tstate);
5739 if (PyErr_Occurred()) SWIG_fail;
5740 }
5741 Py_INCREF(Py_None); resultobj = Py_None;
5742 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5743 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5744 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5745 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj;
5754 wxSize result;
5755 char *kwnames[] = {
5756 NULL
5757 };
5758
5759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5760 {
5761 if (!wxPyCheckForApp()) SWIG_fail;
5762 PyThreadState* __tstate = wxPyBeginAllowThreads();
5763 result = wxGetDisplaySizeMM();
5764
5765 wxPyEndAllowThreads(__tstate);
5766 if (PyErr_Occurred()) SWIG_fail;
5767 }
5768 {
5769 wxSize * resultptr;
5770 resultptr = new wxSize((wxSize &)(result));
5771 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5772 }
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj;
5781 int *arg1 = (int *) 0 ;
5782 int *arg2 = (int *) 0 ;
5783 int *arg3 = (int *) 0 ;
5784 int *arg4 = (int *) 0 ;
5785 int temp1 ;
5786 int res1 = 0 ;
5787 int temp2 ;
5788 int res2 = 0 ;
5789 int temp3 ;
5790 int res3 = 0 ;
5791 int temp4 ;
5792 int res4 = 0 ;
5793 char *kwnames[] = {
5794 NULL
5795 };
5796
5797 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5798 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5799 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5800 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5802 {
5803 if (!wxPyCheckForApp()) SWIG_fail;
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5806
5807 wxPyEndAllowThreads(__tstate);
5808 if (PyErr_Occurred()) SWIG_fail;
5809 }
5810 Py_INCREF(Py_None); resultobj = Py_None;
5811 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5812 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5813 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5814 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5815 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5816 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5817 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5818 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5819 return resultobj;
5820 fail:
5821 return NULL;
5822 }
5823
5824
5825 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5826 PyObject *resultobj;
5827 wxRect result;
5828 char *kwnames[] = {
5829 NULL
5830 };
5831
5832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5833 {
5834 if (!wxPyCheckForApp()) SWIG_fail;
5835 PyThreadState* __tstate = wxPyBeginAllowThreads();
5836 result = wxGetClientDisplayRect();
5837
5838 wxPyEndAllowThreads(__tstate);
5839 if (PyErr_Occurred()) SWIG_fail;
5840 }
5841 {
5842 wxRect * resultptr;
5843 resultptr = new wxRect((wxRect &)(result));
5844 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5845 }
5846 return resultobj;
5847 fail:
5848 return NULL;
5849 }
5850
5851
5852 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5853 PyObject *resultobj;
5854 wxCursor *arg1 = 0 ;
5855 PyObject * obj0 = 0 ;
5856 char *kwnames[] = {
5857 (char *) "cursor", NULL
5858 };
5859
5860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5861 {
5862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5863 if (SWIG_arg_fail(1)) SWIG_fail;
5864 if (arg1 == NULL) {
5865 SWIG_null_ref("wxCursor");
5866 }
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 }
5869 {
5870 if (!wxPyCheckForApp()) SWIG_fail;
5871 PyThreadState* __tstate = wxPyBeginAllowThreads();
5872 wxSetCursor(*arg1);
5873
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 Py_INCREF(Py_None); resultobj = Py_None;
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj;
5886 void *result;
5887 char *kwnames[] = {
5888 NULL
5889 };
5890
5891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5892 {
5893 if (!wxPyCheckForApp()) SWIG_fail;
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (void *)wxGetXDisplay();
5896
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5908 PyObject *resultobj;
5909 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5910 PyObject * obj0 = 0 ;
5911 char *kwnames[] = {
5912 (char *) "cursor", NULL
5913 };
5914
5915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5916 if (obj0) {
5917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5918 if (SWIG_arg_fail(1)) SWIG_fail;
5919 }
5920 {
5921 if (!wxPyCheckForApp()) SWIG_fail;
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 wxBeginBusyCursor(arg1);
5924
5925 wxPyEndAllowThreads(__tstate);
5926 if (PyErr_Occurred()) SWIG_fail;
5927 }
5928 Py_INCREF(Py_None); resultobj = Py_None;
5929 return resultobj;
5930 fail:
5931 return NULL;
5932 }
5933
5934
5935 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5936 PyObject *resultobj;
5937 wxWindow *result;
5938 char *kwnames[] = {
5939 NULL
5940 };
5941
5942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5943 {
5944 if (!wxPyCheckForApp()) SWIG_fail;
5945 PyThreadState* __tstate = wxPyBeginAllowThreads();
5946 result = (wxWindow *)wxGetActiveWindow();
5947
5948 wxPyEndAllowThreads(__tstate);
5949 if (PyErr_Occurred()) SWIG_fail;
5950 }
5951 {
5952 resultobj = wxPyMake_wxObject(result, 0);
5953 }
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5961 PyObject *resultobj;
5962 wxPoint *arg1 = 0 ;
5963 wxWindow *result;
5964 wxPoint temp1 ;
5965 PyObject * obj0 = 0 ;
5966 char *kwnames[] = {
5967 (char *) "pt", NULL
5968 };
5969
5970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5971 {
5972 arg1 = &temp1;
5973 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5974 }
5975 {
5976 if (!wxPyCheckForApp()) SWIG_fail;
5977 PyThreadState* __tstate = wxPyBeginAllowThreads();
5978 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5979
5980 wxPyEndAllowThreads(__tstate);
5981 if (PyErr_Occurred()) SWIG_fail;
5982 }
5983 {
5984 resultobj = wxPyMake_wxObject(result, 0);
5985 }
5986 return resultobj;
5987 fail:
5988 return NULL;
5989 }
5990
5991
5992 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5993 PyObject *resultobj;
5994 wxPoint *arg1 = 0 ;
5995 wxWindow *result;
5996 wxPoint temp1 ;
5997 PyObject * obj0 = 0 ;
5998 char *kwnames[] = {
5999 (char *) "pt", NULL
6000 };
6001
6002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
6003 {
6004 arg1 = &temp1;
6005 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6006 }
6007 {
6008 if (!wxPyCheckForApp()) SWIG_fail;
6009 PyThreadState* __tstate = wxPyBeginAllowThreads();
6010 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6011
6012 wxPyEndAllowThreads(__tstate);
6013 if (PyErr_Occurred()) SWIG_fail;
6014 }
6015 {
6016 resultobj = wxPyMake_wxObject(result, 0);
6017 }
6018 return resultobj;
6019 fail:
6020 return NULL;
6021 }
6022
6023
6024 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6025 PyObject *resultobj;
6026 wxWindow *arg1 = (wxWindow *) 0 ;
6027 wxWindow *result;
6028 PyObject * obj0 = 0 ;
6029 char *kwnames[] = {
6030 (char *) "win", NULL
6031 };
6032
6033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6035 if (SWIG_arg_fail(1)) SWIG_fail;
6036 {
6037 if (!wxPyCheckForApp()) SWIG_fail;
6038 PyThreadState* __tstate = wxPyBeginAllowThreads();
6039 result = (wxWindow *)wxGetTopLevelParent(arg1);
6040
6041 wxPyEndAllowThreads(__tstate);
6042 if (PyErr_Occurred()) SWIG_fail;
6043 }
6044 {
6045 resultobj = wxPyMake_wxObject(result, 0);
6046 }
6047 return resultobj;
6048 fail:
6049 return NULL;
6050 }
6051
6052
6053 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6054 PyObject *resultobj;
6055 wxString *arg1 = 0 ;
6056 bool result;
6057 bool temp1 = false ;
6058 PyObject * obj0 = 0 ;
6059 char *kwnames[] = {
6060 (char *) "url", NULL
6061 };
6062
6063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6064 {
6065 arg1 = wxString_in_helper(obj0);
6066 if (arg1 == NULL) SWIG_fail;
6067 temp1 = true;
6068 }
6069 {
6070 PyThreadState* __tstate = wxPyBeginAllowThreads();
6071 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6072
6073 wxPyEndAllowThreads(__tstate);
6074 if (PyErr_Occurred()) SWIG_fail;
6075 }
6076 {
6077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6078 }
6079 {
6080 if (temp1)
6081 delete arg1;
6082 }
6083 return resultobj;
6084 fail:
6085 {
6086 if (temp1)
6087 delete arg1;
6088 }
6089 return NULL;
6090 }
6091
6092
6093 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6094 PyObject *resultobj;
6095 wxKeyCode arg1 ;
6096 bool result;
6097 PyObject * obj0 = 0 ;
6098 char *kwnames[] = {
6099 (char *) "key", NULL
6100 };
6101
6102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6103 {
6104 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6105 if (SWIG_arg_fail(1)) SWIG_fail;
6106 }
6107 {
6108 if (!wxPyCheckForApp()) SWIG_fail;
6109 PyThreadState* __tstate = wxPyBeginAllowThreads();
6110 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6111
6112 wxPyEndAllowThreads(__tstate);
6113 if (PyErr_Occurred()) SWIG_fail;
6114 }
6115 {
6116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6117 }
6118 return resultobj;
6119 fail:
6120 return NULL;
6121 }
6122
6123
6124 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6125 PyObject *resultobj;
6126 char *kwnames[] = {
6127 NULL
6128 };
6129
6130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6131 {
6132 if (!wxPyCheckForApp()) SWIG_fail;
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 wxWakeUpMainThread();
6135
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 Py_INCREF(Py_None); resultobj = Py_None;
6140 return resultobj;
6141 fail:
6142 return NULL;
6143 }
6144
6145
6146 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6147 PyObject *resultobj;
6148 char *kwnames[] = {
6149 NULL
6150 };
6151
6152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6153 {
6154 if (!wxPyCheckForApp()) SWIG_fail;
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 wxMutexGuiEnter();
6157
6158 wxPyEndAllowThreads(__tstate);
6159 if (PyErr_Occurred()) SWIG_fail;
6160 }
6161 Py_INCREF(Py_None); resultobj = Py_None;
6162 return resultobj;
6163 fail:
6164 return NULL;
6165 }
6166
6167
6168 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj;
6170 char *kwnames[] = {
6171 NULL
6172 };
6173
6174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6175 {
6176 if (!wxPyCheckForApp()) SWIG_fail;
6177 PyThreadState* __tstate = wxPyBeginAllowThreads();
6178 wxMutexGuiLeave();
6179
6180 wxPyEndAllowThreads(__tstate);
6181 if (PyErr_Occurred()) SWIG_fail;
6182 }
6183 Py_INCREF(Py_None); resultobj = Py_None;
6184 return resultobj;
6185 fail:
6186 return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj;
6192 wxMutexGuiLocker *result;
6193 char *kwnames[] = {
6194 NULL
6195 };
6196
6197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6198 {
6199 if (!wxPyCheckForApp()) SWIG_fail;
6200 PyThreadState* __tstate = wxPyBeginAllowThreads();
6201 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6202
6203 wxPyEndAllowThreads(__tstate);
6204 if (PyErr_Occurred()) SWIG_fail;
6205 }
6206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6207 return resultobj;
6208 fail:
6209 return NULL;
6210 }
6211
6212
6213 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6214 PyObject *resultobj;
6215 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6216 PyObject * obj0 = 0 ;
6217 char *kwnames[] = {
6218 (char *) "self", NULL
6219 };
6220
6221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6223 if (SWIG_arg_fail(1)) SWIG_fail;
6224 {
6225 PyThreadState* __tstate = wxPyBeginAllowThreads();
6226 delete arg1;
6227
6228 wxPyEndAllowThreads(__tstate);
6229 if (PyErr_Occurred()) SWIG_fail;
6230 }
6231 Py_INCREF(Py_None); resultobj = Py_None;
6232 return resultobj;
6233 fail:
6234 return NULL;
6235 }
6236
6237
6238 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6239 PyObject *obj;
6240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6241 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6242 Py_INCREF(obj);
6243 return Py_BuildValue((char *)"");
6244 }
6245 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6246 PyObject *resultobj;
6247 bool result;
6248 char *kwnames[] = {
6249 NULL
6250 };
6251
6252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6253 {
6254 PyThreadState* __tstate = wxPyBeginAllowThreads();
6255 result = (bool)wxThread_IsMain();
6256
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 {
6261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6262 }
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj;
6271 wxString *arg1 = 0 ;
6272 wxToolTip *result;
6273 bool temp1 = false ;
6274 PyObject * obj0 = 0 ;
6275 char *kwnames[] = {
6276 (char *) "tip", NULL
6277 };
6278
6279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6280 {
6281 arg1 = wxString_in_helper(obj0);
6282 if (arg1 == NULL) SWIG_fail;
6283 temp1 = true;
6284 }
6285 {
6286 if (!wxPyCheckForApp()) SWIG_fail;
6287 PyThreadState* __tstate = wxPyBeginAllowThreads();
6288 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6289
6290 wxPyEndAllowThreads(__tstate);
6291 if (PyErr_Occurred()) SWIG_fail;
6292 }
6293 {
6294 resultobj = wxPyMake_wxObject(result, 1);
6295 }
6296 {
6297 if (temp1)
6298 delete arg1;
6299 }
6300 return resultobj;
6301 fail:
6302 {
6303 if (temp1)
6304 delete arg1;
6305 }
6306 return NULL;
6307 }
6308
6309
6310 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6311 PyObject *resultobj;
6312 wxToolTip *arg1 = (wxToolTip *) 0 ;
6313 wxString *arg2 = 0 ;
6314 bool temp2 = false ;
6315 PyObject * obj0 = 0 ;
6316 PyObject * obj1 = 0 ;
6317 char *kwnames[] = {
6318 (char *) "self",(char *) "tip", NULL
6319 };
6320
6321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6323 if (SWIG_arg_fail(1)) SWIG_fail;
6324 {
6325 arg2 = wxString_in_helper(obj1);
6326 if (arg2 == NULL) SWIG_fail;
6327 temp2 = true;
6328 }
6329 {
6330 PyThreadState* __tstate = wxPyBeginAllowThreads();
6331 (arg1)->SetTip((wxString const &)*arg2);
6332
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 Py_INCREF(Py_None); resultobj = Py_None;
6337 {
6338 if (temp2)
6339 delete arg2;
6340 }
6341 return resultobj;
6342 fail:
6343 {
6344 if (temp2)
6345 delete arg2;
6346 }
6347 return NULL;
6348 }
6349
6350
6351 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj;
6353 wxToolTip *arg1 = (wxToolTip *) 0 ;
6354 wxString result;
6355 PyObject * obj0 = 0 ;
6356 char *kwnames[] = {
6357 (char *) "self", NULL
6358 };
6359
6360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6362 if (SWIG_arg_fail(1)) SWIG_fail;
6363 {
6364 PyThreadState* __tstate = wxPyBeginAllowThreads();
6365 result = (arg1)->GetTip();
6366
6367 wxPyEndAllowThreads(__tstate);
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 {
6371 #if wxUSE_UNICODE
6372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6373 #else
6374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6375 #endif
6376 }
6377 return resultobj;
6378 fail:
6379 return NULL;
6380 }
6381
6382
6383 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6384 PyObject *resultobj;
6385 wxToolTip *arg1 = (wxToolTip *) 0 ;
6386 wxWindow *result;
6387 PyObject * obj0 = 0 ;
6388 char *kwnames[] = {
6389 (char *) "self", NULL
6390 };
6391
6392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6394 if (SWIG_arg_fail(1)) SWIG_fail;
6395 {
6396 PyThreadState* __tstate = wxPyBeginAllowThreads();
6397 result = (wxWindow *)(arg1)->GetWindow();
6398
6399 wxPyEndAllowThreads(__tstate);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 {
6403 resultobj = wxPyMake_wxObject(result, 0);
6404 }
6405 return resultobj;
6406 fail:
6407 return NULL;
6408 }
6409
6410
6411 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6412 PyObject *resultobj;
6413 bool arg1 ;
6414 PyObject * obj0 = 0 ;
6415 char *kwnames[] = {
6416 (char *) "flag", NULL
6417 };
6418
6419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6420 {
6421 arg1 = (bool)(SWIG_As_bool(obj0));
6422 if (SWIG_arg_fail(1)) SWIG_fail;
6423 }
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 wxToolTip::Enable(arg1);
6427
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 Py_INCREF(Py_None); resultobj = Py_None;
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj;
6440 long arg1 ;
6441 PyObject * obj0 = 0 ;
6442 char *kwnames[] = {
6443 (char *) "milliseconds", NULL
6444 };
6445
6446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6447 {
6448 arg1 = (long)(SWIG_As_long(obj0));
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 }
6451 {
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 wxToolTip::SetDelay(arg1);
6454
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 Py_INCREF(Py_None); resultobj = Py_None;
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6466 PyObject *obj;
6467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6468 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6469 Py_INCREF(obj);
6470 return Py_BuildValue((char *)"");
6471 }
6472 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj;
6474 wxWindow *arg1 = (wxWindow *) 0 ;
6475 wxSize *arg2 = 0 ;
6476 wxCaret *result;
6477 wxSize temp2 ;
6478 PyObject * obj0 = 0 ;
6479 PyObject * obj1 = 0 ;
6480 char *kwnames[] = {
6481 (char *) "window",(char *) "size", NULL
6482 };
6483
6484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6486 if (SWIG_arg_fail(1)) SWIG_fail;
6487 {
6488 arg2 = &temp2;
6489 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6490 }
6491 {
6492 if (!wxPyCheckForApp()) SWIG_fail;
6493 PyThreadState* __tstate = wxPyBeginAllowThreads();
6494 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6495
6496 wxPyEndAllowThreads(__tstate);
6497 if (PyErr_Occurred()) SWIG_fail;
6498 }
6499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6500 return resultobj;
6501 fail:
6502 return NULL;
6503 }
6504
6505
6506 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6507 PyObject *resultobj;
6508 wxCaret *arg1 = (wxCaret *) 0 ;
6509 PyObject * obj0 = 0 ;
6510 char *kwnames[] = {
6511 (char *) "self", NULL
6512 };
6513
6514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6516 if (SWIG_arg_fail(1)) SWIG_fail;
6517 {
6518 PyThreadState* __tstate = wxPyBeginAllowThreads();
6519 wxCaret_Destroy(arg1);
6520
6521 wxPyEndAllowThreads(__tstate);
6522 if (PyErr_Occurred()) SWIG_fail;
6523 }
6524 Py_INCREF(Py_None); resultobj = Py_None;
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6532 PyObject *resultobj;
6533 wxCaret *arg1 = (wxCaret *) 0 ;
6534 bool result;
6535 PyObject * obj0 = 0 ;
6536 char *kwnames[] = {
6537 (char *) "self", NULL
6538 };
6539
6540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6542 if (SWIG_arg_fail(1)) SWIG_fail;
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 result = (bool)(arg1)->IsOk();
6546
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 {
6551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6552 }
6553 return resultobj;
6554 fail:
6555 return NULL;
6556 }
6557
6558
6559 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6560 PyObject *resultobj;
6561 wxCaret *arg1 = (wxCaret *) 0 ;
6562 bool result;
6563 PyObject * obj0 = 0 ;
6564 char *kwnames[] = {
6565 (char *) "self", NULL
6566 };
6567
6568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6570 if (SWIG_arg_fail(1)) SWIG_fail;
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 result = (bool)(arg1)->IsVisible();
6574
6575 wxPyEndAllowThreads(__tstate);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 {
6579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6580 }
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6588 PyObject *resultobj;
6589 wxCaret *arg1 = (wxCaret *) 0 ;
6590 wxPoint result;
6591 PyObject * obj0 = 0 ;
6592 char *kwnames[] = {
6593 (char *) "self", NULL
6594 };
6595
6596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6598 if (SWIG_arg_fail(1)) SWIG_fail;
6599 {
6600 PyThreadState* __tstate = wxPyBeginAllowThreads();
6601 result = (arg1)->GetPosition();
6602
6603 wxPyEndAllowThreads(__tstate);
6604 if (PyErr_Occurred()) SWIG_fail;
6605 }
6606 {
6607 wxPoint * resultptr;
6608 resultptr = new wxPoint((wxPoint &)(result));
6609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6610 }
6611 return resultobj;
6612 fail:
6613 return NULL;
6614 }
6615
6616
6617 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6618 PyObject *resultobj;
6619 wxCaret *arg1 = (wxCaret *) 0 ;
6620 int *arg2 = (int *) 0 ;
6621 int *arg3 = (int *) 0 ;
6622 int temp2 ;
6623 int res2 = 0 ;
6624 int temp3 ;
6625 int res3 = 0 ;
6626 PyObject * obj0 = 0 ;
6627 char *kwnames[] = {
6628 (char *) "self", NULL
6629 };
6630
6631 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6632 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6635 if (SWIG_arg_fail(1)) SWIG_fail;
6636 {
6637 PyThreadState* __tstate = wxPyBeginAllowThreads();
6638 (arg1)->GetPosition(arg2,arg3);
6639
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 Py_INCREF(Py_None); resultobj = Py_None;
6644 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6645 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6646 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6647 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6655 PyObject *resultobj;
6656 wxCaret *arg1 = (wxCaret *) 0 ;
6657 wxSize result;
6658 PyObject * obj0 = 0 ;
6659 char *kwnames[] = {
6660 (char *) "self", NULL
6661 };
6662
6663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6665 if (SWIG_arg_fail(1)) SWIG_fail;
6666 {
6667 PyThreadState* __tstate = wxPyBeginAllowThreads();
6668 result = (arg1)->GetSize();
6669
6670 wxPyEndAllowThreads(__tstate);
6671 if (PyErr_Occurred()) SWIG_fail;
6672 }
6673 {
6674 wxSize * resultptr;
6675 resultptr = new wxSize((wxSize &)(result));
6676 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6677 }
6678 return resultobj;
6679 fail:
6680 return NULL;
6681 }
6682
6683
6684 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6685 PyObject *resultobj;
6686 wxCaret *arg1 = (wxCaret *) 0 ;
6687 int *arg2 = (int *) 0 ;
6688 int *arg3 = (int *) 0 ;
6689 int temp2 ;
6690 int res2 = 0 ;
6691 int temp3 ;
6692 int res3 = 0 ;
6693 PyObject * obj0 = 0 ;
6694 char *kwnames[] = {
6695 (char *) "self", NULL
6696 };
6697
6698 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6699 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6702 if (SWIG_arg_fail(1)) SWIG_fail;
6703 {
6704 PyThreadState* __tstate = wxPyBeginAllowThreads();
6705 (arg1)->GetSize(arg2,arg3);
6706
6707 wxPyEndAllowThreads(__tstate);
6708 if (PyErr_Occurred()) SWIG_fail;
6709 }
6710 Py_INCREF(Py_None); resultobj = Py_None;
6711 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6712 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6713 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6714 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj;
6723 wxCaret *arg1 = (wxCaret *) 0 ;
6724 wxWindow *result;
6725 PyObject * obj0 = 0 ;
6726 char *kwnames[] = {
6727 (char *) "self", NULL
6728 };
6729
6730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6732 if (SWIG_arg_fail(1)) SWIG_fail;
6733 {
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 result = (wxWindow *)(arg1)->GetWindow();
6736
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 {
6741 resultobj = wxPyMake_wxObject(result, 0);
6742 }
6743 return resultobj;
6744 fail:
6745 return NULL;
6746 }
6747
6748
6749 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6750 PyObject *resultobj;
6751 wxCaret *arg1 = (wxCaret *) 0 ;
6752 int arg2 ;
6753 int arg3 ;
6754 PyObject * obj0 = 0 ;
6755 PyObject * obj1 = 0 ;
6756 PyObject * obj2 = 0 ;
6757 char *kwnames[] = {
6758 (char *) "self",(char *) "x",(char *) "y", NULL
6759 };
6760
6761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6763 if (SWIG_arg_fail(1)) SWIG_fail;
6764 {
6765 arg2 = (int)(SWIG_As_int(obj1));
6766 if (SWIG_arg_fail(2)) SWIG_fail;
6767 }
6768 {
6769 arg3 = (int)(SWIG_As_int(obj2));
6770 if (SWIG_arg_fail(3)) SWIG_fail;
6771 }
6772 {
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 (arg1)->Move(arg2,arg3);
6775
6776 wxPyEndAllowThreads(__tstate);
6777 if (PyErr_Occurred()) SWIG_fail;
6778 }
6779 Py_INCREF(Py_None); resultobj = Py_None;
6780 return resultobj;
6781 fail:
6782 return NULL;
6783 }
6784
6785
6786 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6787 PyObject *resultobj;
6788 wxCaret *arg1 = (wxCaret *) 0 ;
6789 wxPoint *arg2 = 0 ;
6790 wxPoint temp2 ;
6791 PyObject * obj0 = 0 ;
6792 PyObject * obj1 = 0 ;
6793 char *kwnames[] = {
6794 (char *) "self",(char *) "pt", NULL
6795 };
6796
6797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6799 if (SWIG_arg_fail(1)) SWIG_fail;
6800 {
6801 arg2 = &temp2;
6802 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6803 }
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 (arg1)->Move((wxPoint const &)*arg2);
6807
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 Py_INCREF(Py_None); resultobj = Py_None;
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6819 PyObject *resultobj;
6820 wxCaret *arg1 = (wxCaret *) 0 ;
6821 int arg2 ;
6822 int arg3 ;
6823 PyObject * obj0 = 0 ;
6824 PyObject * obj1 = 0 ;
6825 PyObject * obj2 = 0 ;
6826 char *kwnames[] = {
6827 (char *) "self",(char *) "width",(char *) "height", NULL
6828 };
6829
6830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6832 if (SWIG_arg_fail(1)) SWIG_fail;
6833 {
6834 arg2 = (int)(SWIG_As_int(obj1));
6835 if (SWIG_arg_fail(2)) SWIG_fail;
6836 }
6837 {
6838 arg3 = (int)(SWIG_As_int(obj2));
6839 if (SWIG_arg_fail(3)) SWIG_fail;
6840 }
6841 {
6842 PyThreadState* __tstate = wxPyBeginAllowThreads();
6843 (arg1)->SetSize(arg2,arg3);
6844
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 Py_INCREF(Py_None); resultobj = Py_None;
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj;
6857 wxCaret *arg1 = (wxCaret *) 0 ;
6858 wxSize *arg2 = 0 ;
6859 wxSize temp2 ;
6860 PyObject * obj0 = 0 ;
6861 PyObject * obj1 = 0 ;
6862 char *kwnames[] = {
6863 (char *) "self",(char *) "size", NULL
6864 };
6865
6866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6868 if (SWIG_arg_fail(1)) SWIG_fail;
6869 {
6870 arg2 = &temp2;
6871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6872 }
6873 {
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 (arg1)->SetSize((wxSize const &)*arg2);
6876
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 Py_INCREF(Py_None); resultobj = Py_None;
6881 return resultobj;
6882 fail:
6883 return NULL;
6884 }
6885
6886
6887 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6888 PyObject *resultobj;
6889 wxCaret *arg1 = (wxCaret *) 0 ;
6890 int arg2 = (int) true ;
6891 PyObject * obj0 = 0 ;
6892 PyObject * obj1 = 0 ;
6893 char *kwnames[] = {
6894 (char *) "self",(char *) "show", NULL
6895 };
6896
6897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6899 if (SWIG_arg_fail(1)) SWIG_fail;
6900 if (obj1) {
6901 {
6902 arg2 = (int)(SWIG_As_int(obj1));
6903 if (SWIG_arg_fail(2)) SWIG_fail;
6904 }
6905 }
6906 {
6907 PyThreadState* __tstate = wxPyBeginAllowThreads();
6908 (arg1)->Show(arg2);
6909
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 Py_INCREF(Py_None); resultobj = Py_None;
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6921 PyObject *resultobj;
6922 wxCaret *arg1 = (wxCaret *) 0 ;
6923 PyObject * obj0 = 0 ;
6924 char *kwnames[] = {
6925 (char *) "self", NULL
6926 };
6927
6928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6930 if (SWIG_arg_fail(1)) SWIG_fail;
6931 {
6932 PyThreadState* __tstate = wxPyBeginAllowThreads();
6933 (arg1)->Hide();
6934
6935 wxPyEndAllowThreads(__tstate);
6936 if (PyErr_Occurred()) SWIG_fail;
6937 }
6938 Py_INCREF(Py_None); resultobj = Py_None;
6939 return resultobj;
6940 fail:
6941 return NULL;
6942 }
6943
6944
6945 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6946 PyObject *resultobj;
6947 int result;
6948 char *kwnames[] = {
6949 NULL
6950 };
6951
6952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6953 {
6954 PyThreadState* __tstate = wxPyBeginAllowThreads();
6955 result = (int)wxCaret::GetBlinkTime();
6956
6957 wxPyEndAllowThreads(__tstate);
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 {
6961 resultobj = SWIG_From_int((int)(result));
6962 }
6963 return resultobj;
6964 fail:
6965 return NULL;
6966 }
6967
6968
6969 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6970 PyObject *resultobj;
6971 int arg1 ;
6972 PyObject * obj0 = 0 ;
6973 char *kwnames[] = {
6974 (char *) "milliseconds", NULL
6975 };
6976
6977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6978 {
6979 arg1 = (int)(SWIG_As_int(obj0));
6980 if (SWIG_arg_fail(1)) SWIG_fail;
6981 }
6982 {
6983 PyThreadState* __tstate = wxPyBeginAllowThreads();
6984 wxCaret::SetBlinkTime(arg1);
6985
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 Py_INCREF(Py_None); resultobj = Py_None;
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6997 PyObject *obj;
6998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6999 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
7000 Py_INCREF(obj);
7001 return Py_BuildValue((char *)"");
7002 }
7003 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7004 PyObject *resultobj;
7005 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7006 wxBusyCursor *result;
7007 PyObject * obj0 = 0 ;
7008 char *kwnames[] = {
7009 (char *) "cursor", NULL
7010 };
7011
7012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7013 if (obj0) {
7014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7015 if (SWIG_arg_fail(1)) SWIG_fail;
7016 }
7017 {
7018 if (!wxPyCheckForApp()) SWIG_fail;
7019 PyThreadState* __tstate = wxPyBeginAllowThreads();
7020 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7021
7022 wxPyEndAllowThreads(__tstate);
7023 if (PyErr_Occurred()) SWIG_fail;
7024 }
7025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7026 return resultobj;
7027 fail:
7028 return NULL;
7029 }
7030
7031
7032 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7033 PyObject *resultobj;
7034 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7035 PyObject * obj0 = 0 ;
7036 char *kwnames[] = {
7037 (char *) "self", NULL
7038 };
7039
7040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7042 if (SWIG_arg_fail(1)) SWIG_fail;
7043 {
7044 PyThreadState* __tstate = wxPyBeginAllowThreads();
7045 delete arg1;
7046
7047 wxPyEndAllowThreads(__tstate);
7048 if (PyErr_Occurred()) SWIG_fail;
7049 }
7050 Py_INCREF(Py_None); resultobj = Py_None;
7051 return resultobj;
7052 fail:
7053 return NULL;
7054 }
7055
7056
7057 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7058 PyObject *obj;
7059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7060 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7061 Py_INCREF(obj);
7062 return Py_BuildValue((char *)"");
7063 }
7064 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj;
7066 wxWindow *arg1 = (wxWindow *) NULL ;
7067 wxWindowDisabler *result;
7068 PyObject * obj0 = 0 ;
7069 char *kwnames[] = {
7070 (char *) "winToSkip", NULL
7071 };
7072
7073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7074 if (obj0) {
7075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7076 if (SWIG_arg_fail(1)) SWIG_fail;
7077 }
7078 {
7079 if (!wxPyCheckForApp()) SWIG_fail;
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7082
7083 wxPyEndAllowThreads(__tstate);
7084 if (PyErr_Occurred()) SWIG_fail;
7085 }
7086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7087 return resultobj;
7088 fail:
7089 return NULL;
7090 }
7091
7092
7093 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7094 PyObject *resultobj;
7095 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7096 PyObject * obj0 = 0 ;
7097 char *kwnames[] = {
7098 (char *) "self", NULL
7099 };
7100
7101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7103 if (SWIG_arg_fail(1)) SWIG_fail;
7104 {
7105 PyThreadState* __tstate = wxPyBeginAllowThreads();
7106 delete arg1;
7107
7108 wxPyEndAllowThreads(__tstate);
7109 if (PyErr_Occurred()) SWIG_fail;
7110 }
7111 Py_INCREF(Py_None); resultobj = Py_None;
7112 return resultobj;
7113 fail:
7114 return NULL;
7115 }
7116
7117
7118 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7119 PyObject *obj;
7120 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7121 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7122 Py_INCREF(obj);
7123 return Py_BuildValue((char *)"");
7124 }
7125 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7126 PyObject *resultobj;
7127 wxString *arg1 = 0 ;
7128 wxBusyInfo *result;
7129 bool temp1 = false ;
7130 PyObject * obj0 = 0 ;
7131 char *kwnames[] = {
7132 (char *) "message", NULL
7133 };
7134
7135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7136 {
7137 arg1 = wxString_in_helper(obj0);
7138 if (arg1 == NULL) SWIG_fail;
7139 temp1 = true;
7140 }
7141 {
7142 if (!wxPyCheckForApp()) SWIG_fail;
7143 PyThreadState* __tstate = wxPyBeginAllowThreads();
7144 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7145
7146 wxPyEndAllowThreads(__tstate);
7147 if (PyErr_Occurred()) SWIG_fail;
7148 }
7149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7150 {
7151 if (temp1)
7152 delete arg1;
7153 }
7154 return resultobj;
7155 fail:
7156 {
7157 if (temp1)
7158 delete arg1;
7159 }
7160 return NULL;
7161 }
7162
7163
7164 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj;
7166 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7167 PyObject * obj0 = 0 ;
7168 char *kwnames[] = {
7169 (char *) "self", NULL
7170 };
7171
7172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7174 if (SWIG_arg_fail(1)) SWIG_fail;
7175 {
7176 PyThreadState* __tstate = wxPyBeginAllowThreads();
7177 delete arg1;
7178
7179 wxPyEndAllowThreads(__tstate);
7180 if (PyErr_Occurred()) SWIG_fail;
7181 }
7182 Py_INCREF(Py_None); resultobj = Py_None;
7183 return resultobj;
7184 fail:
7185 return NULL;
7186 }
7187
7188
7189 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7190 PyObject *obj;
7191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7192 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7193 Py_INCREF(obj);
7194 return Py_BuildValue((char *)"");
7195 }
7196 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj;
7198 wxStopWatch *result;
7199 char *kwnames[] = {
7200 NULL
7201 };
7202
7203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7204 {
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 result = (wxStopWatch *)new wxStopWatch();
7207
7208 wxPyEndAllowThreads(__tstate);
7209 if (PyErr_Occurred()) SWIG_fail;
7210 }
7211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj;
7220 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7221 long arg2 = (long) 0 ;
7222 PyObject * obj0 = 0 ;
7223 PyObject * obj1 = 0 ;
7224 char *kwnames[] = {
7225 (char *) "self",(char *) "t0", NULL
7226 };
7227
7228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7230 if (SWIG_arg_fail(1)) SWIG_fail;
7231 if (obj1) {
7232 {
7233 arg2 = (long)(SWIG_As_long(obj1));
7234 if (SWIG_arg_fail(2)) SWIG_fail;
7235 }
7236 }
7237 {
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 (arg1)->Start(arg2);
7240
7241 wxPyEndAllowThreads(__tstate);
7242 if (PyErr_Occurred()) SWIG_fail;
7243 }
7244 Py_INCREF(Py_None); resultobj = Py_None;
7245 return resultobj;
7246 fail:
7247 return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj;
7253 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7254 PyObject * obj0 = 0 ;
7255 char *kwnames[] = {
7256 (char *) "self", NULL
7257 };
7258
7259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7261 if (SWIG_arg_fail(1)) SWIG_fail;
7262 {
7263 PyThreadState* __tstate = wxPyBeginAllowThreads();
7264 (arg1)->Pause();
7265
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 Py_INCREF(Py_None); resultobj = Py_None;
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj;
7278 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7279 PyObject * obj0 = 0 ;
7280 char *kwnames[] = {
7281 (char *) "self", NULL
7282 };
7283
7284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7286 if (SWIG_arg_fail(1)) SWIG_fail;
7287 {
7288 PyThreadState* __tstate = wxPyBeginAllowThreads();
7289 (arg1)->Resume();
7290
7291 wxPyEndAllowThreads(__tstate);
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 Py_INCREF(Py_None); resultobj = Py_None;
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7302 PyObject *resultobj;
7303 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7304 long result;
7305 PyObject * obj0 = 0 ;
7306 char *kwnames[] = {
7307 (char *) "self", NULL
7308 };
7309
7310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7312 if (SWIG_arg_fail(1)) SWIG_fail;
7313 {
7314 PyThreadState* __tstate = wxPyBeginAllowThreads();
7315 result = (long)((wxStopWatch const *)arg1)->Time();
7316
7317 wxPyEndAllowThreads(__tstate);
7318 if (PyErr_Occurred()) SWIG_fail;
7319 }
7320 {
7321 resultobj = SWIG_From_long((long)(result));
7322 }
7323 return resultobj;
7324 fail:
7325 return NULL;
7326 }
7327
7328
7329 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7330 PyObject *obj;
7331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7332 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7333 Py_INCREF(obj);
7334 return Py_BuildValue((char *)"");
7335 }
7336 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7337 PyObject *resultobj;
7338 int arg1 = (int) 9 ;
7339 int arg2 = (int) wxID_FILE1 ;
7340 wxFileHistory *result;
7341 PyObject * obj0 = 0 ;
7342 PyObject * obj1 = 0 ;
7343 char *kwnames[] = {
7344 (char *) "maxFiles",(char *) "idBase", NULL
7345 };
7346
7347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7348 if (obj0) {
7349 {
7350 arg1 = (int)(SWIG_As_int(obj0));
7351 if (SWIG_arg_fail(1)) SWIG_fail;
7352 }
7353 }
7354 if (obj1) {
7355 {
7356 arg2 = (int)(SWIG_As_int(obj1));
7357 if (SWIG_arg_fail(2)) SWIG_fail;
7358 }
7359 }
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj;
7376 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7377 PyObject * obj0 = 0 ;
7378 char *kwnames[] = {
7379 (char *) "self", NULL
7380 };
7381
7382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(1)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 delete arg1;
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 Py_INCREF(Py_None); resultobj = Py_None;
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7402 wxString *arg2 = 0 ;
7403 bool temp2 = false ;
7404 PyObject * obj0 = 0 ;
7405 PyObject * obj1 = 0 ;
7406 char *kwnames[] = {
7407 (char *) "self",(char *) "file", NULL
7408 };
7409
7410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7412 if (SWIG_arg_fail(1)) SWIG_fail;
7413 {
7414 arg2 = wxString_in_helper(obj1);
7415 if (arg2 == NULL) SWIG_fail;
7416 temp2 = true;
7417 }
7418 {
7419 PyThreadState* __tstate = wxPyBeginAllowThreads();
7420 (arg1)->AddFileToHistory((wxString const &)*arg2);
7421
7422 wxPyEndAllowThreads(__tstate);
7423 if (PyErr_Occurred()) SWIG_fail;
7424 }
7425 Py_INCREF(Py_None); resultobj = Py_None;
7426 {
7427 if (temp2)
7428 delete arg2;
7429 }
7430 return resultobj;
7431 fail:
7432 {
7433 if (temp2)
7434 delete arg2;
7435 }
7436 return NULL;
7437 }
7438
7439
7440 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7441 PyObject *resultobj;
7442 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7443 int arg2 ;
7444 PyObject * obj0 = 0 ;
7445 PyObject * obj1 = 0 ;
7446 char *kwnames[] = {
7447 (char *) "self",(char *) "i", NULL
7448 };
7449
7450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7452 if (SWIG_arg_fail(1)) SWIG_fail;
7453 {
7454 arg2 = (int)(SWIG_As_int(obj1));
7455 if (SWIG_arg_fail(2)) SWIG_fail;
7456 }
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 (arg1)->RemoveFileFromHistory(arg2);
7460
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 Py_INCREF(Py_None); resultobj = Py_None;
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj;
7473 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7474 int result;
7475 PyObject * obj0 = 0 ;
7476 char *kwnames[] = {
7477 (char *) "self", NULL
7478 };
7479
7480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7482 if (SWIG_arg_fail(1)) SWIG_fail;
7483 {
7484 PyThreadState* __tstate = wxPyBeginAllowThreads();
7485 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7486
7487 wxPyEndAllowThreads(__tstate);
7488 if (PyErr_Occurred()) SWIG_fail;
7489 }
7490 {
7491 resultobj = SWIG_From_int((int)(result));
7492 }
7493 return resultobj;
7494 fail:
7495 return NULL;
7496 }
7497
7498
7499 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7500 PyObject *resultobj;
7501 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7502 wxMenu *arg2 = (wxMenu *) 0 ;
7503 PyObject * obj0 = 0 ;
7504 PyObject * obj1 = 0 ;
7505 char *kwnames[] = {
7506 (char *) "self",(char *) "menu", NULL
7507 };
7508
7509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7511 if (SWIG_arg_fail(1)) SWIG_fail;
7512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7513 if (SWIG_arg_fail(2)) SWIG_fail;
7514 {
7515 PyThreadState* __tstate = wxPyBeginAllowThreads();
7516 (arg1)->UseMenu(arg2);
7517
7518 wxPyEndAllowThreads(__tstate);
7519 if (PyErr_Occurred()) SWIG_fail;
7520 }
7521 Py_INCREF(Py_None); resultobj = Py_None;
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj;
7530 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7531 wxMenu *arg2 = (wxMenu *) 0 ;
7532 PyObject * obj0 = 0 ;
7533 PyObject * obj1 = 0 ;
7534 char *kwnames[] = {
7535 (char *) "self",(char *) "menu", NULL
7536 };
7537
7538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7540 if (SWIG_arg_fail(1)) SWIG_fail;
7541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7542 if (SWIG_arg_fail(2)) SWIG_fail;
7543 {
7544 PyThreadState* __tstate = wxPyBeginAllowThreads();
7545 (arg1)->RemoveMenu(arg2);
7546
7547 wxPyEndAllowThreads(__tstate);
7548 if (PyErr_Occurred()) SWIG_fail;
7549 }
7550 Py_INCREF(Py_None); resultobj = Py_None;
7551 return resultobj;
7552 fail:
7553 return NULL;
7554 }
7555
7556
7557 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7558 PyObject *resultobj;
7559 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7560 wxConfigBase *arg2 = 0 ;
7561 PyObject * obj0 = 0 ;
7562 PyObject * obj1 = 0 ;
7563 char *kwnames[] = {
7564 (char *) "self",(char *) "config", NULL
7565 };
7566
7567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7569 if (SWIG_arg_fail(1)) SWIG_fail;
7570 {
7571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7572 if (SWIG_arg_fail(2)) SWIG_fail;
7573 if (arg2 == NULL) {
7574 SWIG_null_ref("wxConfigBase");
7575 }
7576 if (SWIG_arg_fail(2)) SWIG_fail;
7577 }
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 (arg1)->Load(*arg2);
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 Py_INCREF(Py_None); resultobj = Py_None;
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj;
7594 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7595 wxConfigBase *arg2 = 0 ;
7596 PyObject * obj0 = 0 ;
7597 PyObject * obj1 = 0 ;
7598 char *kwnames[] = {
7599 (char *) "self",(char *) "config", NULL
7600 };
7601
7602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7604 if (SWIG_arg_fail(1)) SWIG_fail;
7605 {
7606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7607 if (SWIG_arg_fail(2)) SWIG_fail;
7608 if (arg2 == NULL) {
7609 SWIG_null_ref("wxConfigBase");
7610 }
7611 if (SWIG_arg_fail(2)) SWIG_fail;
7612 }
7613 {
7614 PyThreadState* __tstate = wxPyBeginAllowThreads();
7615 (arg1)->Save(*arg2);
7616
7617 wxPyEndAllowThreads(__tstate);
7618 if (PyErr_Occurred()) SWIG_fail;
7619 }
7620 Py_INCREF(Py_None); resultobj = Py_None;
7621 return resultobj;
7622 fail:
7623 return NULL;
7624 }
7625
7626
7627 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7628 PyObject *resultobj;
7629 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7630 PyObject * obj0 = 0 ;
7631 char *kwnames[] = {
7632 (char *) "self", NULL
7633 };
7634
7635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7637 if (SWIG_arg_fail(1)) SWIG_fail;
7638 {
7639 PyThreadState* __tstate = wxPyBeginAllowThreads();
7640 (arg1)->AddFilesToMenu();
7641
7642 wxPyEndAllowThreads(__tstate);
7643 if (PyErr_Occurred()) SWIG_fail;
7644 }
7645 Py_INCREF(Py_None); resultobj = Py_None;
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7653 PyObject *resultobj;
7654 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7655 wxMenu *arg2 = (wxMenu *) 0 ;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 char *kwnames[] = {
7659 (char *) "self",(char *) "menu", NULL
7660 };
7661
7662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7664 if (SWIG_arg_fail(1)) SWIG_fail;
7665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7666 if (SWIG_arg_fail(2)) SWIG_fail;
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 (arg1)->AddFilesToMenu(arg2);
7670
7671 wxPyEndAllowThreads(__tstate);
7672 if (PyErr_Occurred()) SWIG_fail;
7673 }
7674 Py_INCREF(Py_None); resultobj = Py_None;
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7682 PyObject *resultobj;
7683 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7684 int arg2 ;
7685 wxString result;
7686 PyObject * obj0 = 0 ;
7687 PyObject * obj1 = 0 ;
7688 char *kwnames[] = {
7689 (char *) "self",(char *) "i", NULL
7690 };
7691
7692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7694 if (SWIG_arg_fail(1)) SWIG_fail;
7695 {
7696 arg2 = (int)(SWIG_As_int(obj1));
7697 if (SWIG_arg_fail(2)) SWIG_fail;
7698 }
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7702
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 {
7707 #if wxUSE_UNICODE
7708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7709 #else
7710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7711 #endif
7712 }
7713 return resultobj;
7714 fail:
7715 return NULL;
7716 }
7717
7718
7719 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7720 PyObject *resultobj;
7721 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7722 int result;
7723 PyObject * obj0 = 0 ;
7724 char *kwnames[] = {
7725 (char *) "self", NULL
7726 };
7727
7728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7730 if (SWIG_arg_fail(1)) SWIG_fail;
7731 {
7732 PyThreadState* __tstate = wxPyBeginAllowThreads();
7733 result = (int)((wxFileHistory const *)arg1)->GetCount();
7734
7735 wxPyEndAllowThreads(__tstate);
7736 if (PyErr_Occurred()) SWIG_fail;
7737 }
7738 {
7739 resultobj = SWIG_From_int((int)(result));
7740 }
7741 return resultobj;
7742 fail:
7743 return NULL;
7744 }
7745
7746
7747 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7748 PyObject *obj;
7749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7750 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7751 Py_INCREF(obj);
7752 return Py_BuildValue((char *)"");
7753 }
7754 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7755 PyObject *resultobj;
7756 wxString *arg1 = 0 ;
7757 wxString const &arg2_defvalue = wxPyEmptyString ;
7758 wxString *arg2 = (wxString *) &arg2_defvalue ;
7759 wxSingleInstanceChecker *result;
7760 bool temp1 = false ;
7761 bool temp2 = false ;
7762 PyObject * obj0 = 0 ;
7763 PyObject * obj1 = 0 ;
7764 char *kwnames[] = {
7765 (char *) "name",(char *) "path", NULL
7766 };
7767
7768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7769 {
7770 arg1 = wxString_in_helper(obj0);
7771 if (arg1 == NULL) SWIG_fail;
7772 temp1 = true;
7773 }
7774 if (obj1) {
7775 {
7776 arg2 = wxString_in_helper(obj1);
7777 if (arg2 == NULL) SWIG_fail;
7778 temp2 = true;
7779 }
7780 }
7781 {
7782 PyThreadState* __tstate = wxPyBeginAllowThreads();
7783 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7784
7785 wxPyEndAllowThreads(__tstate);
7786 if (PyErr_Occurred()) SWIG_fail;
7787 }
7788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7789 {
7790 if (temp1)
7791 delete arg1;
7792 }
7793 {
7794 if (temp2)
7795 delete arg2;
7796 }
7797 return resultobj;
7798 fail:
7799 {
7800 if (temp1)
7801 delete arg1;
7802 }
7803 {
7804 if (temp2)
7805 delete arg2;
7806 }
7807 return NULL;
7808 }
7809
7810
7811 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj;
7813 wxSingleInstanceChecker *result;
7814 char *kwnames[] = {
7815 NULL
7816 };
7817
7818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7819 {
7820 PyThreadState* __tstate = wxPyBeginAllowThreads();
7821 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7822
7823 wxPyEndAllowThreads(__tstate);
7824 if (PyErr_Occurred()) SWIG_fail;
7825 }
7826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7827 return resultobj;
7828 fail:
7829 return NULL;
7830 }
7831
7832
7833 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7834 PyObject *resultobj;
7835 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7836 PyObject * obj0 = 0 ;
7837 char *kwnames[] = {
7838 (char *) "self", NULL
7839 };
7840
7841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7843 if (SWIG_arg_fail(1)) SWIG_fail;
7844 {
7845 PyThreadState* __tstate = wxPyBeginAllowThreads();
7846 delete arg1;
7847
7848 wxPyEndAllowThreads(__tstate);
7849 if (PyErr_Occurred()) SWIG_fail;
7850 }
7851 Py_INCREF(Py_None); resultobj = Py_None;
7852 return resultobj;
7853 fail:
7854 return NULL;
7855 }
7856
7857
7858 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7859 PyObject *resultobj;
7860 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7861 wxString *arg2 = 0 ;
7862 wxString const &arg3_defvalue = wxPyEmptyString ;
7863 wxString *arg3 = (wxString *) &arg3_defvalue ;
7864 bool result;
7865 bool temp2 = false ;
7866 bool temp3 = false ;
7867 PyObject * obj0 = 0 ;
7868 PyObject * obj1 = 0 ;
7869 PyObject * obj2 = 0 ;
7870 char *kwnames[] = {
7871 (char *) "self",(char *) "name",(char *) "path", NULL
7872 };
7873
7874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7876 if (SWIG_arg_fail(1)) SWIG_fail;
7877 {
7878 arg2 = wxString_in_helper(obj1);
7879 if (arg2 == NULL) SWIG_fail;
7880 temp2 = true;
7881 }
7882 if (obj2) {
7883 {
7884 arg3 = wxString_in_helper(obj2);
7885 if (arg3 == NULL) SWIG_fail;
7886 temp3 = true;
7887 }
7888 }
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7892
7893 wxPyEndAllowThreads(__tstate);
7894 if (PyErr_Occurred()) SWIG_fail;
7895 }
7896 {
7897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7898 }
7899 {
7900 if (temp2)
7901 delete arg2;
7902 }
7903 {
7904 if (temp3)
7905 delete arg3;
7906 }
7907 return resultobj;
7908 fail:
7909 {
7910 if (temp2)
7911 delete arg2;
7912 }
7913 {
7914 if (temp3)
7915 delete arg3;
7916 }
7917 return NULL;
7918 }
7919
7920
7921 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj;
7923 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7924 bool result;
7925 PyObject * obj0 = 0 ;
7926 char *kwnames[] = {
7927 (char *) "self", NULL
7928 };
7929
7930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7932 if (SWIG_arg_fail(1)) SWIG_fail;
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7936
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 {
7941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7942 }
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7950 PyObject *obj;
7951 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7952 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7953 Py_INCREF(obj);
7954 return Py_BuildValue((char *)"");
7955 }
7956 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7957 PyObject *resultobj;
7958 wxWindow *arg1 = (wxWindow *) 0 ;
7959 wxDC *arg2 = 0 ;
7960 bool result;
7961 PyObject * obj0 = 0 ;
7962 PyObject * obj1 = 0 ;
7963 char *kwnames[] = {
7964 (char *) "window",(char *) "dc", NULL
7965 };
7966
7967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7969 if (SWIG_arg_fail(1)) SWIG_fail;
7970 {
7971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7972 if (SWIG_arg_fail(2)) SWIG_fail;
7973 if (arg2 == NULL) {
7974 SWIG_null_ref("wxDC");
7975 }
7976 if (SWIG_arg_fail(2)) SWIG_fail;
7977 }
7978 {
7979 PyThreadState* __tstate = wxPyBeginAllowThreads();
7980 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7981
7982 wxPyEndAllowThreads(__tstate);
7983 if (PyErr_Occurred()) SWIG_fail;
7984 }
7985 {
7986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7987 }
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7995 PyObject *resultobj;
7996 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7997 PyObject * obj0 = 0 ;
7998 char *kwnames[] = {
7999 (char *) "self", NULL
8000 };
8001
8002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
8003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8004 if (SWIG_arg_fail(1)) SWIG_fail;
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 delete arg1;
8008
8009 wxPyEndAllowThreads(__tstate);
8010 if (PyErr_Occurred()) SWIG_fail;
8011 }
8012 Py_INCREF(Py_None); resultobj = Py_None;
8013 return resultobj;
8014 fail:
8015 return NULL;
8016 }
8017
8018
8019 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8020 PyObject *resultobj;
8021 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8022 wxString result;
8023 PyObject * obj0 = 0 ;
8024 char *kwnames[] = {
8025 (char *) "self", NULL
8026 };
8027
8028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8030 if (SWIG_arg_fail(1)) SWIG_fail;
8031 {
8032 PyThreadState* __tstate = wxPyBeginAllowThreads();
8033 result = (arg1)->GetTip();
8034
8035 wxPyEndAllowThreads(__tstate);
8036 if (PyErr_Occurred()) SWIG_fail;
8037 }
8038 {
8039 #if wxUSE_UNICODE
8040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8041 #else
8042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8043 #endif
8044 }
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8052 PyObject *resultobj;
8053 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8054 size_t result;
8055 PyObject * obj0 = 0 ;
8056 char *kwnames[] = {
8057 (char *) "self", NULL
8058 };
8059
8060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8062 if (SWIG_arg_fail(1)) SWIG_fail;
8063 {
8064 PyThreadState* __tstate = wxPyBeginAllowThreads();
8065 result = (size_t)(arg1)->GetCurrentTip();
8066
8067 wxPyEndAllowThreads(__tstate);
8068 if (PyErr_Occurred()) SWIG_fail;
8069 }
8070 {
8071 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8072 }
8073 return resultobj;
8074 fail:
8075 return NULL;
8076 }
8077
8078
8079 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8080 PyObject *resultobj;
8081 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8082 wxString *arg2 = 0 ;
8083 wxString result;
8084 bool temp2 = false ;
8085 PyObject * obj0 = 0 ;
8086 PyObject * obj1 = 0 ;
8087 char *kwnames[] = {
8088 (char *) "self",(char *) "tip", NULL
8089 };
8090
8091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8093 if (SWIG_arg_fail(1)) SWIG_fail;
8094 {
8095 arg2 = wxString_in_helper(obj1);
8096 if (arg2 == NULL) SWIG_fail;
8097 temp2 = true;
8098 }
8099 {
8100 PyThreadState* __tstate = wxPyBeginAllowThreads();
8101 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8102
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 {
8107 #if wxUSE_UNICODE
8108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8109 #else
8110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8111 #endif
8112 }
8113 {
8114 if (temp2)
8115 delete arg2;
8116 }
8117 return resultobj;
8118 fail:
8119 {
8120 if (temp2)
8121 delete arg2;
8122 }
8123 return NULL;
8124 }
8125
8126
8127 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8128 PyObject *obj;
8129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8130 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8131 Py_INCREF(obj);
8132 return Py_BuildValue((char *)"");
8133 }
8134 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8135 PyObject *resultobj;
8136 size_t arg1 ;
8137 wxPyTipProvider *result;
8138 PyObject * obj0 = 0 ;
8139 char *kwnames[] = {
8140 (char *) "currentTip", NULL
8141 };
8142
8143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8144 {
8145 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8146 if (SWIG_arg_fail(1)) SWIG_fail;
8147 }
8148 {
8149 PyThreadState* __tstate = wxPyBeginAllowThreads();
8150 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8151
8152 wxPyEndAllowThreads(__tstate);
8153 if (PyErr_Occurred()) SWIG_fail;
8154 }
8155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8156 return resultobj;
8157 fail:
8158 return NULL;
8159 }
8160
8161
8162 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8163 PyObject *resultobj;
8164 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8165 PyObject *arg2 = (PyObject *) 0 ;
8166 PyObject *arg3 = (PyObject *) 0 ;
8167 PyObject * obj0 = 0 ;
8168 PyObject * obj1 = 0 ;
8169 PyObject * obj2 = 0 ;
8170 char *kwnames[] = {
8171 (char *) "self",(char *) "self",(char *) "_class", NULL
8172 };
8173
8174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8176 if (SWIG_arg_fail(1)) SWIG_fail;
8177 arg2 = obj1;
8178 arg3 = obj2;
8179 {
8180 PyThreadState* __tstate = wxPyBeginAllowThreads();
8181 (arg1)->_setCallbackInfo(arg2,arg3);
8182
8183 wxPyEndAllowThreads(__tstate);
8184 if (PyErr_Occurred()) SWIG_fail;
8185 }
8186 Py_INCREF(Py_None); resultobj = Py_None;
8187 return resultobj;
8188 fail:
8189 return NULL;
8190 }
8191
8192
8193 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8194 PyObject *obj;
8195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8196 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8197 Py_INCREF(obj);
8198 return Py_BuildValue((char *)"");
8199 }
8200 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj;
8202 wxWindow *arg1 = (wxWindow *) 0 ;
8203 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8204 bool arg3 = (bool) true ;
8205 bool result;
8206 PyObject * obj0 = 0 ;
8207 PyObject * obj1 = 0 ;
8208 PyObject * obj2 = 0 ;
8209 char *kwnames[] = {
8210 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8211 };
8212
8213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8215 if (SWIG_arg_fail(1)) SWIG_fail;
8216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8217 if (SWIG_arg_fail(2)) SWIG_fail;
8218 if (obj2) {
8219 {
8220 arg3 = (bool)(SWIG_As_bool(obj2));
8221 if (SWIG_arg_fail(3)) SWIG_fail;
8222 }
8223 }
8224 {
8225 if (!wxPyCheckForApp()) SWIG_fail;
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 result = (bool)wxShowTip(arg1,arg2,arg3);
8228
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 {
8233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8234 }
8235 return resultobj;
8236 fail:
8237 return NULL;
8238 }
8239
8240
8241 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8242 PyObject *resultobj;
8243 wxString *arg1 = 0 ;
8244 size_t arg2 ;
8245 wxTipProvider *result;
8246 bool temp1 = false ;
8247 PyObject * obj0 = 0 ;
8248 PyObject * obj1 = 0 ;
8249 char *kwnames[] = {
8250 (char *) "filename",(char *) "currentTip", NULL
8251 };
8252
8253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8254 {
8255 arg1 = wxString_in_helper(obj0);
8256 if (arg1 == NULL) SWIG_fail;
8257 temp1 = true;
8258 }
8259 {
8260 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8261 if (SWIG_arg_fail(2)) SWIG_fail;
8262 }
8263 {
8264 if (!wxPyCheckForApp()) SWIG_fail;
8265 PyThreadState* __tstate = wxPyBeginAllowThreads();
8266 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8267
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8272 {
8273 if (temp1)
8274 delete arg1;
8275 }
8276 return resultobj;
8277 fail:
8278 {
8279 if (temp1)
8280 delete arg1;
8281 }
8282 return NULL;
8283 }
8284
8285
8286 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8287 PyObject *resultobj;
8288 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8289 int arg2 = (int) -1 ;
8290 wxPyTimer *result;
8291 PyObject * obj0 = 0 ;
8292 PyObject * obj1 = 0 ;
8293 char *kwnames[] = {
8294 (char *) "owner",(char *) "id", NULL
8295 };
8296
8297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8298 if (obj0) {
8299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8300 if (SWIG_arg_fail(1)) SWIG_fail;
8301 }
8302 if (obj1) {
8303 {
8304 arg2 = (int)(SWIG_As_int(obj1));
8305 if (SWIG_arg_fail(2)) SWIG_fail;
8306 }
8307 }
8308 {
8309 if (!wxPyCheckForApp()) SWIG_fail;
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8312
8313 wxPyEndAllowThreads(__tstate);
8314 if (PyErr_Occurred()) SWIG_fail;
8315 }
8316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8317 return resultobj;
8318 fail:
8319 return NULL;
8320 }
8321
8322
8323 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8324 PyObject *resultobj;
8325 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8326 PyObject * obj0 = 0 ;
8327 char *kwnames[] = {
8328 (char *) "self", NULL
8329 };
8330
8331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8333 if (SWIG_arg_fail(1)) SWIG_fail;
8334 {
8335 PyThreadState* __tstate = wxPyBeginAllowThreads();
8336 delete arg1;
8337
8338 wxPyEndAllowThreads(__tstate);
8339 if (PyErr_Occurred()) SWIG_fail;
8340 }
8341 Py_INCREF(Py_None); resultobj = Py_None;
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj;
8350 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8351 PyObject *arg2 = (PyObject *) 0 ;
8352 PyObject *arg3 = (PyObject *) 0 ;
8353 int arg4 = (int) 1 ;
8354 PyObject * obj0 = 0 ;
8355 PyObject * obj1 = 0 ;
8356 PyObject * obj2 = 0 ;
8357 PyObject * obj3 = 0 ;
8358 char *kwnames[] = {
8359 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8360 };
8361
8362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8364 if (SWIG_arg_fail(1)) SWIG_fail;
8365 arg2 = obj1;
8366 arg3 = obj2;
8367 if (obj3) {
8368 {
8369 arg4 = (int)(SWIG_As_int(obj3));
8370 if (SWIG_arg_fail(4)) SWIG_fail;
8371 }
8372 }
8373 {
8374 PyThreadState* __tstate = wxPyBeginAllowThreads();
8375 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8376
8377 wxPyEndAllowThreads(__tstate);
8378 if (PyErr_Occurred()) SWIG_fail;
8379 }
8380 Py_INCREF(Py_None); resultobj = Py_None;
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8388 PyObject *resultobj;
8389 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8390 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8391 int arg3 = (int) -1 ;
8392 PyObject * obj0 = 0 ;
8393 PyObject * obj1 = 0 ;
8394 PyObject * obj2 = 0 ;
8395 char *kwnames[] = {
8396 (char *) "self",(char *) "owner",(char *) "id", NULL
8397 };
8398
8399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8401 if (SWIG_arg_fail(1)) SWIG_fail;
8402 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8403 if (SWIG_arg_fail(2)) SWIG_fail;
8404 if (obj2) {
8405 {
8406 arg3 = (int)(SWIG_As_int(obj2));
8407 if (SWIG_arg_fail(3)) SWIG_fail;
8408 }
8409 }
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 (arg1)->SetOwner(arg2,arg3);
8413
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 Py_INCREF(Py_None); resultobj = Py_None;
8418 return resultobj;
8419 fail:
8420 return NULL;
8421 }
8422
8423
8424 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8425 PyObject *resultobj;
8426 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8427 wxEvtHandler *result;
8428 PyObject * obj0 = 0 ;
8429 char *kwnames[] = {
8430 (char *) "self", NULL
8431 };
8432
8433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8435 if (SWIG_arg_fail(1)) SWIG_fail;
8436 {
8437 PyThreadState* __tstate = wxPyBeginAllowThreads();
8438 result = (wxEvtHandler *)(arg1)->GetOwner();
8439
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 {
8444 resultobj = wxPyMake_wxObject(result, 0);
8445 }
8446 return resultobj;
8447 fail:
8448 return NULL;
8449 }
8450
8451
8452 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8453 PyObject *resultobj;
8454 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8455 int arg2 = (int) -1 ;
8456 bool arg3 = (bool) false ;
8457 bool result;
8458 PyObject * obj0 = 0 ;
8459 PyObject * obj1 = 0 ;
8460 PyObject * obj2 = 0 ;
8461 char *kwnames[] = {
8462 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8463 };
8464
8465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8467 if (SWIG_arg_fail(1)) SWIG_fail;
8468 if (obj1) {
8469 {
8470 arg2 = (int)(SWIG_As_int(obj1));
8471 if (SWIG_arg_fail(2)) SWIG_fail;
8472 }
8473 }
8474 if (obj2) {
8475 {
8476 arg3 = (bool)(SWIG_As_bool(obj2));
8477 if (SWIG_arg_fail(3)) SWIG_fail;
8478 }
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 result = (bool)(arg1)->Start(arg2,arg3);
8483
8484 wxPyEndAllowThreads(__tstate);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 {
8488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8489 }
8490 return resultobj;
8491 fail:
8492 return NULL;
8493 }
8494
8495
8496 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8497 PyObject *resultobj;
8498 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8499 PyObject * obj0 = 0 ;
8500 char *kwnames[] = {
8501 (char *) "self", NULL
8502 };
8503
8504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8506 if (SWIG_arg_fail(1)) SWIG_fail;
8507 {
8508 PyThreadState* __tstate = wxPyBeginAllowThreads();
8509 (arg1)->Stop();
8510
8511 wxPyEndAllowThreads(__tstate);
8512 if (PyErr_Occurred()) SWIG_fail;
8513 }
8514 Py_INCREF(Py_None); resultobj = Py_None;
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8522 PyObject *resultobj;
8523 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8524 bool result;
8525 PyObject * obj0 = 0 ;
8526 char *kwnames[] = {
8527 (char *) "self", NULL
8528 };
8529
8530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8532 if (SWIG_arg_fail(1)) SWIG_fail;
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8536
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 {
8541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8542 }
8543 return resultobj;
8544 fail:
8545 return NULL;
8546 }
8547
8548
8549 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8550 PyObject *resultobj;
8551 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8552 int result;
8553 PyObject * obj0 = 0 ;
8554 char *kwnames[] = {
8555 (char *) "self", NULL
8556 };
8557
8558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8560 if (SWIG_arg_fail(1)) SWIG_fail;
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8564
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 {
8569 resultobj = SWIG_From_int((int)(result));
8570 }
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj;
8579 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8580 bool result;
8581 PyObject * obj0 = 0 ;
8582 char *kwnames[] = {
8583 (char *) "self", NULL
8584 };
8585
8586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8588 if (SWIG_arg_fail(1)) SWIG_fail;
8589 {
8590 PyThreadState* __tstate = wxPyBeginAllowThreads();
8591 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8592
8593 wxPyEndAllowThreads(__tstate);
8594 if (PyErr_Occurred()) SWIG_fail;
8595 }
8596 {
8597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8598 }
8599 return resultobj;
8600 fail:
8601 return NULL;
8602 }
8603
8604
8605 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8606 PyObject *resultobj;
8607 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8608 int result;
8609 PyObject * obj0 = 0 ;
8610 char *kwnames[] = {
8611 (char *) "self", NULL
8612 };
8613
8614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8616 if (SWIG_arg_fail(1)) SWIG_fail;
8617 {
8618 PyThreadState* __tstate = wxPyBeginAllowThreads();
8619 result = (int)((wxPyTimer const *)arg1)->GetId();
8620
8621 wxPyEndAllowThreads(__tstate);
8622 if (PyErr_Occurred()) SWIG_fail;
8623 }
8624 {
8625 resultobj = SWIG_From_int((int)(result));
8626 }
8627 return resultobj;
8628 fail:
8629 return NULL;
8630 }
8631
8632
8633 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8634 PyObject *obj;
8635 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8636 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8637 Py_INCREF(obj);
8638 return Py_BuildValue((char *)"");
8639 }
8640 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8641 PyObject *resultobj;
8642 int arg1 = (int) 0 ;
8643 int arg2 = (int) 0 ;
8644 wxTimerEvent *result;
8645 PyObject * obj0 = 0 ;
8646 PyObject * obj1 = 0 ;
8647 char *kwnames[] = {
8648 (char *) "timerid",(char *) "interval", NULL
8649 };
8650
8651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8652 if (obj0) {
8653 {
8654 arg1 = (int)(SWIG_As_int(obj0));
8655 if (SWIG_arg_fail(1)) SWIG_fail;
8656 }
8657 }
8658 if (obj1) {
8659 {
8660 arg2 = (int)(SWIG_As_int(obj1));
8661 if (SWIG_arg_fail(2)) SWIG_fail;
8662 }
8663 }
8664 {
8665 PyThreadState* __tstate = wxPyBeginAllowThreads();
8666 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8667
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj;
8680 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8681 int result;
8682 PyObject * obj0 = 0 ;
8683 char *kwnames[] = {
8684 (char *) "self", NULL
8685 };
8686
8687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8689 if (SWIG_arg_fail(1)) SWIG_fail;
8690 {
8691 PyThreadState* __tstate = wxPyBeginAllowThreads();
8692 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8693
8694 wxPyEndAllowThreads(__tstate);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 {
8698 resultobj = SWIG_From_int((int)(result));
8699 }
8700 return resultobj;
8701 fail:
8702 return NULL;
8703 }
8704
8705
8706 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8707 PyObject *obj;
8708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8709 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8710 Py_INCREF(obj);
8711 return Py_BuildValue((char *)"");
8712 }
8713 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8714 PyObject *resultobj;
8715 wxTimer *arg1 = 0 ;
8716 wxTimerRunner *result;
8717 PyObject * obj0 = 0 ;
8718
8719 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8720 {
8721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8722 if (SWIG_arg_fail(1)) SWIG_fail;
8723 if (arg1 == NULL) {
8724 SWIG_null_ref("wxTimer");
8725 }
8726 if (SWIG_arg_fail(1)) SWIG_fail;
8727 }
8728 {
8729 if (!wxPyCheckForApp()) SWIG_fail;
8730 PyThreadState* __tstate = wxPyBeginAllowThreads();
8731 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8732
8733 wxPyEndAllowThreads(__tstate);
8734 if (PyErr_Occurred()) SWIG_fail;
8735 }
8736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8744 PyObject *resultobj;
8745 wxTimer *arg1 = 0 ;
8746 int arg2 ;
8747 bool arg3 = (bool) false ;
8748 wxTimerRunner *result;
8749 PyObject * obj0 = 0 ;
8750 PyObject * obj1 = 0 ;
8751 PyObject * obj2 = 0 ;
8752
8753 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8754 {
8755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8756 if (SWIG_arg_fail(1)) SWIG_fail;
8757 if (arg1 == NULL) {
8758 SWIG_null_ref("wxTimer");
8759 }
8760 if (SWIG_arg_fail(1)) SWIG_fail;
8761 }
8762 {
8763 arg2 = (int)(SWIG_As_int(obj1));
8764 if (SWIG_arg_fail(2)) SWIG_fail;
8765 }
8766 if (obj2) {
8767 {
8768 arg3 = (bool)(SWIG_As_bool(obj2));
8769 if (SWIG_arg_fail(3)) SWIG_fail;
8770 }
8771 }
8772 {
8773 if (!wxPyCheckForApp()) SWIG_fail;
8774 PyThreadState* __tstate = wxPyBeginAllowThreads();
8775 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8776
8777 wxPyEndAllowThreads(__tstate);
8778 if (PyErr_Occurred()) SWIG_fail;
8779 }
8780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8781 return resultobj;
8782 fail:
8783 return NULL;
8784 }
8785
8786
8787 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8788 int argc;
8789 PyObject *argv[4];
8790 int ii;
8791
8792 argc = PyObject_Length(args);
8793 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8794 argv[ii] = PyTuple_GetItem(args,ii);
8795 }
8796 if (argc == 1) {
8797 int _v;
8798 {
8799 void *ptr = 0;
8800 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8801 _v = 0;
8802 PyErr_Clear();
8803 } else {
8804 _v = (ptr != 0);
8805 }
8806 }
8807 if (_v) {
8808 return _wrap_new_TimerRunner__SWIG_0(self,args);
8809 }
8810 }
8811 if ((argc >= 2) && (argc <= 3)) {
8812 int _v;
8813 {
8814 void *ptr = 0;
8815 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8816 _v = 0;
8817 PyErr_Clear();
8818 } else {
8819 _v = (ptr != 0);
8820 }
8821 }
8822 if (_v) {
8823 _v = SWIG_Check_int(argv[1]);
8824 if (_v) {
8825 if (argc <= 2) {
8826 return _wrap_new_TimerRunner__SWIG_1(self,args);
8827 }
8828 _v = SWIG_Check_bool(argv[2]);
8829 if (_v) {
8830 return _wrap_new_TimerRunner__SWIG_1(self,args);
8831 }
8832 }
8833 }
8834 }
8835
8836 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8837 return NULL;
8838 }
8839
8840
8841 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8842 PyObject *resultobj;
8843 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8844 PyObject * obj0 = 0 ;
8845 char *kwnames[] = {
8846 (char *) "self", NULL
8847 };
8848
8849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8851 if (SWIG_arg_fail(1)) SWIG_fail;
8852 {
8853 PyThreadState* __tstate = wxPyBeginAllowThreads();
8854 delete arg1;
8855
8856 wxPyEndAllowThreads(__tstate);
8857 if (PyErr_Occurred()) SWIG_fail;
8858 }
8859 Py_INCREF(Py_None); resultobj = Py_None;
8860 return resultobj;
8861 fail:
8862 return NULL;
8863 }
8864
8865
8866 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8867 PyObject *resultobj;
8868 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8869 int arg2 ;
8870 bool arg3 = (bool) false ;
8871 PyObject * obj0 = 0 ;
8872 PyObject * obj1 = 0 ;
8873 PyObject * obj2 = 0 ;
8874 char *kwnames[] = {
8875 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8876 };
8877
8878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8880 if (SWIG_arg_fail(1)) SWIG_fail;
8881 {
8882 arg2 = (int)(SWIG_As_int(obj1));
8883 if (SWIG_arg_fail(2)) SWIG_fail;
8884 }
8885 if (obj2) {
8886 {
8887 arg3 = (bool)(SWIG_As_bool(obj2));
8888 if (SWIG_arg_fail(3)) SWIG_fail;
8889 }
8890 }
8891 {
8892 PyThreadState* __tstate = wxPyBeginAllowThreads();
8893 (arg1)->Start(arg2,arg3);
8894
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 Py_INCREF(Py_None); resultobj = Py_None;
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8906 PyObject *obj;
8907 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8908 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8909 Py_INCREF(obj);
8910 return Py_BuildValue((char *)"");
8911 }
8912 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8913 PyObject *resultobj;
8914 wxLog *result;
8915 char *kwnames[] = {
8916 NULL
8917 };
8918
8919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8920 {
8921 PyThreadState* __tstate = wxPyBeginAllowThreads();
8922 result = (wxLog *)new wxLog();
8923
8924 wxPyEndAllowThreads(__tstate);
8925 if (PyErr_Occurred()) SWIG_fail;
8926 }
8927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8928 return resultobj;
8929 fail:
8930 return NULL;
8931 }
8932
8933
8934 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8935 PyObject *resultobj;
8936 bool result;
8937 char *kwnames[] = {
8938 NULL
8939 };
8940
8941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8942 {
8943 PyThreadState* __tstate = wxPyBeginAllowThreads();
8944 result = (bool)wxLog::IsEnabled();
8945
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 {
8950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8951 }
8952 return resultobj;
8953 fail:
8954 return NULL;
8955 }
8956
8957
8958 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8959 PyObject *resultobj;
8960 bool arg1 = (bool) true ;
8961 bool result;
8962 PyObject * obj0 = 0 ;
8963 char *kwnames[] = {
8964 (char *) "doIt", NULL
8965 };
8966
8967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8968 if (obj0) {
8969 {
8970 arg1 = (bool)(SWIG_As_bool(obj0));
8971 if (SWIG_arg_fail(1)) SWIG_fail;
8972 }
8973 }
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 result = (bool)wxLog::EnableLogging(arg1);
8977
8978 wxPyEndAllowThreads(__tstate);
8979 if (PyErr_Occurred()) SWIG_fail;
8980 }
8981 {
8982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8983 }
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8991 PyObject *resultobj;
8992 wxLogLevel arg1 ;
8993 wxChar *arg2 = (wxChar *) 0 ;
8994 time_t arg3 ;
8995 PyObject * obj0 = 0 ;
8996 PyObject * obj1 = 0 ;
8997 PyObject * obj2 = 0 ;
8998 char *kwnames[] = {
8999 (char *) "level",(char *) "szString",(char *) "t", NULL
9000 };
9001
9002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
9003 {
9004 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9005 if (SWIG_arg_fail(1)) SWIG_fail;
9006 }
9007 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9008 if (SWIG_arg_fail(2)) SWIG_fail;
9009 {
9010 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
9011 if (SWIG_arg_fail(3)) SWIG_fail;
9012 }
9013 {
9014 PyThreadState* __tstate = wxPyBeginAllowThreads();
9015 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9016
9017 wxPyEndAllowThreads(__tstate);
9018 if (PyErr_Occurred()) SWIG_fail;
9019 }
9020 Py_INCREF(Py_None); resultobj = Py_None;
9021 return resultobj;
9022 fail:
9023 return NULL;
9024 }
9025
9026
9027 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9028 PyObject *resultobj;
9029 wxLog *arg1 = (wxLog *) 0 ;
9030 PyObject * obj0 = 0 ;
9031 char *kwnames[] = {
9032 (char *) "self", NULL
9033 };
9034
9035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9037 if (SWIG_arg_fail(1)) SWIG_fail;
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 (arg1)->Flush();
9041
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 Py_INCREF(Py_None); resultobj = Py_None;
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 char *kwnames[] = {
9055 NULL
9056 };
9057
9058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9059 {
9060 PyThreadState* __tstate = wxPyBeginAllowThreads();
9061 wxLog::FlushActive();
9062
9063 wxPyEndAllowThreads(__tstate);
9064 if (PyErr_Occurred()) SWIG_fail;
9065 }
9066 Py_INCREF(Py_None); resultobj = Py_None;
9067 return resultobj;
9068 fail:
9069 return NULL;
9070 }
9071
9072
9073 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9074 PyObject *resultobj;
9075 wxLog *result;
9076 char *kwnames[] = {
9077 NULL
9078 };
9079
9080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9081 {
9082 PyThreadState* __tstate = wxPyBeginAllowThreads();
9083 result = (wxLog *)wxLog::GetActiveTarget();
9084
9085 wxPyEndAllowThreads(__tstate);
9086 if (PyErr_Occurred()) SWIG_fail;
9087 }
9088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9089 return resultobj;
9090 fail:
9091 return NULL;
9092 }
9093
9094
9095 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9096 PyObject *resultobj;
9097 wxLog *arg1 = (wxLog *) 0 ;
9098 wxLog *result;
9099 PyObject * obj0 = 0 ;
9100 char *kwnames[] = {
9101 (char *) "pLogger", NULL
9102 };
9103
9104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9106 if (SWIG_arg_fail(1)) SWIG_fail;
9107 {
9108 PyThreadState* __tstate = wxPyBeginAllowThreads();
9109 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9110
9111 wxPyEndAllowThreads(__tstate);
9112 if (PyErr_Occurred()) SWIG_fail;
9113 }
9114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9115 return resultobj;
9116 fail:
9117 return NULL;
9118 }
9119
9120
9121 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9122 PyObject *resultobj;
9123 char *kwnames[] = {
9124 NULL
9125 };
9126
9127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9128 {
9129 PyThreadState* __tstate = wxPyBeginAllowThreads();
9130 wxLog::Suspend();
9131
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 Py_INCREF(Py_None); resultobj = Py_None;
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9143 PyObject *resultobj;
9144 char *kwnames[] = {
9145 NULL
9146 };
9147
9148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9149 {
9150 PyThreadState* __tstate = wxPyBeginAllowThreads();
9151 wxLog::Resume();
9152
9153 wxPyEndAllowThreads(__tstate);
9154 if (PyErr_Occurred()) SWIG_fail;
9155 }
9156 Py_INCREF(Py_None); resultobj = Py_None;
9157 return resultobj;
9158 fail:
9159 return NULL;
9160 }
9161
9162
9163 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9164 PyObject *resultobj;
9165 bool arg1 = (bool) true ;
9166 PyObject * obj0 = 0 ;
9167 char *kwnames[] = {
9168 (char *) "bVerbose", NULL
9169 };
9170
9171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9172 if (obj0) {
9173 {
9174 arg1 = (bool)(SWIG_As_bool(obj0));
9175 if (SWIG_arg_fail(1)) SWIG_fail;
9176 }
9177 }
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 wxLog::SetVerbose(arg1);
9181
9182 wxPyEndAllowThreads(__tstate);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 Py_INCREF(Py_None); resultobj = Py_None;
9186 return resultobj;
9187 fail:
9188 return NULL;
9189 }
9190
9191
9192 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9193 PyObject *resultobj;
9194 wxLogLevel arg1 ;
9195 PyObject * obj0 = 0 ;
9196 char *kwnames[] = {
9197 (char *) "logLevel", NULL
9198 };
9199
9200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9201 {
9202 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9203 if (SWIG_arg_fail(1)) SWIG_fail;
9204 }
9205 {
9206 PyThreadState* __tstate = wxPyBeginAllowThreads();
9207 wxLog::SetLogLevel(arg1);
9208
9209 wxPyEndAllowThreads(__tstate);
9210 if (PyErr_Occurred()) SWIG_fail;
9211 }
9212 Py_INCREF(Py_None); resultobj = Py_None;
9213 return resultobj;
9214 fail:
9215 return NULL;
9216 }
9217
9218
9219 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9220 PyObject *resultobj;
9221 char *kwnames[] = {
9222 NULL
9223 };
9224
9225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9226 {
9227 PyThreadState* __tstate = wxPyBeginAllowThreads();
9228 wxLog::DontCreateOnDemand();
9229
9230 wxPyEndAllowThreads(__tstate);
9231 if (PyErr_Occurred()) SWIG_fail;
9232 }
9233 Py_INCREF(Py_None); resultobj = Py_None;
9234 return resultobj;
9235 fail:
9236 return NULL;
9237 }
9238
9239
9240 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9241 PyObject *resultobj;
9242 wxTraceMask arg1 ;
9243 PyObject * obj0 = 0 ;
9244 char *kwnames[] = {
9245 (char *) "ulMask", NULL
9246 };
9247
9248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9249 {
9250 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9251 if (SWIG_arg_fail(1)) SWIG_fail;
9252 }
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 wxLog::SetTraceMask(arg1);
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 Py_INCREF(Py_None); resultobj = Py_None;
9261 return resultobj;
9262 fail:
9263 return NULL;
9264 }
9265
9266
9267 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj;
9269 wxString *arg1 = 0 ;
9270 bool temp1 = false ;
9271 PyObject * obj0 = 0 ;
9272 char *kwnames[] = {
9273 (char *) "str", NULL
9274 };
9275
9276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9277 {
9278 arg1 = wxString_in_helper(obj0);
9279 if (arg1 == NULL) SWIG_fail;
9280 temp1 = true;
9281 }
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 wxLog::AddTraceMask((wxString const &)*arg1);
9285
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 Py_INCREF(Py_None); resultobj = Py_None;
9290 {
9291 if (temp1)
9292 delete arg1;
9293 }
9294 return resultobj;
9295 fail:
9296 {
9297 if (temp1)
9298 delete arg1;
9299 }
9300 return NULL;
9301 }
9302
9303
9304 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9305 PyObject *resultobj;
9306 wxString *arg1 = 0 ;
9307 bool temp1 = false ;
9308 PyObject * obj0 = 0 ;
9309 char *kwnames[] = {
9310 (char *) "str", NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9314 {
9315 arg1 = wxString_in_helper(obj0);
9316 if (arg1 == NULL) SWIG_fail;
9317 temp1 = true;
9318 }
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 wxLog::RemoveTraceMask((wxString const &)*arg1);
9322
9323 wxPyEndAllowThreads(__tstate);
9324 if (PyErr_Occurred()) SWIG_fail;
9325 }
9326 Py_INCREF(Py_None); resultobj = Py_None;
9327 {
9328 if (temp1)
9329 delete arg1;
9330 }
9331 return resultobj;
9332 fail:
9333 {
9334 if (temp1)
9335 delete arg1;
9336 }
9337 return NULL;
9338 }
9339
9340
9341 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9342 PyObject *resultobj;
9343 char *kwnames[] = {
9344 NULL
9345 };
9346
9347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 wxLog::ClearTraceMasks();
9351
9352 wxPyEndAllowThreads(__tstate);
9353 if (PyErr_Occurred()) SWIG_fail;
9354 }
9355 Py_INCREF(Py_None); resultobj = Py_None;
9356 return resultobj;
9357 fail:
9358 return NULL;
9359 }
9360
9361
9362 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9363 PyObject *resultobj;
9364 wxArrayString *result;
9365 char *kwnames[] = {
9366 NULL
9367 };
9368
9369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9370 {
9371 PyThreadState* __tstate = wxPyBeginAllowThreads();
9372 {
9373 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9374 result = (wxArrayString *) &_result_ref;
9375 }
9376
9377 wxPyEndAllowThreads(__tstate);
9378 if (PyErr_Occurred()) SWIG_fail;
9379 }
9380 {
9381 resultobj = wxArrayString2PyList_helper(*result);
9382 }
9383 return resultobj;
9384 fail:
9385 return NULL;
9386 }
9387
9388
9389 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9390 PyObject *resultobj;
9391 wxChar *arg1 = (wxChar *) 0 ;
9392 PyObject * obj0 = 0 ;
9393 char *kwnames[] = {
9394 (char *) "ts", NULL
9395 };
9396
9397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9399 if (SWIG_arg_fail(1)) SWIG_fail;
9400 {
9401 PyThreadState* __tstate = wxPyBeginAllowThreads();
9402 wxLog::SetTimestamp((wxChar const *)arg1);
9403
9404 wxPyEndAllowThreads(__tstate);
9405 if (PyErr_Occurred()) SWIG_fail;
9406 }
9407 Py_INCREF(Py_None); resultobj = Py_None;
9408 return resultobj;
9409 fail:
9410 return NULL;
9411 }
9412
9413
9414 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9415 PyObject *resultobj;
9416 bool result;
9417 char *kwnames[] = {
9418 NULL
9419 };
9420
9421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9422 {
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 result = (bool)wxLog::GetVerbose();
9425
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 {
9430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9431 }
9432 return resultobj;
9433 fail:
9434 return NULL;
9435 }
9436
9437
9438 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9439 PyObject *resultobj;
9440 wxTraceMask result;
9441 char *kwnames[] = {
9442 NULL
9443 };
9444
9445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 result = (wxTraceMask)wxLog::GetTraceMask();
9449
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 {
9454 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9455 }
9456 return resultobj;
9457 fail:
9458 return NULL;
9459 }
9460
9461
9462 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9463 PyObject *resultobj;
9464 wxChar *arg1 = (wxChar *) 0 ;
9465 bool result;
9466 PyObject * obj0 = 0 ;
9467 char *kwnames[] = {
9468 (char *) "mask", NULL
9469 };
9470
9471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9473 if (SWIG_arg_fail(1)) SWIG_fail;
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9477
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 {
9482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9483 }
9484 return resultobj;
9485 fail:
9486 return NULL;
9487 }
9488
9489
9490 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9491 PyObject *resultobj;
9492 wxLogLevel result;
9493 char *kwnames[] = {
9494 NULL
9495 };
9496
9497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9498 {
9499 PyThreadState* __tstate = wxPyBeginAllowThreads();
9500 result = (wxLogLevel)wxLog::GetLogLevel();
9501
9502 wxPyEndAllowThreads(__tstate);
9503 if (PyErr_Occurred()) SWIG_fail;
9504 }
9505 {
9506 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9507 }
9508 return resultobj;
9509 fail:
9510 return NULL;
9511 }
9512
9513
9514 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9515 PyObject *resultobj;
9516 wxChar *result;
9517 char *kwnames[] = {
9518 NULL
9519 };
9520
9521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 result = (wxChar *)wxLog::GetTimestamp();
9525
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9537 PyObject *resultobj;
9538 wxString result;
9539 char *kwnames[] = {
9540 NULL
9541 };
9542
9543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9544 {
9545 PyThreadState* __tstate = wxPyBeginAllowThreads();
9546 result = Log_TimeStamp();
9547
9548 wxPyEndAllowThreads(__tstate);
9549 if (PyErr_Occurred()) SWIG_fail;
9550 }
9551 {
9552 #if wxUSE_UNICODE
9553 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9554 #else
9555 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9556 #endif
9557 }
9558 return resultobj;
9559 fail:
9560 return NULL;
9561 }
9562
9563
9564 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9565 PyObject *resultobj;
9566 wxLog *arg1 = (wxLog *) 0 ;
9567 PyObject * obj0 = 0 ;
9568 char *kwnames[] = {
9569 (char *) "self", NULL
9570 };
9571
9572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9574 if (SWIG_arg_fail(1)) SWIG_fail;
9575 {
9576 PyThreadState* __tstate = wxPyBeginAllowThreads();
9577 wxLog_Destroy(arg1);
9578
9579 wxPyEndAllowThreads(__tstate);
9580 if (PyErr_Occurred()) SWIG_fail;
9581 }
9582 Py_INCREF(Py_None); resultobj = Py_None;
9583 return resultobj;
9584 fail:
9585 return NULL;
9586 }
9587
9588
9589 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9590 PyObject *obj;
9591 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9592 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9593 Py_INCREF(obj);
9594 return Py_BuildValue((char *)"");
9595 }
9596 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9597 PyObject *resultobj;
9598 wxLogStderr *result;
9599 char *kwnames[] = {
9600 NULL
9601 };
9602
9603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9604 {
9605 PyThreadState* __tstate = wxPyBeginAllowThreads();
9606 result = (wxLogStderr *)new wxLogStderr();
9607
9608 wxPyEndAllowThreads(__tstate);
9609 if (PyErr_Occurred()) SWIG_fail;
9610 }
9611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9612 return resultobj;
9613 fail:
9614 return NULL;
9615 }
9616
9617
9618 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9619 PyObject *obj;
9620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9621 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9622 Py_INCREF(obj);
9623 return Py_BuildValue((char *)"");
9624 }
9625 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj;
9627 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9628 wxLogTextCtrl *result;
9629 PyObject * obj0 = 0 ;
9630 char *kwnames[] = {
9631 (char *) "pTextCtrl", NULL
9632 };
9633
9634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9636 if (SWIG_arg_fail(1)) SWIG_fail;
9637 {
9638 PyThreadState* __tstate = wxPyBeginAllowThreads();
9639 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9640
9641 wxPyEndAllowThreads(__tstate);
9642 if (PyErr_Occurred()) SWIG_fail;
9643 }
9644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9645 return resultobj;
9646 fail:
9647 return NULL;
9648 }
9649
9650
9651 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9652 PyObject *obj;
9653 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9654 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9655 Py_INCREF(obj);
9656 return Py_BuildValue((char *)"");
9657 }
9658 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9659 PyObject *resultobj;
9660 wxLogGui *result;
9661 char *kwnames[] = {
9662 NULL
9663 };
9664
9665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9666 {
9667 PyThreadState* __tstate = wxPyBeginAllowThreads();
9668 result = (wxLogGui *)new wxLogGui();
9669
9670 wxPyEndAllowThreads(__tstate);
9671 if (PyErr_Occurred()) SWIG_fail;
9672 }
9673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9674 return resultobj;
9675 fail:
9676 return NULL;
9677 }
9678
9679
9680 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9681 PyObject *obj;
9682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9683 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9684 Py_INCREF(obj);
9685 return Py_BuildValue((char *)"");
9686 }
9687 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9688 PyObject *resultobj;
9689 wxFrame *arg1 = (wxFrame *) 0 ;
9690 wxString *arg2 = 0 ;
9691 bool arg3 = (bool) true ;
9692 bool arg4 = (bool) true ;
9693 wxLogWindow *result;
9694 bool temp2 = false ;
9695 PyObject * obj0 = 0 ;
9696 PyObject * obj1 = 0 ;
9697 PyObject * obj2 = 0 ;
9698 PyObject * obj3 = 0 ;
9699 char *kwnames[] = {
9700 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9701 };
9702
9703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9705 if (SWIG_arg_fail(1)) SWIG_fail;
9706 {
9707 arg2 = wxString_in_helper(obj1);
9708 if (arg2 == NULL) SWIG_fail;
9709 temp2 = true;
9710 }
9711 if (obj2) {
9712 {
9713 arg3 = (bool)(SWIG_As_bool(obj2));
9714 if (SWIG_arg_fail(3)) SWIG_fail;
9715 }
9716 }
9717 if (obj3) {
9718 {
9719 arg4 = (bool)(SWIG_As_bool(obj3));
9720 if (SWIG_arg_fail(4)) SWIG_fail;
9721 }
9722 }
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9726
9727 wxPyEndAllowThreads(__tstate);
9728 if (PyErr_Occurred()) SWIG_fail;
9729 }
9730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9731 {
9732 if (temp2)
9733 delete arg2;
9734 }
9735 return resultobj;
9736 fail:
9737 {
9738 if (temp2)
9739 delete arg2;
9740 }
9741 return NULL;
9742 }
9743
9744
9745 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9746 PyObject *resultobj;
9747 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9748 bool arg2 = (bool) true ;
9749 PyObject * obj0 = 0 ;
9750 PyObject * obj1 = 0 ;
9751 char *kwnames[] = {
9752 (char *) "self",(char *) "bShow", NULL
9753 };
9754
9755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(1)) SWIG_fail;
9758 if (obj1) {
9759 {
9760 arg2 = (bool)(SWIG_As_bool(obj1));
9761 if (SWIG_arg_fail(2)) SWIG_fail;
9762 }
9763 }
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 (arg1)->Show(arg2);
9767
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 Py_INCREF(Py_None); resultobj = Py_None;
9772 return resultobj;
9773 fail:
9774 return NULL;
9775 }
9776
9777
9778 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9779 PyObject *resultobj;
9780 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9781 wxFrame *result;
9782 PyObject * obj0 = 0 ;
9783 char *kwnames[] = {
9784 (char *) "self", NULL
9785 };
9786
9787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9789 if (SWIG_arg_fail(1)) SWIG_fail;
9790 {
9791 PyThreadState* __tstate = wxPyBeginAllowThreads();
9792 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9793
9794 wxPyEndAllowThreads(__tstate);
9795 if (PyErr_Occurred()) SWIG_fail;
9796 }
9797 {
9798 resultobj = wxPyMake_wxObject(result, 0);
9799 }
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
9806 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9807 PyObject *resultobj;
9808 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9809 wxLog *result;
9810 PyObject * obj0 = 0 ;
9811 char *kwnames[] = {
9812 (char *) "self", NULL
9813 };
9814
9815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9817 if (SWIG_arg_fail(1)) SWIG_fail;
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9821
9822 wxPyEndAllowThreads(__tstate);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9833 PyObject *resultobj;
9834 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9835 bool result;
9836 PyObject * obj0 = 0 ;
9837 char *kwnames[] = {
9838 (char *) "self", NULL
9839 };
9840
9841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9843 if (SWIG_arg_fail(1)) SWIG_fail;
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9847
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9853 }
9854 return resultobj;
9855 fail:
9856 return NULL;
9857 }
9858
9859
9860 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9861 PyObject *resultobj;
9862 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9863 bool arg2 ;
9864 PyObject * obj0 = 0 ;
9865 PyObject * obj1 = 0 ;
9866 char *kwnames[] = {
9867 (char *) "self",(char *) "bDoPass", NULL
9868 };
9869
9870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9872 if (SWIG_arg_fail(1)) SWIG_fail;
9873 {
9874 arg2 = (bool)(SWIG_As_bool(obj1));
9875 if (SWIG_arg_fail(2)) SWIG_fail;
9876 }
9877 {
9878 PyThreadState* __tstate = wxPyBeginAllowThreads();
9879 (arg1)->PassMessages(arg2);
9880
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 Py_INCREF(Py_None); resultobj = Py_None;
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9892 PyObject *obj;
9893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9894 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9895 Py_INCREF(obj);
9896 return Py_BuildValue((char *)"");
9897 }
9898 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9899 PyObject *resultobj;
9900 wxLog *arg1 = (wxLog *) 0 ;
9901 wxLogChain *result;
9902 PyObject * obj0 = 0 ;
9903 char *kwnames[] = {
9904 (char *) "logger", NULL
9905 };
9906
9907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9909 if (SWIG_arg_fail(1)) SWIG_fail;
9910 {
9911 PyThreadState* __tstate = wxPyBeginAllowThreads();
9912 result = (wxLogChain *)new wxLogChain(arg1);
9913
9914 wxPyEndAllowThreads(__tstate);
9915 if (PyErr_Occurred()) SWIG_fail;
9916 }
9917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9918 return resultobj;
9919 fail:
9920 return NULL;
9921 }
9922
9923
9924 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9925 PyObject *resultobj;
9926 wxLogChain *arg1 = (wxLogChain *) 0 ;
9927 wxLog *arg2 = (wxLog *) 0 ;
9928 PyObject * obj0 = 0 ;
9929 PyObject * obj1 = 0 ;
9930 char *kwnames[] = {
9931 (char *) "self",(char *) "logger", NULL
9932 };
9933
9934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9936 if (SWIG_arg_fail(1)) SWIG_fail;
9937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9938 if (SWIG_arg_fail(2)) SWIG_fail;
9939 {
9940 PyThreadState* __tstate = wxPyBeginAllowThreads();
9941 (arg1)->SetLog(arg2);
9942
9943 wxPyEndAllowThreads(__tstate);
9944 if (PyErr_Occurred()) SWIG_fail;
9945 }
9946 Py_INCREF(Py_None); resultobj = Py_None;
9947 return resultobj;
9948 fail:
9949 return NULL;
9950 }
9951
9952
9953 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj;
9955 wxLogChain *arg1 = (wxLogChain *) 0 ;
9956 bool arg2 ;
9957 PyObject * obj0 = 0 ;
9958 PyObject * obj1 = 0 ;
9959 char *kwnames[] = {
9960 (char *) "self",(char *) "bDoPass", NULL
9961 };
9962
9963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9965 if (SWIG_arg_fail(1)) SWIG_fail;
9966 {
9967 arg2 = (bool)(SWIG_As_bool(obj1));
9968 if (SWIG_arg_fail(2)) SWIG_fail;
9969 }
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 (arg1)->PassMessages(arg2);
9973
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 Py_INCREF(Py_None); resultobj = Py_None;
9978 return resultobj;
9979 fail:
9980 return NULL;
9981 }
9982
9983
9984 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9985 PyObject *resultobj;
9986 wxLogChain *arg1 = (wxLogChain *) 0 ;
9987 bool result;
9988 PyObject * obj0 = 0 ;
9989 char *kwnames[] = {
9990 (char *) "self", NULL
9991 };
9992
9993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9995 if (SWIG_arg_fail(1)) SWIG_fail;
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (bool)(arg1)->IsPassingMessages();
9999
10000 wxPyEndAllowThreads(__tstate);
10001 if (PyErr_Occurred()) SWIG_fail;
10002 }
10003 {
10004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10005 }
10006 return resultobj;
10007 fail:
10008 return NULL;
10009 }
10010
10011
10012 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10013 PyObject *resultobj;
10014 wxLogChain *arg1 = (wxLogChain *) 0 ;
10015 wxLog *result;
10016 PyObject * obj0 = 0 ;
10017 char *kwnames[] = {
10018 (char *) "self", NULL
10019 };
10020
10021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10023 if (SWIG_arg_fail(1)) SWIG_fail;
10024 {
10025 PyThreadState* __tstate = wxPyBeginAllowThreads();
10026 result = (wxLog *)(arg1)->GetOldLog();
10027
10028 wxPyEndAllowThreads(__tstate);
10029 if (PyErr_Occurred()) SWIG_fail;
10030 }
10031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10032 return resultobj;
10033 fail:
10034 return NULL;
10035 }
10036
10037
10038 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10039 PyObject *obj;
10040 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10041 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10042 Py_INCREF(obj);
10043 return Py_BuildValue((char *)"");
10044 }
10045 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj;
10047 unsigned long result;
10048 char *kwnames[] = {
10049 NULL
10050 };
10051
10052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10053 {
10054 PyThreadState* __tstate = wxPyBeginAllowThreads();
10055 result = (unsigned long)wxSysErrorCode();
10056
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 {
10061 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10062 }
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10070 PyObject *resultobj;
10071 unsigned long arg1 = (unsigned long) 0 ;
10072 wxString result;
10073 PyObject * obj0 = 0 ;
10074 char *kwnames[] = {
10075 (char *) "nErrCode", NULL
10076 };
10077
10078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10079 if (obj0) {
10080 {
10081 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10082 if (SWIG_arg_fail(1)) SWIG_fail;
10083 }
10084 }
10085 {
10086 PyThreadState* __tstate = wxPyBeginAllowThreads();
10087 result = wxSysErrorMsg(arg1);
10088
10089 wxPyEndAllowThreads(__tstate);
10090 if (PyErr_Occurred()) SWIG_fail;
10091 }
10092 {
10093 #if wxUSE_UNICODE
10094 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10095 #else
10096 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10097 #endif
10098 }
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj;
10107 wxString *arg1 = 0 ;
10108 bool temp1 = false ;
10109 PyObject * obj0 = 0 ;
10110 char *kwnames[] = {
10111 (char *) "msg", NULL
10112 };
10113
10114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10115 {
10116 arg1 = wxString_in_helper(obj0);
10117 if (arg1 == NULL) SWIG_fail;
10118 temp1 = true;
10119 }
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 wxPyLogFatalError((wxString const &)*arg1);
10123
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 Py_INCREF(Py_None); resultobj = Py_None;
10128 {
10129 if (temp1)
10130 delete arg1;
10131 }
10132 return resultobj;
10133 fail:
10134 {
10135 if (temp1)
10136 delete arg1;
10137 }
10138 return NULL;
10139 }
10140
10141
10142 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10143 PyObject *resultobj;
10144 wxString *arg1 = 0 ;
10145 bool temp1 = false ;
10146 PyObject * obj0 = 0 ;
10147 char *kwnames[] = {
10148 (char *) "msg", NULL
10149 };
10150
10151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10152 {
10153 arg1 = wxString_in_helper(obj0);
10154 if (arg1 == NULL) SWIG_fail;
10155 temp1 = true;
10156 }
10157 {
10158 PyThreadState* __tstate = wxPyBeginAllowThreads();
10159 wxPyLogError((wxString const &)*arg1);
10160
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 Py_INCREF(Py_None); resultobj = Py_None;
10165 {
10166 if (temp1)
10167 delete arg1;
10168 }
10169 return resultobj;
10170 fail:
10171 {
10172 if (temp1)
10173 delete arg1;
10174 }
10175 return NULL;
10176 }
10177
10178
10179 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj;
10181 wxString *arg1 = 0 ;
10182 bool temp1 = false ;
10183 PyObject * obj0 = 0 ;
10184 char *kwnames[] = {
10185 (char *) "msg", NULL
10186 };
10187
10188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10189 {
10190 arg1 = wxString_in_helper(obj0);
10191 if (arg1 == NULL) SWIG_fail;
10192 temp1 = true;
10193 }
10194 {
10195 PyThreadState* __tstate = wxPyBeginAllowThreads();
10196 wxPyLogWarning((wxString const &)*arg1);
10197
10198 wxPyEndAllowThreads(__tstate);
10199 if (PyErr_Occurred()) SWIG_fail;
10200 }
10201 Py_INCREF(Py_None); resultobj = Py_None;
10202 {
10203 if (temp1)
10204 delete arg1;
10205 }
10206 return resultobj;
10207 fail:
10208 {
10209 if (temp1)
10210 delete arg1;
10211 }
10212 return NULL;
10213 }
10214
10215
10216 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10217 PyObject *resultobj;
10218 wxString *arg1 = 0 ;
10219 bool temp1 = false ;
10220 PyObject * obj0 = 0 ;
10221 char *kwnames[] = {
10222 (char *) "msg", NULL
10223 };
10224
10225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10226 {
10227 arg1 = wxString_in_helper(obj0);
10228 if (arg1 == NULL) SWIG_fail;
10229 temp1 = true;
10230 }
10231 {
10232 PyThreadState* __tstate = wxPyBeginAllowThreads();
10233 wxPyLogMessage((wxString const &)*arg1);
10234
10235 wxPyEndAllowThreads(__tstate);
10236 if (PyErr_Occurred()) SWIG_fail;
10237 }
10238 Py_INCREF(Py_None); resultobj = Py_None;
10239 {
10240 if (temp1)
10241 delete arg1;
10242 }
10243 return resultobj;
10244 fail:
10245 {
10246 if (temp1)
10247 delete arg1;
10248 }
10249 return NULL;
10250 }
10251
10252
10253 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10254 PyObject *resultobj;
10255 wxString *arg1 = 0 ;
10256 bool temp1 = false ;
10257 PyObject * obj0 = 0 ;
10258 char *kwnames[] = {
10259 (char *) "msg", NULL
10260 };
10261
10262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10263 {
10264 arg1 = wxString_in_helper(obj0);
10265 if (arg1 == NULL) SWIG_fail;
10266 temp1 = true;
10267 }
10268 {
10269 PyThreadState* __tstate = wxPyBeginAllowThreads();
10270 wxPyLogInfo((wxString const &)*arg1);
10271
10272 wxPyEndAllowThreads(__tstate);
10273 if (PyErr_Occurred()) SWIG_fail;
10274 }
10275 Py_INCREF(Py_None); resultobj = Py_None;
10276 {
10277 if (temp1)
10278 delete arg1;
10279 }
10280 return resultobj;
10281 fail:
10282 {
10283 if (temp1)
10284 delete arg1;
10285 }
10286 return NULL;
10287 }
10288
10289
10290 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj;
10292 wxString *arg1 = 0 ;
10293 bool temp1 = false ;
10294 PyObject * obj0 = 0 ;
10295 char *kwnames[] = {
10296 (char *) "msg", NULL
10297 };
10298
10299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10300 {
10301 arg1 = wxString_in_helper(obj0);
10302 if (arg1 == NULL) SWIG_fail;
10303 temp1 = true;
10304 }
10305 {
10306 PyThreadState* __tstate = wxPyBeginAllowThreads();
10307 wxPyLogDebug((wxString const &)*arg1);
10308
10309 wxPyEndAllowThreads(__tstate);
10310 if (PyErr_Occurred()) SWIG_fail;
10311 }
10312 Py_INCREF(Py_None); resultobj = Py_None;
10313 {
10314 if (temp1)
10315 delete arg1;
10316 }
10317 return resultobj;
10318 fail:
10319 {
10320 if (temp1)
10321 delete arg1;
10322 }
10323 return NULL;
10324 }
10325
10326
10327 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10328 PyObject *resultobj;
10329 wxString *arg1 = 0 ;
10330 bool temp1 = false ;
10331 PyObject * obj0 = 0 ;
10332 char *kwnames[] = {
10333 (char *) "msg", NULL
10334 };
10335
10336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10337 {
10338 arg1 = wxString_in_helper(obj0);
10339 if (arg1 == NULL) SWIG_fail;
10340 temp1 = true;
10341 }
10342 {
10343 PyThreadState* __tstate = wxPyBeginAllowThreads();
10344 wxPyLogVerbose((wxString const &)*arg1);
10345
10346 wxPyEndAllowThreads(__tstate);
10347 if (PyErr_Occurred()) SWIG_fail;
10348 }
10349 Py_INCREF(Py_None); resultobj = Py_None;
10350 {
10351 if (temp1)
10352 delete arg1;
10353 }
10354 return resultobj;
10355 fail:
10356 {
10357 if (temp1)
10358 delete arg1;
10359 }
10360 return NULL;
10361 }
10362
10363
10364 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10365 PyObject *resultobj;
10366 wxString *arg1 = 0 ;
10367 bool temp1 = false ;
10368 PyObject * obj0 = 0 ;
10369 char *kwnames[] = {
10370 (char *) "msg", NULL
10371 };
10372
10373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10374 {
10375 arg1 = wxString_in_helper(obj0);
10376 if (arg1 == NULL) SWIG_fail;
10377 temp1 = true;
10378 }
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 wxPyLogStatus((wxString const &)*arg1);
10382
10383 wxPyEndAllowThreads(__tstate);
10384 if (PyErr_Occurred()) SWIG_fail;
10385 }
10386 Py_INCREF(Py_None); resultobj = Py_None;
10387 {
10388 if (temp1)
10389 delete arg1;
10390 }
10391 return resultobj;
10392 fail:
10393 {
10394 if (temp1)
10395 delete arg1;
10396 }
10397 return NULL;
10398 }
10399
10400
10401 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10402 PyObject *resultobj;
10403 wxFrame *arg1 = (wxFrame *) 0 ;
10404 wxString *arg2 = 0 ;
10405 bool temp2 = false ;
10406 PyObject * obj0 = 0 ;
10407 PyObject * obj1 = 0 ;
10408 char *kwnames[] = {
10409 (char *) "pFrame",(char *) "msg", NULL
10410 };
10411
10412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10414 if (SWIG_arg_fail(1)) SWIG_fail;
10415 {
10416 arg2 = wxString_in_helper(obj1);
10417 if (arg2 == NULL) SWIG_fail;
10418 temp2 = true;
10419 }
10420 {
10421 PyThreadState* __tstate = wxPyBeginAllowThreads();
10422 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10423
10424 wxPyEndAllowThreads(__tstate);
10425 if (PyErr_Occurred()) SWIG_fail;
10426 }
10427 Py_INCREF(Py_None); resultobj = Py_None;
10428 {
10429 if (temp2)
10430 delete arg2;
10431 }
10432 return resultobj;
10433 fail:
10434 {
10435 if (temp2)
10436 delete arg2;
10437 }
10438 return NULL;
10439 }
10440
10441
10442 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10443 PyObject *resultobj;
10444 wxString *arg1 = 0 ;
10445 bool temp1 = false ;
10446 PyObject * obj0 = 0 ;
10447 char *kwnames[] = {
10448 (char *) "msg", NULL
10449 };
10450
10451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10452 {
10453 arg1 = wxString_in_helper(obj0);
10454 if (arg1 == NULL) SWIG_fail;
10455 temp1 = true;
10456 }
10457 {
10458 PyThreadState* __tstate = wxPyBeginAllowThreads();
10459 wxPyLogSysError((wxString const &)*arg1);
10460
10461 wxPyEndAllowThreads(__tstate);
10462 if (PyErr_Occurred()) SWIG_fail;
10463 }
10464 Py_INCREF(Py_None); resultobj = Py_None;
10465 {
10466 if (temp1)
10467 delete arg1;
10468 }
10469 return resultobj;
10470 fail:
10471 {
10472 if (temp1)
10473 delete arg1;
10474 }
10475 return NULL;
10476 }
10477
10478
10479 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10480 PyObject *resultobj;
10481 unsigned long arg1 ;
10482 wxString *arg2 = 0 ;
10483 bool temp2 = false ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486 char *kwnames[] = {
10487 (char *) "level",(char *) "msg", NULL
10488 };
10489
10490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10491 {
10492 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10493 if (SWIG_arg_fail(1)) SWIG_fail;
10494 }
10495 {
10496 arg2 = wxString_in_helper(obj1);
10497 if (arg2 == NULL) SWIG_fail;
10498 temp2 = true;
10499 }
10500 {
10501 PyThreadState* __tstate = wxPyBeginAllowThreads();
10502 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10503
10504 wxPyEndAllowThreads(__tstate);
10505 if (PyErr_Occurred()) SWIG_fail;
10506 }
10507 Py_INCREF(Py_None); resultobj = Py_None;
10508 {
10509 if (temp2)
10510 delete arg2;
10511 }
10512 return resultobj;
10513 fail:
10514 {
10515 if (temp2)
10516 delete arg2;
10517 }
10518 return NULL;
10519 }
10520
10521
10522 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10523 PyObject *resultobj;
10524 unsigned long arg1 ;
10525 wxString *arg2 = 0 ;
10526 bool temp2 = false ;
10527 PyObject * obj0 = 0 ;
10528 PyObject * obj1 = 0 ;
10529
10530 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10531 {
10532 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10533 if (SWIG_arg_fail(1)) SWIG_fail;
10534 }
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 wxPyLogTrace(arg1,(wxString const &)*arg2);
10543
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 Py_INCREF(Py_None); resultobj = Py_None;
10548 {
10549 if (temp2)
10550 delete arg2;
10551 }
10552 return resultobj;
10553 fail:
10554 {
10555 if (temp2)
10556 delete arg2;
10557 }
10558 return NULL;
10559 }
10560
10561
10562 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10563 PyObject *resultobj;
10564 wxString *arg1 = 0 ;
10565 wxString *arg2 = 0 ;
10566 bool temp1 = false ;
10567 bool temp2 = false ;
10568 PyObject * obj0 = 0 ;
10569 PyObject * obj1 = 0 ;
10570
10571 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10572 {
10573 arg1 = wxString_in_helper(obj0);
10574 if (arg1 == NULL) SWIG_fail;
10575 temp1 = true;
10576 }
10577 {
10578 arg2 = wxString_in_helper(obj1);
10579 if (arg2 == NULL) SWIG_fail;
10580 temp2 = true;
10581 }
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10585
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 Py_INCREF(Py_None); resultobj = Py_None;
10590 {
10591 if (temp1)
10592 delete arg1;
10593 }
10594 {
10595 if (temp2)
10596 delete arg2;
10597 }
10598 return resultobj;
10599 fail:
10600 {
10601 if (temp1)
10602 delete arg1;
10603 }
10604 {
10605 if (temp2)
10606 delete arg2;
10607 }
10608 return NULL;
10609 }
10610
10611
10612 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10613 int argc;
10614 PyObject *argv[3];
10615 int ii;
10616
10617 argc = PyObject_Length(args);
10618 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10619 argv[ii] = PyTuple_GetItem(args,ii);
10620 }
10621 if (argc == 2) {
10622 int _v;
10623 {
10624 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10625 }
10626 if (_v) {
10627 {
10628 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10629 }
10630 if (_v) {
10631 return _wrap_LogTrace__SWIG_1(self,args);
10632 }
10633 }
10634 }
10635 if (argc == 2) {
10636 int _v;
10637 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10638 if (_v) {
10639 {
10640 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10641 }
10642 if (_v) {
10643 return _wrap_LogTrace__SWIG_0(self,args);
10644 }
10645 }
10646 }
10647
10648 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10649 return NULL;
10650 }
10651
10652
10653 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10654 PyObject *resultobj;
10655 wxString *arg1 = 0 ;
10656 wxString *arg2 = 0 ;
10657 bool temp1 = false ;
10658 bool temp2 = false ;
10659 PyObject * obj0 = 0 ;
10660 PyObject * obj1 = 0 ;
10661 char *kwnames[] = {
10662 (char *) "title",(char *) "text", NULL
10663 };
10664
10665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10666 {
10667 arg1 = wxString_in_helper(obj0);
10668 if (arg1 == NULL) SWIG_fail;
10669 temp1 = true;
10670 }
10671 {
10672 arg2 = wxString_in_helper(obj1);
10673 if (arg2 == NULL) SWIG_fail;
10674 temp2 = true;
10675 }
10676 {
10677 PyThreadState* __tstate = wxPyBeginAllowThreads();
10678 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10679
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 Py_INCREF(Py_None); resultobj = Py_None;
10684 {
10685 if (temp1)
10686 delete arg1;
10687 }
10688 {
10689 if (temp2)
10690 delete arg2;
10691 }
10692 return resultobj;
10693 fail:
10694 {
10695 if (temp1)
10696 delete arg1;
10697 }
10698 {
10699 if (temp2)
10700 delete arg2;
10701 }
10702 return NULL;
10703 }
10704
10705
10706 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10707 PyObject *resultobj;
10708 wxLogNull *result;
10709 char *kwnames[] = {
10710 NULL
10711 };
10712
10713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 result = (wxLogNull *)new wxLogNull();
10717
10718 wxPyEndAllowThreads(__tstate);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10722 return resultobj;
10723 fail:
10724 return NULL;
10725 }
10726
10727
10728 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10729 PyObject *resultobj;
10730 wxLogNull *arg1 = (wxLogNull *) 0 ;
10731 PyObject * obj0 = 0 ;
10732 char *kwnames[] = {
10733 (char *) "self", NULL
10734 };
10735
10736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10738 if (SWIG_arg_fail(1)) SWIG_fail;
10739 {
10740 PyThreadState* __tstate = wxPyBeginAllowThreads();
10741 delete arg1;
10742
10743 wxPyEndAllowThreads(__tstate);
10744 if (PyErr_Occurred()) SWIG_fail;
10745 }
10746 Py_INCREF(Py_None); resultobj = Py_None;
10747 return resultobj;
10748 fail:
10749 return NULL;
10750 }
10751
10752
10753 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10754 PyObject *obj;
10755 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10756 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10757 Py_INCREF(obj);
10758 return Py_BuildValue((char *)"");
10759 }
10760 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10761 PyObject *resultobj;
10762 wxPyLog *result;
10763 char *kwnames[] = {
10764 NULL
10765 };
10766
10767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 result = (wxPyLog *)new wxPyLog();
10771
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10783 PyObject *resultobj;
10784 wxPyLog *arg1 = (wxPyLog *) 0 ;
10785 PyObject *arg2 = (PyObject *) 0 ;
10786 PyObject *arg3 = (PyObject *) 0 ;
10787 PyObject * obj0 = 0 ;
10788 PyObject * obj1 = 0 ;
10789 PyObject * obj2 = 0 ;
10790 char *kwnames[] = {
10791 (char *) "self",(char *) "self",(char *) "_class", NULL
10792 };
10793
10794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10796 if (SWIG_arg_fail(1)) SWIG_fail;
10797 arg2 = obj1;
10798 arg3 = obj2;
10799 {
10800 PyThreadState* __tstate = wxPyBeginAllowThreads();
10801 (arg1)->_setCallbackInfo(arg2,arg3);
10802
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 Py_INCREF(Py_None); resultobj = Py_None;
10807 return resultobj;
10808 fail:
10809 return NULL;
10810 }
10811
10812
10813 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10814 PyObject *obj;
10815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10816 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10817 Py_INCREF(obj);
10818 return Py_BuildValue((char *)"");
10819 }
10820 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10821 PyObject *resultobj;
10822 int arg1 ;
10823 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10824 int arg3 = (int) wxKILL_NOCHILDREN ;
10825 wxKillError result;
10826 PyObject * obj0 = 0 ;
10827 PyObject * obj1 = 0 ;
10828 PyObject * obj2 = 0 ;
10829 char *kwnames[] = {
10830 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10831 };
10832
10833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10834 {
10835 arg1 = (int)(SWIG_As_int(obj0));
10836 if (SWIG_arg_fail(1)) SWIG_fail;
10837 }
10838 if (obj1) {
10839 {
10840 arg2 = (wxSignal)(SWIG_As_int(obj1));
10841 if (SWIG_arg_fail(2)) SWIG_fail;
10842 }
10843 }
10844 if (obj2) {
10845 {
10846 arg3 = (int)(SWIG_As_int(obj2));
10847 if (SWIG_arg_fail(3)) SWIG_fail;
10848 }
10849 }
10850 {
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10853
10854 wxPyEndAllowThreads(__tstate);
10855 if (PyErr_Occurred()) SWIG_fail;
10856 }
10857 resultobj = SWIG_From_int((result));
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj;
10866 int arg1 ;
10867 bool result;
10868 PyObject * obj0 = 0 ;
10869 char *kwnames[] = {
10870 (char *) "pid", NULL
10871 };
10872
10873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10874 {
10875 arg1 = (int)(SWIG_As_int(obj0));
10876 if (SWIG_arg_fail(1)) SWIG_fail;
10877 }
10878 {
10879 PyThreadState* __tstate = wxPyBeginAllowThreads();
10880 result = (bool)wxPyProcess::Exists(arg1);
10881
10882 wxPyEndAllowThreads(__tstate);
10883 if (PyErr_Occurred()) SWIG_fail;
10884 }
10885 {
10886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10887 }
10888 return resultobj;
10889 fail:
10890 return NULL;
10891 }
10892
10893
10894 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10895 PyObject *resultobj;
10896 wxString *arg1 = 0 ;
10897 int arg2 = (int) wxEXEC_ASYNC ;
10898 wxPyProcess *result;
10899 bool temp1 = false ;
10900 PyObject * obj0 = 0 ;
10901 PyObject * obj1 = 0 ;
10902 char *kwnames[] = {
10903 (char *) "cmd",(char *) "flags", NULL
10904 };
10905
10906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10907 {
10908 arg1 = wxString_in_helper(obj0);
10909 if (arg1 == NULL) SWIG_fail;
10910 temp1 = true;
10911 }
10912 if (obj1) {
10913 {
10914 arg2 = (int)(SWIG_As_int(obj1));
10915 if (SWIG_arg_fail(2)) SWIG_fail;
10916 }
10917 }
10918 {
10919 PyThreadState* __tstate = wxPyBeginAllowThreads();
10920 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10921
10922 wxPyEndAllowThreads(__tstate);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10926 {
10927 if (temp1)
10928 delete arg1;
10929 }
10930 return resultobj;
10931 fail:
10932 {
10933 if (temp1)
10934 delete arg1;
10935 }
10936 return NULL;
10937 }
10938
10939
10940 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10941 PyObject *resultobj;
10942 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10943 int arg2 = (int) -1 ;
10944 wxPyProcess *result;
10945 PyObject * obj0 = 0 ;
10946 PyObject * obj1 = 0 ;
10947 char *kwnames[] = {
10948 (char *) "parent",(char *) "id", NULL
10949 };
10950
10951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10952 if (obj0) {
10953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10954 if (SWIG_arg_fail(1)) SWIG_fail;
10955 }
10956 if (obj1) {
10957 {
10958 arg2 = (int)(SWIG_As_int(obj1));
10959 if (SWIG_arg_fail(2)) SWIG_fail;
10960 }
10961 }
10962 {
10963 PyThreadState* __tstate = wxPyBeginAllowThreads();
10964 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10965
10966 wxPyEndAllowThreads(__tstate);
10967 if (PyErr_Occurred()) SWIG_fail;
10968 }
10969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10970 return resultobj;
10971 fail:
10972 return NULL;
10973 }
10974
10975
10976 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10977 PyObject *resultobj;
10978 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10979 PyObject *arg2 = (PyObject *) 0 ;
10980 PyObject *arg3 = (PyObject *) 0 ;
10981 PyObject * obj0 = 0 ;
10982 PyObject * obj1 = 0 ;
10983 PyObject * obj2 = 0 ;
10984 char *kwnames[] = {
10985 (char *) "self",(char *) "self",(char *) "_class", NULL
10986 };
10987
10988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10990 if (SWIG_arg_fail(1)) SWIG_fail;
10991 arg2 = obj1;
10992 arg3 = obj2;
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 (arg1)->_setCallbackInfo(arg2,arg3);
10996
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 Py_INCREF(Py_None); resultobj = Py_None;
11001 return resultobj;
11002 fail:
11003 return NULL;
11004 }
11005
11006
11007 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj;
11009 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11010 int arg2 ;
11011 int arg3 ;
11012 PyObject * obj0 = 0 ;
11013 PyObject * obj1 = 0 ;
11014 PyObject * obj2 = 0 ;
11015 char *kwnames[] = {
11016 (char *) "self",(char *) "pid",(char *) "status", NULL
11017 };
11018
11019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11021 if (SWIG_arg_fail(1)) SWIG_fail;
11022 {
11023 arg2 = (int)(SWIG_As_int(obj1));
11024 if (SWIG_arg_fail(2)) SWIG_fail;
11025 }
11026 {
11027 arg3 = (int)(SWIG_As_int(obj2));
11028 if (SWIG_arg_fail(3)) SWIG_fail;
11029 }
11030 {
11031 PyThreadState* __tstate = wxPyBeginAllowThreads();
11032 (arg1)->base_OnTerminate(arg2,arg3);
11033
11034 wxPyEndAllowThreads(__tstate);
11035 if (PyErr_Occurred()) SWIG_fail;
11036 }
11037 Py_INCREF(Py_None); resultobj = Py_None;
11038 return resultobj;
11039 fail:
11040 return NULL;
11041 }
11042
11043
11044 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11045 PyObject *resultobj;
11046 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11047 PyObject * obj0 = 0 ;
11048 char *kwnames[] = {
11049 (char *) "self", NULL
11050 };
11051
11052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11054 if (SWIG_arg_fail(1)) SWIG_fail;
11055 {
11056 PyThreadState* __tstate = wxPyBeginAllowThreads();
11057 (arg1)->Redirect();
11058
11059 wxPyEndAllowThreads(__tstate);
11060 if (PyErr_Occurred()) SWIG_fail;
11061 }
11062 Py_INCREF(Py_None); resultobj = Py_None;
11063 return resultobj;
11064 fail:
11065 return NULL;
11066 }
11067
11068
11069 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11070 PyObject *resultobj;
11071 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11072 bool result;
11073 PyObject * obj0 = 0 ;
11074 char *kwnames[] = {
11075 (char *) "self", NULL
11076 };
11077
11078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11080 if (SWIG_arg_fail(1)) SWIG_fail;
11081 {
11082 PyThreadState* __tstate = wxPyBeginAllowThreads();
11083 result = (bool)(arg1)->IsRedirected();
11084
11085 wxPyEndAllowThreads(__tstate);
11086 if (PyErr_Occurred()) SWIG_fail;
11087 }
11088 {
11089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11090 }
11091 return resultobj;
11092 fail:
11093 return NULL;
11094 }
11095
11096
11097 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11098 PyObject *resultobj;
11099 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11100 PyObject * obj0 = 0 ;
11101 char *kwnames[] = {
11102 (char *) "self", NULL
11103 };
11104
11105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11107 if (SWIG_arg_fail(1)) SWIG_fail;
11108 {
11109 PyThreadState* __tstate = wxPyBeginAllowThreads();
11110 (arg1)->Detach();
11111
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 Py_INCREF(Py_None); resultobj = Py_None;
11116 return resultobj;
11117 fail:
11118 return NULL;
11119 }
11120
11121
11122 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11123 PyObject *resultobj;
11124 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11125 wxInputStream *result;
11126 PyObject * obj0 = 0 ;
11127 char *kwnames[] = {
11128 (char *) "self", NULL
11129 };
11130
11131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11133 if (SWIG_arg_fail(1)) SWIG_fail;
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 result = (wxInputStream *)(arg1)->GetInputStream();
11137
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 {
11142 wxPyInputStream * _ptr = NULL;
11143
11144 if (result) {
11145 _ptr = new wxPyInputStream(result);
11146 }
11147 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11148 }
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj;
11157 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11158 wxInputStream *result;
11159 PyObject * obj0 = 0 ;
11160 char *kwnames[] = {
11161 (char *) "self", NULL
11162 };
11163
11164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11166 if (SWIG_arg_fail(1)) SWIG_fail;
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 result = (wxInputStream *)(arg1)->GetErrorStream();
11170
11171 wxPyEndAllowThreads(__tstate);
11172 if (PyErr_Occurred()) SWIG_fail;
11173 }
11174 {
11175 wxPyInputStream * _ptr = NULL;
11176
11177 if (result) {
11178 _ptr = new wxPyInputStream(result);
11179 }
11180 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11181 }
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11189 PyObject *resultobj;
11190 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11191 wxOutputStream *result;
11192 PyObject * obj0 = 0 ;
11193 char *kwnames[] = {
11194 (char *) "self", NULL
11195 };
11196
11197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11199 if (SWIG_arg_fail(1)) SWIG_fail;
11200 {
11201 PyThreadState* __tstate = wxPyBeginAllowThreads();
11202 result = (wxOutputStream *)(arg1)->GetOutputStream();
11203
11204 wxPyEndAllowThreads(__tstate);
11205 if (PyErr_Occurred()) SWIG_fail;
11206 }
11207 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11208 return resultobj;
11209 fail:
11210 return NULL;
11211 }
11212
11213
11214 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11215 PyObject *resultobj;
11216 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11217 PyObject * obj0 = 0 ;
11218 char *kwnames[] = {
11219 (char *) "self", NULL
11220 };
11221
11222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11224 if (SWIG_arg_fail(1)) SWIG_fail;
11225 {
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 (arg1)->CloseOutput();
11228
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 Py_INCREF(Py_None); resultobj = Py_None;
11233 return resultobj;
11234 fail:
11235 return NULL;
11236 }
11237
11238
11239 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11240 PyObject *resultobj;
11241 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11242 bool result;
11243 PyObject * obj0 = 0 ;
11244 char *kwnames[] = {
11245 (char *) "self", NULL
11246 };
11247
11248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11250 if (SWIG_arg_fail(1)) SWIG_fail;
11251 {
11252 PyThreadState* __tstate = wxPyBeginAllowThreads();
11253 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11254
11255 wxPyEndAllowThreads(__tstate);
11256 if (PyErr_Occurred()) SWIG_fail;
11257 }
11258 {
11259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11260 }
11261 return resultobj;
11262 fail:
11263 return NULL;
11264 }
11265
11266
11267 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11268 PyObject *resultobj;
11269 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11270 bool result;
11271 PyObject * obj0 = 0 ;
11272 char *kwnames[] = {
11273 (char *) "self", NULL
11274 };
11275
11276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11278 if (SWIG_arg_fail(1)) SWIG_fail;
11279 {
11280 PyThreadState* __tstate = wxPyBeginAllowThreads();
11281 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11282
11283 wxPyEndAllowThreads(__tstate);
11284 if (PyErr_Occurred()) SWIG_fail;
11285 }
11286 {
11287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11288 }
11289 return resultobj;
11290 fail:
11291 return NULL;
11292 }
11293
11294
11295 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11296 PyObject *resultobj;
11297 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11298 bool result;
11299 PyObject * obj0 = 0 ;
11300 char *kwnames[] = {
11301 (char *) "self", NULL
11302 };
11303
11304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11306 if (SWIG_arg_fail(1)) SWIG_fail;
11307 {
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11310
11311 wxPyEndAllowThreads(__tstate);
11312 if (PyErr_Occurred()) SWIG_fail;
11313 }
11314 {
11315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11316 }
11317 return resultobj;
11318 fail:
11319 return NULL;
11320 }
11321
11322
11323 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11324 PyObject *obj;
11325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11326 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11327 Py_INCREF(obj);
11328 return Py_BuildValue((char *)"");
11329 }
11330 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11331 PyObject *resultobj;
11332 int arg1 = (int) 0 ;
11333 int arg2 = (int) 0 ;
11334 int arg3 = (int) 0 ;
11335 wxProcessEvent *result;
11336 PyObject * obj0 = 0 ;
11337 PyObject * obj1 = 0 ;
11338 PyObject * obj2 = 0 ;
11339 char *kwnames[] = {
11340 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11341 };
11342
11343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11344 if (obj0) {
11345 {
11346 arg1 = (int)(SWIG_As_int(obj0));
11347 if (SWIG_arg_fail(1)) SWIG_fail;
11348 }
11349 }
11350 if (obj1) {
11351 {
11352 arg2 = (int)(SWIG_As_int(obj1));
11353 if (SWIG_arg_fail(2)) SWIG_fail;
11354 }
11355 }
11356 if (obj2) {
11357 {
11358 arg3 = (int)(SWIG_As_int(obj2));
11359 if (SWIG_arg_fail(3)) SWIG_fail;
11360 }
11361 }
11362 {
11363 PyThreadState* __tstate = wxPyBeginAllowThreads();
11364 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11365
11366 wxPyEndAllowThreads(__tstate);
11367 if (PyErr_Occurred()) SWIG_fail;
11368 }
11369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11370 return resultobj;
11371 fail:
11372 return NULL;
11373 }
11374
11375
11376 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11377 PyObject *resultobj;
11378 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11379 int result;
11380 PyObject * obj0 = 0 ;
11381 char *kwnames[] = {
11382 (char *) "self", NULL
11383 };
11384
11385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11387 if (SWIG_arg_fail(1)) SWIG_fail;
11388 {
11389 PyThreadState* __tstate = wxPyBeginAllowThreads();
11390 result = (int)(arg1)->GetPid();
11391
11392 wxPyEndAllowThreads(__tstate);
11393 if (PyErr_Occurred()) SWIG_fail;
11394 }
11395 {
11396 resultobj = SWIG_From_int((int)(result));
11397 }
11398 return resultobj;
11399 fail:
11400 return NULL;
11401 }
11402
11403
11404 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11405 PyObject *resultobj;
11406 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11407 int result;
11408 PyObject * obj0 = 0 ;
11409 char *kwnames[] = {
11410 (char *) "self", NULL
11411 };
11412
11413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11415 if (SWIG_arg_fail(1)) SWIG_fail;
11416 {
11417 PyThreadState* __tstate = wxPyBeginAllowThreads();
11418 result = (int)(arg1)->GetExitCode();
11419
11420 wxPyEndAllowThreads(__tstate);
11421 if (PyErr_Occurred()) SWIG_fail;
11422 }
11423 {
11424 resultobj = SWIG_From_int((int)(result));
11425 }
11426 return resultobj;
11427 fail:
11428 return NULL;
11429 }
11430
11431
11432 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11433 PyObject *resultobj;
11434 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11435 int arg2 ;
11436 PyObject * obj0 = 0 ;
11437 PyObject * obj1 = 0 ;
11438 char *kwnames[] = {
11439 (char *) "self",(char *) "m_pid", NULL
11440 };
11441
11442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11444 if (SWIG_arg_fail(1)) SWIG_fail;
11445 {
11446 arg2 = (int)(SWIG_As_int(obj1));
11447 if (SWIG_arg_fail(2)) SWIG_fail;
11448 }
11449 if (arg1) (arg1)->m_pid = arg2;
11450
11451 Py_INCREF(Py_None); resultobj = Py_None;
11452 return resultobj;
11453 fail:
11454 return NULL;
11455 }
11456
11457
11458 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11459 PyObject *resultobj;
11460 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11461 int result;
11462 PyObject * obj0 = 0 ;
11463 char *kwnames[] = {
11464 (char *) "self", NULL
11465 };
11466
11467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11469 if (SWIG_arg_fail(1)) SWIG_fail;
11470 result = (int) ((arg1)->m_pid);
11471
11472 {
11473 resultobj = SWIG_From_int((int)(result));
11474 }
11475 return resultobj;
11476 fail:
11477 return NULL;
11478 }
11479
11480
11481 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj;
11483 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11484 int arg2 ;
11485 PyObject * obj0 = 0 ;
11486 PyObject * obj1 = 0 ;
11487 char *kwnames[] = {
11488 (char *) "self",(char *) "m_exitcode", NULL
11489 };
11490
11491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11493 if (SWIG_arg_fail(1)) SWIG_fail;
11494 {
11495 arg2 = (int)(SWIG_As_int(obj1));
11496 if (SWIG_arg_fail(2)) SWIG_fail;
11497 }
11498 if (arg1) (arg1)->m_exitcode = arg2;
11499
11500 Py_INCREF(Py_None); resultobj = Py_None;
11501 return resultobj;
11502 fail:
11503 return NULL;
11504 }
11505
11506
11507 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj;
11509 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11510 int result;
11511 PyObject * obj0 = 0 ;
11512 char *kwnames[] = {
11513 (char *) "self", NULL
11514 };
11515
11516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11518 if (SWIG_arg_fail(1)) SWIG_fail;
11519 result = (int) ((arg1)->m_exitcode);
11520
11521 {
11522 resultobj = SWIG_From_int((int)(result));
11523 }
11524 return resultobj;
11525 fail:
11526 return NULL;
11527 }
11528
11529
11530 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11531 PyObject *obj;
11532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11533 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11534 Py_INCREF(obj);
11535 return Py_BuildValue((char *)"");
11536 }
11537 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11538 PyObject *resultobj;
11539 wxString *arg1 = 0 ;
11540 int arg2 = (int) wxEXEC_ASYNC ;
11541 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11542 long result;
11543 bool temp1 = false ;
11544 PyObject * obj0 = 0 ;
11545 PyObject * obj1 = 0 ;
11546 PyObject * obj2 = 0 ;
11547 char *kwnames[] = {
11548 (char *) "command",(char *) "flags",(char *) "process", NULL
11549 };
11550
11551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11552 {
11553 arg1 = wxString_in_helper(obj0);
11554 if (arg1 == NULL) SWIG_fail;
11555 temp1 = true;
11556 }
11557 if (obj1) {
11558 {
11559 arg2 = (int)(SWIG_As_int(obj1));
11560 if (SWIG_arg_fail(2)) SWIG_fail;
11561 }
11562 }
11563 if (obj2) {
11564 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11565 if (SWIG_arg_fail(3)) SWIG_fail;
11566 }
11567 {
11568 if (!wxPyCheckForApp()) SWIG_fail;
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11571
11572 wxPyEndAllowThreads(__tstate);
11573 if (PyErr_Occurred()) SWIG_fail;
11574 }
11575 {
11576 resultobj = SWIG_From_long((long)(result));
11577 }
11578 {
11579 if (temp1)
11580 delete arg1;
11581 }
11582 return resultobj;
11583 fail:
11584 {
11585 if (temp1)
11586 delete arg1;
11587 }
11588 return NULL;
11589 }
11590
11591
11592 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11593 PyObject *resultobj;
11594 long arg1 ;
11595 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11596 wxKillError *arg3 = (wxKillError *) 0 ;
11597 int arg4 = (int) wxKILL_NOCHILDREN ;
11598 int result;
11599 wxKillError temp3 ;
11600 PyObject * obj0 = 0 ;
11601 PyObject * obj1 = 0 ;
11602 PyObject * obj2 = 0 ;
11603 char *kwnames[] = {
11604 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11605 };
11606
11607 {
11608 arg3 = &temp3;
11609 }
11610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11611 {
11612 arg1 = (long)(SWIG_As_long(obj0));
11613 if (SWIG_arg_fail(1)) SWIG_fail;
11614 }
11615 if (obj1) {
11616 {
11617 arg2 = (wxSignal)(SWIG_As_int(obj1));
11618 if (SWIG_arg_fail(2)) SWIG_fail;
11619 }
11620 }
11621 if (obj2) {
11622 {
11623 arg4 = (int)(SWIG_As_int(obj2));
11624 if (SWIG_arg_fail(4)) SWIG_fail;
11625 }
11626 }
11627 {
11628 PyThreadState* __tstate = wxPyBeginAllowThreads();
11629 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11630
11631 wxPyEndAllowThreads(__tstate);
11632 if (PyErr_Occurred()) SWIG_fail;
11633 }
11634 {
11635 resultobj = SWIG_From_int((int)(result));
11636 }
11637 {
11638 PyObject* o;
11639 o = PyInt_FromLong((long) (*arg3));
11640 resultobj = t_output_helper(resultobj, o);
11641 }
11642 return resultobj;
11643 fail:
11644 return NULL;
11645 }
11646
11647
11648 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11649 PyObject *resultobj;
11650 int arg1 = (int) wxJOYSTICK1 ;
11651 wxJoystick *result;
11652 PyObject * obj0 = 0 ;
11653 char *kwnames[] = {
11654 (char *) "joystick", NULL
11655 };
11656
11657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11658 if (obj0) {
11659 {
11660 arg1 = (int)(SWIG_As_int(obj0));
11661 if (SWIG_arg_fail(1)) SWIG_fail;
11662 }
11663 }
11664 {
11665 if (!wxPyCheckForApp()) SWIG_fail;
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (wxJoystick *)new wxJoystick(arg1);
11668
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxJoystick *arg1 = (wxJoystick *) 0 ;
11682 PyObject * obj0 = 0 ;
11683 char *kwnames[] = {
11684 (char *) "self", NULL
11685 };
11686
11687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11689 if (SWIG_arg_fail(1)) SWIG_fail;
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 delete arg1;
11693
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 Py_INCREF(Py_None); resultobj = Py_None;
11698 return resultobj;
11699 fail:
11700 return NULL;
11701 }
11702
11703
11704 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11705 PyObject *resultobj;
11706 wxJoystick *arg1 = (wxJoystick *) 0 ;
11707 wxPoint result;
11708 PyObject * obj0 = 0 ;
11709 char *kwnames[] = {
11710 (char *) "self", NULL
11711 };
11712
11713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11715 if (SWIG_arg_fail(1)) SWIG_fail;
11716 {
11717 PyThreadState* __tstate = wxPyBeginAllowThreads();
11718 result = (arg1)->GetPosition();
11719
11720 wxPyEndAllowThreads(__tstate);
11721 if (PyErr_Occurred()) SWIG_fail;
11722 }
11723 {
11724 wxPoint * resultptr;
11725 resultptr = new wxPoint((wxPoint &)(result));
11726 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11727 }
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11735 PyObject *resultobj;
11736 wxJoystick *arg1 = (wxJoystick *) 0 ;
11737 int result;
11738 PyObject * obj0 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "self", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11745 if (SWIG_arg_fail(1)) SWIG_fail;
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 result = (int)(arg1)->GetZPosition();
11749
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 {
11754 resultobj = SWIG_From_int((int)(result));
11755 }
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11763 PyObject *resultobj;
11764 wxJoystick *arg1 = (wxJoystick *) 0 ;
11765 int result;
11766 PyObject * obj0 = 0 ;
11767 char *kwnames[] = {
11768 (char *) "self", NULL
11769 };
11770
11771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11773 if (SWIG_arg_fail(1)) SWIG_fail;
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 result = (int)(arg1)->GetButtonState();
11777
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 {
11782 resultobj = SWIG_From_int((int)(result));
11783 }
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11791 PyObject *resultobj;
11792 wxJoystick *arg1 = (wxJoystick *) 0 ;
11793 int result;
11794 PyObject * obj0 = 0 ;
11795 char *kwnames[] = {
11796 (char *) "self", NULL
11797 };
11798
11799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11801 if (SWIG_arg_fail(1)) SWIG_fail;
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 result = (int)(arg1)->GetPOVPosition();
11805
11806 wxPyEndAllowThreads(__tstate);
11807 if (PyErr_Occurred()) SWIG_fail;
11808 }
11809 {
11810 resultobj = SWIG_From_int((int)(result));
11811 }
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11819 PyObject *resultobj;
11820 wxJoystick *arg1 = (wxJoystick *) 0 ;
11821 int result;
11822 PyObject * obj0 = 0 ;
11823 char *kwnames[] = {
11824 (char *) "self", NULL
11825 };
11826
11827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11829 if (SWIG_arg_fail(1)) SWIG_fail;
11830 {
11831 PyThreadState* __tstate = wxPyBeginAllowThreads();
11832 result = (int)(arg1)->GetPOVCTSPosition();
11833
11834 wxPyEndAllowThreads(__tstate);
11835 if (PyErr_Occurred()) SWIG_fail;
11836 }
11837 {
11838 resultobj = SWIG_From_int((int)(result));
11839 }
11840 return resultobj;
11841 fail:
11842 return NULL;
11843 }
11844
11845
11846 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11847 PyObject *resultobj;
11848 wxJoystick *arg1 = (wxJoystick *) 0 ;
11849 int result;
11850 PyObject * obj0 = 0 ;
11851 char *kwnames[] = {
11852 (char *) "self", NULL
11853 };
11854
11855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11857 if (SWIG_arg_fail(1)) SWIG_fail;
11858 {
11859 PyThreadState* __tstate = wxPyBeginAllowThreads();
11860 result = (int)(arg1)->GetRudderPosition();
11861
11862 wxPyEndAllowThreads(__tstate);
11863 if (PyErr_Occurred()) SWIG_fail;
11864 }
11865 {
11866 resultobj = SWIG_From_int((int)(result));
11867 }
11868 return resultobj;
11869 fail:
11870 return NULL;
11871 }
11872
11873
11874 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11875 PyObject *resultobj;
11876 wxJoystick *arg1 = (wxJoystick *) 0 ;
11877 int result;
11878 PyObject * obj0 = 0 ;
11879 char *kwnames[] = {
11880 (char *) "self", NULL
11881 };
11882
11883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11885 if (SWIG_arg_fail(1)) SWIG_fail;
11886 {
11887 PyThreadState* __tstate = wxPyBeginAllowThreads();
11888 result = (int)(arg1)->GetUPosition();
11889
11890 wxPyEndAllowThreads(__tstate);
11891 if (PyErr_Occurred()) SWIG_fail;
11892 }
11893 {
11894 resultobj = SWIG_From_int((int)(result));
11895 }
11896 return resultobj;
11897 fail:
11898 return NULL;
11899 }
11900
11901
11902 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11903 PyObject *resultobj;
11904 wxJoystick *arg1 = (wxJoystick *) 0 ;
11905 int result;
11906 PyObject * obj0 = 0 ;
11907 char *kwnames[] = {
11908 (char *) "self", NULL
11909 };
11910
11911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11913 if (SWIG_arg_fail(1)) SWIG_fail;
11914 {
11915 PyThreadState* __tstate = wxPyBeginAllowThreads();
11916 result = (int)(arg1)->GetVPosition();
11917
11918 wxPyEndAllowThreads(__tstate);
11919 if (PyErr_Occurred()) SWIG_fail;
11920 }
11921 {
11922 resultobj = SWIG_From_int((int)(result));
11923 }
11924 return resultobj;
11925 fail:
11926 return NULL;
11927 }
11928
11929
11930 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11931 PyObject *resultobj;
11932 wxJoystick *arg1 = (wxJoystick *) 0 ;
11933 int result;
11934 PyObject * obj0 = 0 ;
11935 char *kwnames[] = {
11936 (char *) "self", NULL
11937 };
11938
11939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11941 if (SWIG_arg_fail(1)) SWIG_fail;
11942 {
11943 PyThreadState* __tstate = wxPyBeginAllowThreads();
11944 result = (int)(arg1)->GetMovementThreshold();
11945
11946 wxPyEndAllowThreads(__tstate);
11947 if (PyErr_Occurred()) SWIG_fail;
11948 }
11949 {
11950 resultobj = SWIG_From_int((int)(result));
11951 }
11952 return resultobj;
11953 fail:
11954 return NULL;
11955 }
11956
11957
11958 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11959 PyObject *resultobj;
11960 wxJoystick *arg1 = (wxJoystick *) 0 ;
11961 int arg2 ;
11962 PyObject * obj0 = 0 ;
11963 PyObject * obj1 = 0 ;
11964 char *kwnames[] = {
11965 (char *) "self",(char *) "threshold", NULL
11966 };
11967
11968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11970 if (SWIG_arg_fail(1)) SWIG_fail;
11971 {
11972 arg2 = (int)(SWIG_As_int(obj1));
11973 if (SWIG_arg_fail(2)) SWIG_fail;
11974 }
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 (arg1)->SetMovementThreshold(arg2);
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 Py_INCREF(Py_None); resultobj = Py_None;
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj;
11991 wxJoystick *arg1 = (wxJoystick *) 0 ;
11992 bool result;
11993 PyObject * obj0 = 0 ;
11994 char *kwnames[] = {
11995 (char *) "self", NULL
11996 };
11997
11998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12000 if (SWIG_arg_fail(1)) SWIG_fail;
12001 {
12002 PyThreadState* __tstate = wxPyBeginAllowThreads();
12003 result = (bool)(arg1)->IsOk();
12004
12005 wxPyEndAllowThreads(__tstate);
12006 if (PyErr_Occurred()) SWIG_fail;
12007 }
12008 {
12009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12010 }
12011 return resultobj;
12012 fail:
12013 return NULL;
12014 }
12015
12016
12017 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj;
12019 wxJoystick *arg1 = (wxJoystick *) 0 ;
12020 int result;
12021 PyObject * obj0 = 0 ;
12022 char *kwnames[] = {
12023 (char *) "self", NULL
12024 };
12025
12026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12028 if (SWIG_arg_fail(1)) SWIG_fail;
12029 {
12030 PyThreadState* __tstate = wxPyBeginAllowThreads();
12031 result = (int)(arg1)->GetNumberJoysticks();
12032
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 {
12037 resultobj = SWIG_From_int((int)(result));
12038 }
12039 return resultobj;
12040 fail:
12041 return NULL;
12042 }
12043
12044
12045 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12046 PyObject *resultobj;
12047 wxJoystick *arg1 = (wxJoystick *) 0 ;
12048 int result;
12049 PyObject * obj0 = 0 ;
12050 char *kwnames[] = {
12051 (char *) "self", NULL
12052 };
12053
12054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12056 if (SWIG_arg_fail(1)) SWIG_fail;
12057 {
12058 PyThreadState* __tstate = wxPyBeginAllowThreads();
12059 result = (int)(arg1)->GetManufacturerId();
12060
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 {
12065 resultobj = SWIG_From_int((int)(result));
12066 }
12067 return resultobj;
12068 fail:
12069 return NULL;
12070 }
12071
12072
12073 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12074 PyObject *resultobj;
12075 wxJoystick *arg1 = (wxJoystick *) 0 ;
12076 int result;
12077 PyObject * obj0 = 0 ;
12078 char *kwnames[] = {
12079 (char *) "self", NULL
12080 };
12081
12082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12084 if (SWIG_arg_fail(1)) SWIG_fail;
12085 {
12086 PyThreadState* __tstate = wxPyBeginAllowThreads();
12087 result = (int)(arg1)->GetProductId();
12088
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 {
12093 resultobj = SWIG_From_int((int)(result));
12094 }
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12102 PyObject *resultobj;
12103 wxJoystick *arg1 = (wxJoystick *) 0 ;
12104 wxString result;
12105 PyObject * obj0 = 0 ;
12106 char *kwnames[] = {
12107 (char *) "self", NULL
12108 };
12109
12110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12112 if (SWIG_arg_fail(1)) SWIG_fail;
12113 {
12114 PyThreadState* __tstate = wxPyBeginAllowThreads();
12115 result = (arg1)->GetProductName();
12116
12117 wxPyEndAllowThreads(__tstate);
12118 if (PyErr_Occurred()) SWIG_fail;
12119 }
12120 {
12121 #if wxUSE_UNICODE
12122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12123 #else
12124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12125 #endif
12126 }
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj;
12135 wxJoystick *arg1 = (wxJoystick *) 0 ;
12136 int result;
12137 PyObject * obj0 = 0 ;
12138 char *kwnames[] = {
12139 (char *) "self", NULL
12140 };
12141
12142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12144 if (SWIG_arg_fail(1)) SWIG_fail;
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 result = (int)(arg1)->GetXMin();
12148
12149 wxPyEndAllowThreads(__tstate);
12150 if (PyErr_Occurred()) SWIG_fail;
12151 }
12152 {
12153 resultobj = SWIG_From_int((int)(result));
12154 }
12155 return resultobj;
12156 fail:
12157 return NULL;
12158 }
12159
12160
12161 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12162 PyObject *resultobj;
12163 wxJoystick *arg1 = (wxJoystick *) 0 ;
12164 int result;
12165 PyObject * obj0 = 0 ;
12166 char *kwnames[] = {
12167 (char *) "self", NULL
12168 };
12169
12170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12172 if (SWIG_arg_fail(1)) SWIG_fail;
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (int)(arg1)->GetYMin();
12176
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 {
12181 resultobj = SWIG_From_int((int)(result));
12182 }
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12190 PyObject *resultobj;
12191 wxJoystick *arg1 = (wxJoystick *) 0 ;
12192 int result;
12193 PyObject * obj0 = 0 ;
12194 char *kwnames[] = {
12195 (char *) "self", NULL
12196 };
12197
12198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12200 if (SWIG_arg_fail(1)) SWIG_fail;
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 result = (int)(arg1)->GetZMin();
12204
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 {
12209 resultobj = SWIG_From_int((int)(result));
12210 }
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj;
12219 wxJoystick *arg1 = (wxJoystick *) 0 ;
12220 int result;
12221 PyObject * obj0 = 0 ;
12222 char *kwnames[] = {
12223 (char *) "self", NULL
12224 };
12225
12226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12228 if (SWIG_arg_fail(1)) SWIG_fail;
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (int)(arg1)->GetXMax();
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 {
12237 resultobj = SWIG_From_int((int)(result));
12238 }
12239 return resultobj;
12240 fail:
12241 return NULL;
12242 }
12243
12244
12245 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12246 PyObject *resultobj;
12247 wxJoystick *arg1 = (wxJoystick *) 0 ;
12248 int result;
12249 PyObject * obj0 = 0 ;
12250 char *kwnames[] = {
12251 (char *) "self", NULL
12252 };
12253
12254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12256 if (SWIG_arg_fail(1)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 result = (int)(arg1)->GetYMax();
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 {
12265 resultobj = SWIG_From_int((int)(result));
12266 }
12267 return resultobj;
12268 fail:
12269 return NULL;
12270 }
12271
12272
12273 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12274 PyObject *resultobj;
12275 wxJoystick *arg1 = (wxJoystick *) 0 ;
12276 int result;
12277 PyObject * obj0 = 0 ;
12278 char *kwnames[] = {
12279 (char *) "self", NULL
12280 };
12281
12282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12284 if (SWIG_arg_fail(1)) SWIG_fail;
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (int)(arg1)->GetZMax();
12288
12289 wxPyEndAllowThreads(__tstate);
12290 if (PyErr_Occurred()) SWIG_fail;
12291 }
12292 {
12293 resultobj = SWIG_From_int((int)(result));
12294 }
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj;
12303 wxJoystick *arg1 = (wxJoystick *) 0 ;
12304 int result;
12305 PyObject * obj0 = 0 ;
12306 char *kwnames[] = {
12307 (char *) "self", NULL
12308 };
12309
12310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12312 if (SWIG_arg_fail(1)) SWIG_fail;
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 result = (int)(arg1)->GetNumberButtons();
12316
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 {
12321 resultobj = SWIG_From_int((int)(result));
12322 }
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj;
12331 wxJoystick *arg1 = (wxJoystick *) 0 ;
12332 int result;
12333 PyObject * obj0 = 0 ;
12334 char *kwnames[] = {
12335 (char *) "self", NULL
12336 };
12337
12338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12340 if (SWIG_arg_fail(1)) SWIG_fail;
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = (int)(arg1)->GetNumberAxes();
12344
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 {
12349 resultobj = SWIG_From_int((int)(result));
12350 }
12351 return resultobj;
12352 fail:
12353 return NULL;
12354 }
12355
12356
12357 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12358 PyObject *resultobj;
12359 wxJoystick *arg1 = (wxJoystick *) 0 ;
12360 int result;
12361 PyObject * obj0 = 0 ;
12362 char *kwnames[] = {
12363 (char *) "self", NULL
12364 };
12365
12366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12368 if (SWIG_arg_fail(1)) SWIG_fail;
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 result = (int)(arg1)->GetMaxButtons();
12372
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 {
12377 resultobj = SWIG_From_int((int)(result));
12378 }
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj;
12387 wxJoystick *arg1 = (wxJoystick *) 0 ;
12388 int result;
12389 PyObject * obj0 = 0 ;
12390 char *kwnames[] = {
12391 (char *) "self", NULL
12392 };
12393
12394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12396 if (SWIG_arg_fail(1)) SWIG_fail;
12397 {
12398 PyThreadState* __tstate = wxPyBeginAllowThreads();
12399 result = (int)(arg1)->GetMaxAxes();
12400
12401 wxPyEndAllowThreads(__tstate);
12402 if (PyErr_Occurred()) SWIG_fail;
12403 }
12404 {
12405 resultobj = SWIG_From_int((int)(result));
12406 }
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj;
12415 wxJoystick *arg1 = (wxJoystick *) 0 ;
12416 int result;
12417 PyObject * obj0 = 0 ;
12418 char *kwnames[] = {
12419 (char *) "self", NULL
12420 };
12421
12422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12424 if (SWIG_arg_fail(1)) SWIG_fail;
12425 {
12426 PyThreadState* __tstate = wxPyBeginAllowThreads();
12427 result = (int)(arg1)->GetPollingMin();
12428
12429 wxPyEndAllowThreads(__tstate);
12430 if (PyErr_Occurred()) SWIG_fail;
12431 }
12432 {
12433 resultobj = SWIG_From_int((int)(result));
12434 }
12435 return resultobj;
12436 fail:
12437 return NULL;
12438 }
12439
12440
12441 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj;
12443 wxJoystick *arg1 = (wxJoystick *) 0 ;
12444 int result;
12445 PyObject * obj0 = 0 ;
12446 char *kwnames[] = {
12447 (char *) "self", NULL
12448 };
12449
12450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12452 if (SWIG_arg_fail(1)) SWIG_fail;
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = (int)(arg1)->GetPollingMax();
12456
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 {
12461 resultobj = SWIG_From_int((int)(result));
12462 }
12463 return resultobj;
12464 fail:
12465 return NULL;
12466 }
12467
12468
12469 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12470 PyObject *resultobj;
12471 wxJoystick *arg1 = (wxJoystick *) 0 ;
12472 int result;
12473 PyObject * obj0 = 0 ;
12474 char *kwnames[] = {
12475 (char *) "self", NULL
12476 };
12477
12478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12480 if (SWIG_arg_fail(1)) SWIG_fail;
12481 {
12482 PyThreadState* __tstate = wxPyBeginAllowThreads();
12483 result = (int)(arg1)->GetRudderMin();
12484
12485 wxPyEndAllowThreads(__tstate);
12486 if (PyErr_Occurred()) SWIG_fail;
12487 }
12488 {
12489 resultobj = SWIG_From_int((int)(result));
12490 }
12491 return resultobj;
12492 fail:
12493 return NULL;
12494 }
12495
12496
12497 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12498 PyObject *resultobj;
12499 wxJoystick *arg1 = (wxJoystick *) 0 ;
12500 int result;
12501 PyObject * obj0 = 0 ;
12502 char *kwnames[] = {
12503 (char *) "self", NULL
12504 };
12505
12506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12508 if (SWIG_arg_fail(1)) SWIG_fail;
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 result = (int)(arg1)->GetRudderMax();
12512
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 {
12517 resultobj = SWIG_From_int((int)(result));
12518 }
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12526 PyObject *resultobj;
12527 wxJoystick *arg1 = (wxJoystick *) 0 ;
12528 int result;
12529 PyObject * obj0 = 0 ;
12530 char *kwnames[] = {
12531 (char *) "self", NULL
12532 };
12533
12534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12536 if (SWIG_arg_fail(1)) SWIG_fail;
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 result = (int)(arg1)->GetUMin();
12540
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 {
12545 resultobj = SWIG_From_int((int)(result));
12546 }
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj;
12555 wxJoystick *arg1 = (wxJoystick *) 0 ;
12556 int result;
12557 PyObject * obj0 = 0 ;
12558 char *kwnames[] = {
12559 (char *) "self", NULL
12560 };
12561
12562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12564 if (SWIG_arg_fail(1)) SWIG_fail;
12565 {
12566 PyThreadState* __tstate = wxPyBeginAllowThreads();
12567 result = (int)(arg1)->GetUMax();
12568
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 {
12573 resultobj = SWIG_From_int((int)(result));
12574 }
12575 return resultobj;
12576 fail:
12577 return NULL;
12578 }
12579
12580
12581 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj;
12583 wxJoystick *arg1 = (wxJoystick *) 0 ;
12584 int result;
12585 PyObject * obj0 = 0 ;
12586 char *kwnames[] = {
12587 (char *) "self", NULL
12588 };
12589
12590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12592 if (SWIG_arg_fail(1)) SWIG_fail;
12593 {
12594 PyThreadState* __tstate = wxPyBeginAllowThreads();
12595 result = (int)(arg1)->GetVMin();
12596
12597 wxPyEndAllowThreads(__tstate);
12598 if (PyErr_Occurred()) SWIG_fail;
12599 }
12600 {
12601 resultobj = SWIG_From_int((int)(result));
12602 }
12603 return resultobj;
12604 fail:
12605 return NULL;
12606 }
12607
12608
12609 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12610 PyObject *resultobj;
12611 wxJoystick *arg1 = (wxJoystick *) 0 ;
12612 int result;
12613 PyObject * obj0 = 0 ;
12614 char *kwnames[] = {
12615 (char *) "self", NULL
12616 };
12617
12618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12620 if (SWIG_arg_fail(1)) SWIG_fail;
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 result = (int)(arg1)->GetVMax();
12624
12625 wxPyEndAllowThreads(__tstate);
12626 if (PyErr_Occurred()) SWIG_fail;
12627 }
12628 {
12629 resultobj = SWIG_From_int((int)(result));
12630 }
12631 return resultobj;
12632 fail:
12633 return NULL;
12634 }
12635
12636
12637 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12638 PyObject *resultobj;
12639 wxJoystick *arg1 = (wxJoystick *) 0 ;
12640 bool result;
12641 PyObject * obj0 = 0 ;
12642 char *kwnames[] = {
12643 (char *) "self", NULL
12644 };
12645
12646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12648 if (SWIG_arg_fail(1)) SWIG_fail;
12649 {
12650 PyThreadState* __tstate = wxPyBeginAllowThreads();
12651 result = (bool)(arg1)->HasRudder();
12652
12653 wxPyEndAllowThreads(__tstate);
12654 if (PyErr_Occurred()) SWIG_fail;
12655 }
12656 {
12657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12658 }
12659 return resultobj;
12660 fail:
12661 return NULL;
12662 }
12663
12664
12665 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12666 PyObject *resultobj;
12667 wxJoystick *arg1 = (wxJoystick *) 0 ;
12668 bool result;
12669 PyObject * obj0 = 0 ;
12670 char *kwnames[] = {
12671 (char *) "self", NULL
12672 };
12673
12674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12676 if (SWIG_arg_fail(1)) SWIG_fail;
12677 {
12678 PyThreadState* __tstate = wxPyBeginAllowThreads();
12679 result = (bool)(arg1)->HasZ();
12680
12681 wxPyEndAllowThreads(__tstate);
12682 if (PyErr_Occurred()) SWIG_fail;
12683 }
12684 {
12685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12686 }
12687 return resultobj;
12688 fail:
12689 return NULL;
12690 }
12691
12692
12693 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12694 PyObject *resultobj;
12695 wxJoystick *arg1 = (wxJoystick *) 0 ;
12696 bool result;
12697 PyObject * obj0 = 0 ;
12698 char *kwnames[] = {
12699 (char *) "self", NULL
12700 };
12701
12702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12704 if (SWIG_arg_fail(1)) SWIG_fail;
12705 {
12706 PyThreadState* __tstate = wxPyBeginAllowThreads();
12707 result = (bool)(arg1)->HasU();
12708
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 {
12713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12714 }
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12722 PyObject *resultobj;
12723 wxJoystick *arg1 = (wxJoystick *) 0 ;
12724 bool result;
12725 PyObject * obj0 = 0 ;
12726 char *kwnames[] = {
12727 (char *) "self", NULL
12728 };
12729
12730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12732 if (SWIG_arg_fail(1)) SWIG_fail;
12733 {
12734 PyThreadState* __tstate = wxPyBeginAllowThreads();
12735 result = (bool)(arg1)->HasV();
12736
12737 wxPyEndAllowThreads(__tstate);
12738 if (PyErr_Occurred()) SWIG_fail;
12739 }
12740 {
12741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12742 }
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12750 PyObject *resultobj;
12751 wxJoystick *arg1 = (wxJoystick *) 0 ;
12752 bool result;
12753 PyObject * obj0 = 0 ;
12754 char *kwnames[] = {
12755 (char *) "self", NULL
12756 };
12757
12758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12760 if (SWIG_arg_fail(1)) SWIG_fail;
12761 {
12762 PyThreadState* __tstate = wxPyBeginAllowThreads();
12763 result = (bool)(arg1)->HasPOV();
12764
12765 wxPyEndAllowThreads(__tstate);
12766 if (PyErr_Occurred()) SWIG_fail;
12767 }
12768 {
12769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12770 }
12771 return resultobj;
12772 fail:
12773 return NULL;
12774 }
12775
12776
12777 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12778 PyObject *resultobj;
12779 wxJoystick *arg1 = (wxJoystick *) 0 ;
12780 bool result;
12781 PyObject * obj0 = 0 ;
12782 char *kwnames[] = {
12783 (char *) "self", NULL
12784 };
12785
12786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12788 if (SWIG_arg_fail(1)) SWIG_fail;
12789 {
12790 PyThreadState* __tstate = wxPyBeginAllowThreads();
12791 result = (bool)(arg1)->HasPOV4Dir();
12792
12793 wxPyEndAllowThreads(__tstate);
12794 if (PyErr_Occurred()) SWIG_fail;
12795 }
12796 {
12797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12798 }
12799 return resultobj;
12800 fail:
12801 return NULL;
12802 }
12803
12804
12805 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12806 PyObject *resultobj;
12807 wxJoystick *arg1 = (wxJoystick *) 0 ;
12808 bool result;
12809 PyObject * obj0 = 0 ;
12810 char *kwnames[] = {
12811 (char *) "self", NULL
12812 };
12813
12814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12816 if (SWIG_arg_fail(1)) SWIG_fail;
12817 {
12818 PyThreadState* __tstate = wxPyBeginAllowThreads();
12819 result = (bool)(arg1)->HasPOVCTS();
12820
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 {
12825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12826 }
12827 return resultobj;
12828 fail:
12829 return NULL;
12830 }
12831
12832
12833 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12834 PyObject *resultobj;
12835 wxJoystick *arg1 = (wxJoystick *) 0 ;
12836 wxWindow *arg2 = (wxWindow *) 0 ;
12837 int arg3 = (int) 0 ;
12838 bool result;
12839 PyObject * obj0 = 0 ;
12840 PyObject * obj1 = 0 ;
12841 PyObject * obj2 = 0 ;
12842 char *kwnames[] = {
12843 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12844 };
12845
12846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12848 if (SWIG_arg_fail(1)) SWIG_fail;
12849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12850 if (SWIG_arg_fail(2)) SWIG_fail;
12851 if (obj2) {
12852 {
12853 arg3 = (int)(SWIG_As_int(obj2));
12854 if (SWIG_arg_fail(3)) SWIG_fail;
12855 }
12856 }
12857 {
12858 PyThreadState* __tstate = wxPyBeginAllowThreads();
12859 result = (bool)(arg1)->SetCapture(arg2,arg3);
12860
12861 wxPyEndAllowThreads(__tstate);
12862 if (PyErr_Occurred()) SWIG_fail;
12863 }
12864 {
12865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12866 }
12867 return resultobj;
12868 fail:
12869 return NULL;
12870 }
12871
12872
12873 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12874 PyObject *resultobj;
12875 wxJoystick *arg1 = (wxJoystick *) 0 ;
12876 bool result;
12877 PyObject * obj0 = 0 ;
12878 char *kwnames[] = {
12879 (char *) "self", NULL
12880 };
12881
12882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12884 if (SWIG_arg_fail(1)) SWIG_fail;
12885 {
12886 PyThreadState* __tstate = wxPyBeginAllowThreads();
12887 result = (bool)(arg1)->ReleaseCapture();
12888
12889 wxPyEndAllowThreads(__tstate);
12890 if (PyErr_Occurred()) SWIG_fail;
12891 }
12892 {
12893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12894 }
12895 return resultobj;
12896 fail:
12897 return NULL;
12898 }
12899
12900
12901 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12902 PyObject *obj;
12903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12904 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12905 Py_INCREF(obj);
12906 return Py_BuildValue((char *)"");
12907 }
12908 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12909 PyObject *resultobj;
12910 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12911 int arg2 = (int) 0 ;
12912 int arg3 = (int) wxJOYSTICK1 ;
12913 int arg4 = (int) 0 ;
12914 wxJoystickEvent *result;
12915 PyObject * obj0 = 0 ;
12916 PyObject * obj1 = 0 ;
12917 PyObject * obj2 = 0 ;
12918 PyObject * obj3 = 0 ;
12919 char *kwnames[] = {
12920 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12921 };
12922
12923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12924 if (obj0) {
12925 {
12926 arg1 = (wxEventType)(SWIG_As_int(obj0));
12927 if (SWIG_arg_fail(1)) SWIG_fail;
12928 }
12929 }
12930 if (obj1) {
12931 {
12932 arg2 = (int)(SWIG_As_int(obj1));
12933 if (SWIG_arg_fail(2)) SWIG_fail;
12934 }
12935 }
12936 if (obj2) {
12937 {
12938 arg3 = (int)(SWIG_As_int(obj2));
12939 if (SWIG_arg_fail(3)) SWIG_fail;
12940 }
12941 }
12942 if (obj3) {
12943 {
12944 arg4 = (int)(SWIG_As_int(obj3));
12945 if (SWIG_arg_fail(4)) SWIG_fail;
12946 }
12947 }
12948 {
12949 PyThreadState* __tstate = wxPyBeginAllowThreads();
12950 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12951
12952 wxPyEndAllowThreads(__tstate);
12953 if (PyErr_Occurred()) SWIG_fail;
12954 }
12955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12956 return resultobj;
12957 fail:
12958 return NULL;
12959 }
12960
12961
12962 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12963 PyObject *resultobj;
12964 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12965 wxPoint result;
12966 PyObject * obj0 = 0 ;
12967 char *kwnames[] = {
12968 (char *) "self", NULL
12969 };
12970
12971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12973 if (SWIG_arg_fail(1)) SWIG_fail;
12974 {
12975 PyThreadState* __tstate = wxPyBeginAllowThreads();
12976 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12977
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 {
12982 wxPoint * resultptr;
12983 resultptr = new wxPoint((wxPoint &)(result));
12984 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12985 }
12986 return resultobj;
12987 fail:
12988 return NULL;
12989 }
12990
12991
12992 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12993 PyObject *resultobj;
12994 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12995 int result;
12996 PyObject * obj0 = 0 ;
12997 char *kwnames[] = {
12998 (char *) "self", NULL
12999 };
13000
13001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13003 if (SWIG_arg_fail(1)) SWIG_fail;
13004 {
13005 PyThreadState* __tstate = wxPyBeginAllowThreads();
13006 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13007
13008 wxPyEndAllowThreads(__tstate);
13009 if (PyErr_Occurred()) SWIG_fail;
13010 }
13011 {
13012 resultobj = SWIG_From_int((int)(result));
13013 }
13014 return resultobj;
13015 fail:
13016 return NULL;
13017 }
13018
13019
13020 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13021 PyObject *resultobj;
13022 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13023 int result;
13024 PyObject * obj0 = 0 ;
13025 char *kwnames[] = {
13026 (char *) "self", NULL
13027 };
13028
13029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13031 if (SWIG_arg_fail(1)) SWIG_fail;
13032 {
13033 PyThreadState* __tstate = wxPyBeginAllowThreads();
13034 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13035
13036 wxPyEndAllowThreads(__tstate);
13037 if (PyErr_Occurred()) SWIG_fail;
13038 }
13039 {
13040 resultobj = SWIG_From_int((int)(result));
13041 }
13042 return resultobj;
13043 fail:
13044 return NULL;
13045 }
13046
13047
13048 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13049 PyObject *resultobj;
13050 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13051 int result;
13052 PyObject * obj0 = 0 ;
13053 char *kwnames[] = {
13054 (char *) "self", NULL
13055 };
13056
13057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13059 if (SWIG_arg_fail(1)) SWIG_fail;
13060 {
13061 PyThreadState* __tstate = wxPyBeginAllowThreads();
13062 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13063
13064 wxPyEndAllowThreads(__tstate);
13065 if (PyErr_Occurred()) SWIG_fail;
13066 }
13067 {
13068 resultobj = SWIG_From_int((int)(result));
13069 }
13070 return resultobj;
13071 fail:
13072 return NULL;
13073 }
13074
13075
13076 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13077 PyObject *resultobj;
13078 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13079 int result;
13080 PyObject * obj0 = 0 ;
13081 char *kwnames[] = {
13082 (char *) "self", NULL
13083 };
13084
13085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13087 if (SWIG_arg_fail(1)) SWIG_fail;
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13091
13092 wxPyEndAllowThreads(__tstate);
13093 if (PyErr_Occurred()) SWIG_fail;
13094 }
13095 {
13096 resultobj = SWIG_From_int((int)(result));
13097 }
13098 return resultobj;
13099 fail:
13100 return NULL;
13101 }
13102
13103
13104 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13105 PyObject *resultobj;
13106 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13107 int arg2 ;
13108 PyObject * obj0 = 0 ;
13109 PyObject * obj1 = 0 ;
13110 char *kwnames[] = {
13111 (char *) "self",(char *) "stick", NULL
13112 };
13113
13114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13116 if (SWIG_arg_fail(1)) SWIG_fail;
13117 {
13118 arg2 = (int)(SWIG_As_int(obj1));
13119 if (SWIG_arg_fail(2)) SWIG_fail;
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 (arg1)->SetJoystick(arg2);
13124
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 Py_INCREF(Py_None); resultobj = Py_None;
13129 return resultobj;
13130 fail:
13131 return NULL;
13132 }
13133
13134
13135 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13136 PyObject *resultobj;
13137 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13138 int arg2 ;
13139 PyObject * obj0 = 0 ;
13140 PyObject * obj1 = 0 ;
13141 char *kwnames[] = {
13142 (char *) "self",(char *) "state", NULL
13143 };
13144
13145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13147 if (SWIG_arg_fail(1)) SWIG_fail;
13148 {
13149 arg2 = (int)(SWIG_As_int(obj1));
13150 if (SWIG_arg_fail(2)) SWIG_fail;
13151 }
13152 {
13153 PyThreadState* __tstate = wxPyBeginAllowThreads();
13154 (arg1)->SetButtonState(arg2);
13155
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 Py_INCREF(Py_None); resultobj = Py_None;
13160 return resultobj;
13161 fail:
13162 return NULL;
13163 }
13164
13165
13166 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13167 PyObject *resultobj;
13168 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13169 int arg2 ;
13170 PyObject * obj0 = 0 ;
13171 PyObject * obj1 = 0 ;
13172 char *kwnames[] = {
13173 (char *) "self",(char *) "change", NULL
13174 };
13175
13176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13178 if (SWIG_arg_fail(1)) SWIG_fail;
13179 {
13180 arg2 = (int)(SWIG_As_int(obj1));
13181 if (SWIG_arg_fail(2)) SWIG_fail;
13182 }
13183 {
13184 PyThreadState* __tstate = wxPyBeginAllowThreads();
13185 (arg1)->SetButtonChange(arg2);
13186
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 Py_INCREF(Py_None); resultobj = Py_None;
13191 return resultobj;
13192 fail:
13193 return NULL;
13194 }
13195
13196
13197 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13198 PyObject *resultobj;
13199 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13200 wxPoint *arg2 = 0 ;
13201 wxPoint temp2 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 char *kwnames[] = {
13205 (char *) "self",(char *) "pos", NULL
13206 };
13207
13208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13210 if (SWIG_arg_fail(1)) SWIG_fail;
13211 {
13212 arg2 = &temp2;
13213 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13214 }
13215 {
13216 PyThreadState* __tstate = wxPyBeginAllowThreads();
13217 (arg1)->SetPosition((wxPoint const &)*arg2);
13218
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 Py_INCREF(Py_None); resultobj = Py_None;
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13230 PyObject *resultobj;
13231 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13232 int arg2 ;
13233 PyObject * obj0 = 0 ;
13234 PyObject * obj1 = 0 ;
13235 char *kwnames[] = {
13236 (char *) "self",(char *) "zPos", NULL
13237 };
13238
13239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13241 if (SWIG_arg_fail(1)) SWIG_fail;
13242 {
13243 arg2 = (int)(SWIG_As_int(obj1));
13244 if (SWIG_arg_fail(2)) SWIG_fail;
13245 }
13246 {
13247 PyThreadState* __tstate = wxPyBeginAllowThreads();
13248 (arg1)->SetZPosition(arg2);
13249
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 Py_INCREF(Py_None); resultobj = Py_None;
13254 return resultobj;
13255 fail:
13256 return NULL;
13257 }
13258
13259
13260 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13261 PyObject *resultobj;
13262 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13263 bool result;
13264 PyObject * obj0 = 0 ;
13265 char *kwnames[] = {
13266 (char *) "self", NULL
13267 };
13268
13269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13271 if (SWIG_arg_fail(1)) SWIG_fail;
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13275
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 {
13280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13281 }
13282 return resultobj;
13283 fail:
13284 return NULL;
13285 }
13286
13287
13288 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13289 PyObject *resultobj;
13290 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13291 bool result;
13292 PyObject * obj0 = 0 ;
13293 char *kwnames[] = {
13294 (char *) "self", NULL
13295 };
13296
13297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13299 if (SWIG_arg_fail(1)) SWIG_fail;
13300 {
13301 PyThreadState* __tstate = wxPyBeginAllowThreads();
13302 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13303
13304 wxPyEndAllowThreads(__tstate);
13305 if (PyErr_Occurred()) SWIG_fail;
13306 }
13307 {
13308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13309 }
13310 return resultobj;
13311 fail:
13312 return NULL;
13313 }
13314
13315
13316 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13317 PyObject *resultobj;
13318 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13319 bool result;
13320 PyObject * obj0 = 0 ;
13321 char *kwnames[] = {
13322 (char *) "self", NULL
13323 };
13324
13325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13327 if (SWIG_arg_fail(1)) SWIG_fail;
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13331
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 {
13336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13337 }
13338 return resultobj;
13339 fail:
13340 return NULL;
13341 }
13342
13343
13344 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13345 PyObject *resultobj;
13346 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13347 int arg2 = (int) wxJOY_BUTTON_ANY ;
13348 bool result;
13349 PyObject * obj0 = 0 ;
13350 PyObject * obj1 = 0 ;
13351 char *kwnames[] = {
13352 (char *) "self",(char *) "but", NULL
13353 };
13354
13355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13357 if (SWIG_arg_fail(1)) SWIG_fail;
13358 if (obj1) {
13359 {
13360 arg2 = (int)(SWIG_As_int(obj1));
13361 if (SWIG_arg_fail(2)) SWIG_fail;
13362 }
13363 }
13364 {
13365 PyThreadState* __tstate = wxPyBeginAllowThreads();
13366 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13367
13368 wxPyEndAllowThreads(__tstate);
13369 if (PyErr_Occurred()) SWIG_fail;
13370 }
13371 {
13372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13373 }
13374 return resultobj;
13375 fail:
13376 return NULL;
13377 }
13378
13379
13380 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13381 PyObject *resultobj;
13382 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13383 int arg2 = (int) wxJOY_BUTTON_ANY ;
13384 bool result;
13385 PyObject * obj0 = 0 ;
13386 PyObject * obj1 = 0 ;
13387 char *kwnames[] = {
13388 (char *) "self",(char *) "but", NULL
13389 };
13390
13391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13393 if (SWIG_arg_fail(1)) SWIG_fail;
13394 if (obj1) {
13395 {
13396 arg2 = (int)(SWIG_As_int(obj1));
13397 if (SWIG_arg_fail(2)) SWIG_fail;
13398 }
13399 }
13400 {
13401 PyThreadState* __tstate = wxPyBeginAllowThreads();
13402 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13403
13404 wxPyEndAllowThreads(__tstate);
13405 if (PyErr_Occurred()) SWIG_fail;
13406 }
13407 {
13408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13409 }
13410 return resultobj;
13411 fail:
13412 return NULL;
13413 }
13414
13415
13416 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13417 PyObject *resultobj;
13418 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13419 int arg2 = (int) wxJOY_BUTTON_ANY ;
13420 bool result;
13421 PyObject * obj0 = 0 ;
13422 PyObject * obj1 = 0 ;
13423 char *kwnames[] = {
13424 (char *) "self",(char *) "but", NULL
13425 };
13426
13427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13429 if (SWIG_arg_fail(1)) SWIG_fail;
13430 if (obj1) {
13431 {
13432 arg2 = (int)(SWIG_As_int(obj1));
13433 if (SWIG_arg_fail(2)) SWIG_fail;
13434 }
13435 }
13436 {
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13439
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 {
13444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13445 }
13446 return resultobj;
13447 fail:
13448 return NULL;
13449 }
13450
13451
13452 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13453 PyObject *obj;
13454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13455 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13456 Py_INCREF(obj);
13457 return Py_BuildValue((char *)"");
13458 }
13459 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13460 PyObject *resultobj;
13461 wxString const &arg1_defvalue = wxPyEmptyString ;
13462 wxString *arg1 = (wxString *) &arg1_defvalue ;
13463 wxSound *result;
13464 bool temp1 = false ;
13465 PyObject * obj0 = 0 ;
13466 char *kwnames[] = {
13467 (char *) "fileName", NULL
13468 };
13469
13470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13471 if (obj0) {
13472 {
13473 arg1 = wxString_in_helper(obj0);
13474 if (arg1 == NULL) SWIG_fail;
13475 temp1 = true;
13476 }
13477 }
13478 {
13479 if (!wxPyCheckForApp()) SWIG_fail;
13480 PyThreadState* __tstate = wxPyBeginAllowThreads();
13481 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13482
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13487 {
13488 if (temp1)
13489 delete arg1;
13490 }
13491 return resultobj;
13492 fail:
13493 {
13494 if (temp1)
13495 delete arg1;
13496 }
13497 return NULL;
13498 }
13499
13500
13501 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13502 PyObject *resultobj;
13503 PyObject *arg1 = (PyObject *) 0 ;
13504 wxSound *result;
13505 PyObject * obj0 = 0 ;
13506 char *kwnames[] = {
13507 (char *) "data", NULL
13508 };
13509
13510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13511 arg1 = obj0;
13512 {
13513 if (!wxPyCheckForApp()) SWIG_fail;
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 result = (wxSound *)new_wxSound(arg1);
13516
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13521 return resultobj;
13522 fail:
13523 return NULL;
13524 }
13525
13526
13527 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13528 PyObject *resultobj;
13529 wxSound *arg1 = (wxSound *) 0 ;
13530 PyObject * obj0 = 0 ;
13531 char *kwnames[] = {
13532 (char *) "self", NULL
13533 };
13534
13535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13537 if (SWIG_arg_fail(1)) SWIG_fail;
13538 {
13539 PyThreadState* __tstate = wxPyBeginAllowThreads();
13540 delete arg1;
13541
13542 wxPyEndAllowThreads(__tstate);
13543 if (PyErr_Occurred()) SWIG_fail;
13544 }
13545 Py_INCREF(Py_None); resultobj = Py_None;
13546 return resultobj;
13547 fail:
13548 return NULL;
13549 }
13550
13551
13552 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj;
13554 wxSound *arg1 = (wxSound *) 0 ;
13555 wxString *arg2 = 0 ;
13556 bool result;
13557 bool temp2 = false ;
13558 PyObject * obj0 = 0 ;
13559 PyObject * obj1 = 0 ;
13560 char *kwnames[] = {
13561 (char *) "self",(char *) "fileName", NULL
13562 };
13563
13564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13566 if (SWIG_arg_fail(1)) SWIG_fail;
13567 {
13568 arg2 = wxString_in_helper(obj1);
13569 if (arg2 == NULL) SWIG_fail;
13570 temp2 = true;
13571 }
13572 {
13573 PyThreadState* __tstate = wxPyBeginAllowThreads();
13574 result = (bool)(arg1)->Create((wxString const &)*arg2);
13575
13576 wxPyEndAllowThreads(__tstate);
13577 if (PyErr_Occurred()) SWIG_fail;
13578 }
13579 {
13580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13581 }
13582 {
13583 if (temp2)
13584 delete arg2;
13585 }
13586 return resultobj;
13587 fail:
13588 {
13589 if (temp2)
13590 delete arg2;
13591 }
13592 return NULL;
13593 }
13594
13595
13596 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13597 PyObject *resultobj;
13598 wxSound *arg1 = (wxSound *) 0 ;
13599 PyObject *arg2 = (PyObject *) 0 ;
13600 bool result;
13601 PyObject * obj0 = 0 ;
13602 PyObject * obj1 = 0 ;
13603 char *kwnames[] = {
13604 (char *) "self",(char *) "data", NULL
13605 };
13606
13607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13609 if (SWIG_arg_fail(1)) SWIG_fail;
13610 arg2 = obj1;
13611 {
13612 PyThreadState* __tstate = wxPyBeginAllowThreads();
13613 result = (bool)wxSound_CreateFromData(arg1,arg2);
13614
13615 wxPyEndAllowThreads(__tstate);
13616 if (PyErr_Occurred()) SWIG_fail;
13617 }
13618 {
13619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13620 }
13621 return resultobj;
13622 fail:
13623 return NULL;
13624 }
13625
13626
13627 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13628 PyObject *resultobj;
13629 wxSound *arg1 = (wxSound *) 0 ;
13630 bool result;
13631 PyObject * obj0 = 0 ;
13632 char *kwnames[] = {
13633 (char *) "self", NULL
13634 };
13635
13636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13638 if (SWIG_arg_fail(1)) SWIG_fail;
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 result = (bool)(arg1)->IsOk();
13642
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 {
13647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13648 }
13649 return resultobj;
13650 fail:
13651 return NULL;
13652 }
13653
13654
13655 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13656 PyObject *resultobj;
13657 wxSound *arg1 = (wxSound *) 0 ;
13658 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13659 bool result;
13660 PyObject * obj0 = 0 ;
13661 PyObject * obj1 = 0 ;
13662 char *kwnames[] = {
13663 (char *) "self",(char *) "flags", NULL
13664 };
13665
13666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13668 if (SWIG_arg_fail(1)) SWIG_fail;
13669 if (obj1) {
13670 {
13671 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13672 if (SWIG_arg_fail(2)) SWIG_fail;
13673 }
13674 }
13675 {
13676 if (!wxPyCheckForApp()) SWIG_fail;
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 result = (bool)((wxSound const *)arg1)->Play(arg2);
13679
13680 wxPyEndAllowThreads(__tstate);
13681 if (PyErr_Occurred()) SWIG_fail;
13682 }
13683 {
13684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13685 }
13686 return resultobj;
13687 fail:
13688 return NULL;
13689 }
13690
13691
13692 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13693 PyObject *resultobj;
13694 wxString *arg1 = 0 ;
13695 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13696 bool result;
13697 bool temp1 = false ;
13698 PyObject * obj0 = 0 ;
13699 PyObject * obj1 = 0 ;
13700 char *kwnames[] = {
13701 (char *) "filename",(char *) "flags", NULL
13702 };
13703
13704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13705 {
13706 arg1 = wxString_in_helper(obj0);
13707 if (arg1 == NULL) SWIG_fail;
13708 temp1 = true;
13709 }
13710 if (obj1) {
13711 {
13712 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13713 if (SWIG_arg_fail(2)) SWIG_fail;
13714 }
13715 }
13716 {
13717 if (!wxPyCheckForApp()) SWIG_fail;
13718 PyThreadState* __tstate = wxPyBeginAllowThreads();
13719 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13720
13721 wxPyEndAllowThreads(__tstate);
13722 if (PyErr_Occurred()) SWIG_fail;
13723 }
13724 {
13725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13726 }
13727 {
13728 if (temp1)
13729 delete arg1;
13730 }
13731 return resultobj;
13732 fail:
13733 {
13734 if (temp1)
13735 delete arg1;
13736 }
13737 return NULL;
13738 }
13739
13740
13741 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj;
13743 char *kwnames[] = {
13744 NULL
13745 };
13746
13747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13748 {
13749 if (!wxPyCheckForApp()) SWIG_fail;
13750 PyThreadState* __tstate = wxPyBeginAllowThreads();
13751 wxSound::Stop();
13752
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 Py_INCREF(Py_None); resultobj = Py_None;
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13764 PyObject *obj;
13765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13766 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13767 Py_INCREF(obj);
13768 return Py_BuildValue((char *)"");
13769 }
13770 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13771 PyObject *resultobj;
13772 wxString *arg1 = 0 ;
13773 wxString *arg2 = 0 ;
13774 wxString *arg3 = 0 ;
13775 wxString *arg4 = 0 ;
13776 wxFileTypeInfo *result;
13777 bool temp1 = false ;
13778 bool temp2 = false ;
13779 bool temp3 = false ;
13780 bool temp4 = false ;
13781 PyObject * obj0 = 0 ;
13782 PyObject * obj1 = 0 ;
13783 PyObject * obj2 = 0 ;
13784 PyObject * obj3 = 0 ;
13785 char *kwnames[] = {
13786 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13787 };
13788
13789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13790 {
13791 arg1 = wxString_in_helper(obj0);
13792 if (arg1 == NULL) SWIG_fail;
13793 temp1 = true;
13794 }
13795 {
13796 arg2 = wxString_in_helper(obj1);
13797 if (arg2 == NULL) SWIG_fail;
13798 temp2 = true;
13799 }
13800 {
13801 arg3 = wxString_in_helper(obj2);
13802 if (arg3 == NULL) SWIG_fail;
13803 temp3 = true;
13804 }
13805 {
13806 arg4 = wxString_in_helper(obj3);
13807 if (arg4 == NULL) SWIG_fail;
13808 temp4 = true;
13809 }
13810 {
13811 PyThreadState* __tstate = wxPyBeginAllowThreads();
13812 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13813
13814 wxPyEndAllowThreads(__tstate);
13815 if (PyErr_Occurred()) SWIG_fail;
13816 }
13817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13818 {
13819 if (temp1)
13820 delete arg1;
13821 }
13822 {
13823 if (temp2)
13824 delete arg2;
13825 }
13826 {
13827 if (temp3)
13828 delete arg3;
13829 }
13830 {
13831 if (temp4)
13832 delete arg4;
13833 }
13834 return resultobj;
13835 fail:
13836 {
13837 if (temp1)
13838 delete arg1;
13839 }
13840 {
13841 if (temp2)
13842 delete arg2;
13843 }
13844 {
13845 if (temp3)
13846 delete arg3;
13847 }
13848 {
13849 if (temp4)
13850 delete arg4;
13851 }
13852 return NULL;
13853 }
13854
13855
13856 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13857 PyObject *resultobj;
13858 wxArrayString *arg1 = 0 ;
13859 wxFileTypeInfo *result;
13860 bool temp1 = false ;
13861 PyObject * obj0 = 0 ;
13862 char *kwnames[] = {
13863 (char *) "sArray", NULL
13864 };
13865
13866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13867 {
13868 if (! PySequence_Check(obj0)) {
13869 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13870 SWIG_fail;
13871 }
13872 arg1 = new wxArrayString;
13873 temp1 = true;
13874 int i, len=PySequence_Length(obj0);
13875 for (i=0; i<len; i++) {
13876 PyObject* item = PySequence_GetItem(obj0, i);
13877 wxString* s = wxString_in_helper(item);
13878 if (PyErr_Occurred()) SWIG_fail;
13879 arg1->Add(*s);
13880 delete s;
13881 Py_DECREF(item);
13882 }
13883 }
13884 {
13885 PyThreadState* __tstate = wxPyBeginAllowThreads();
13886 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13887
13888 wxPyEndAllowThreads(__tstate);
13889 if (PyErr_Occurred()) SWIG_fail;
13890 }
13891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13892 {
13893 if (temp1) delete arg1;
13894 }
13895 return resultobj;
13896 fail:
13897 {
13898 if (temp1) delete arg1;
13899 }
13900 return NULL;
13901 }
13902
13903
13904 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13905 PyObject *resultobj;
13906 wxFileTypeInfo *result;
13907 char *kwnames[] = {
13908 NULL
13909 };
13910
13911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13912 {
13913 PyThreadState* __tstate = wxPyBeginAllowThreads();
13914 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13915
13916 wxPyEndAllowThreads(__tstate);
13917 if (PyErr_Occurred()) SWIG_fail;
13918 }
13919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13920 return resultobj;
13921 fail:
13922 return NULL;
13923 }
13924
13925
13926 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13927 PyObject *resultobj;
13928 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13929 bool result;
13930 PyObject * obj0 = 0 ;
13931 char *kwnames[] = {
13932 (char *) "self", NULL
13933 };
13934
13935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13937 if (SWIG_arg_fail(1)) SWIG_fail;
13938 {
13939 PyThreadState* __tstate = wxPyBeginAllowThreads();
13940 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13941
13942 wxPyEndAllowThreads(__tstate);
13943 if (PyErr_Occurred()) SWIG_fail;
13944 }
13945 {
13946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13947 }
13948 return resultobj;
13949 fail:
13950 return NULL;
13951 }
13952
13953
13954 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13955 PyObject *resultobj;
13956 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13957 wxString *arg2 = 0 ;
13958 int arg3 = (int) 0 ;
13959 bool temp2 = false ;
13960 PyObject * obj0 = 0 ;
13961 PyObject * obj1 = 0 ;
13962 PyObject * obj2 = 0 ;
13963 char *kwnames[] = {
13964 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13965 };
13966
13967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13969 if (SWIG_arg_fail(1)) SWIG_fail;
13970 {
13971 arg2 = wxString_in_helper(obj1);
13972 if (arg2 == NULL) SWIG_fail;
13973 temp2 = true;
13974 }
13975 if (obj2) {
13976 {
13977 arg3 = (int)(SWIG_As_int(obj2));
13978 if (SWIG_arg_fail(3)) SWIG_fail;
13979 }
13980 }
13981 {
13982 PyThreadState* __tstate = wxPyBeginAllowThreads();
13983 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13984
13985 wxPyEndAllowThreads(__tstate);
13986 if (PyErr_Occurred()) SWIG_fail;
13987 }
13988 Py_INCREF(Py_None); resultobj = Py_None;
13989 {
13990 if (temp2)
13991 delete arg2;
13992 }
13993 return resultobj;
13994 fail:
13995 {
13996 if (temp2)
13997 delete arg2;
13998 }
13999 return NULL;
14000 }
14001
14002
14003 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14004 PyObject *resultobj;
14005 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14006 wxString *arg2 = 0 ;
14007 bool temp2 = false ;
14008 PyObject * obj0 = 0 ;
14009 PyObject * obj1 = 0 ;
14010 char *kwnames[] = {
14011 (char *) "self",(char *) "shortDesc", NULL
14012 };
14013
14014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14016 if (SWIG_arg_fail(1)) SWIG_fail;
14017 {
14018 arg2 = wxString_in_helper(obj1);
14019 if (arg2 == NULL) SWIG_fail;
14020 temp2 = true;
14021 }
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 (arg1)->SetShortDesc((wxString const &)*arg2);
14025
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 Py_INCREF(Py_None); resultobj = Py_None;
14030 {
14031 if (temp2)
14032 delete arg2;
14033 }
14034 return resultobj;
14035 fail:
14036 {
14037 if (temp2)
14038 delete arg2;
14039 }
14040 return NULL;
14041 }
14042
14043
14044 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14045 PyObject *resultobj;
14046 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14047 wxString *result;
14048 PyObject * obj0 = 0 ;
14049 char *kwnames[] = {
14050 (char *) "self", NULL
14051 };
14052
14053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14055 if (SWIG_arg_fail(1)) SWIG_fail;
14056 {
14057 PyThreadState* __tstate = wxPyBeginAllowThreads();
14058 {
14059 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14060 result = (wxString *) &_result_ref;
14061 }
14062
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 {
14067 #if wxUSE_UNICODE
14068 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14069 #else
14070 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14071 #endif
14072 }
14073 return resultobj;
14074 fail:
14075 return NULL;
14076 }
14077
14078
14079 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14080 PyObject *resultobj;
14081 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14082 wxString *result;
14083 PyObject * obj0 = 0 ;
14084 char *kwnames[] = {
14085 (char *) "self", NULL
14086 };
14087
14088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14090 if (SWIG_arg_fail(1)) SWIG_fail;
14091 {
14092 PyThreadState* __tstate = wxPyBeginAllowThreads();
14093 {
14094 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14095 result = (wxString *) &_result_ref;
14096 }
14097
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 {
14102 #if wxUSE_UNICODE
14103 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14104 #else
14105 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14106 #endif
14107 }
14108 return resultobj;
14109 fail:
14110 return NULL;
14111 }
14112
14113
14114 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14115 PyObject *resultobj;
14116 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14117 wxString *result;
14118 PyObject * obj0 = 0 ;
14119 char *kwnames[] = {
14120 (char *) "self", NULL
14121 };
14122
14123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14125 if (SWIG_arg_fail(1)) SWIG_fail;
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 {
14129 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14130 result = (wxString *) &_result_ref;
14131 }
14132
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 {
14137 #if wxUSE_UNICODE
14138 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14139 #else
14140 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14141 #endif
14142 }
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj;
14151 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14152 wxString *result;
14153 PyObject * obj0 = 0 ;
14154 char *kwnames[] = {
14155 (char *) "self", NULL
14156 };
14157
14158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14160 if (SWIG_arg_fail(1)) SWIG_fail;
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 {
14164 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14165 result = (wxString *) &_result_ref;
14166 }
14167
14168 wxPyEndAllowThreads(__tstate);
14169 if (PyErr_Occurred()) SWIG_fail;
14170 }
14171 {
14172 #if wxUSE_UNICODE
14173 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14174 #else
14175 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14176 #endif
14177 }
14178 return resultobj;
14179 fail:
14180 return NULL;
14181 }
14182
14183
14184 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14187 wxString *result;
14188 PyObject * obj0 = 0 ;
14189 char *kwnames[] = {
14190 (char *) "self", NULL
14191 };
14192
14193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14195 if (SWIG_arg_fail(1)) SWIG_fail;
14196 {
14197 PyThreadState* __tstate = wxPyBeginAllowThreads();
14198 {
14199 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14200 result = (wxString *) &_result_ref;
14201 }
14202
14203 wxPyEndAllowThreads(__tstate);
14204 if (PyErr_Occurred()) SWIG_fail;
14205 }
14206 {
14207 #if wxUSE_UNICODE
14208 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14209 #else
14210 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14211 #endif
14212 }
14213 return resultobj;
14214 fail:
14215 return NULL;
14216 }
14217
14218
14219 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14220 PyObject *resultobj;
14221 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14222 wxArrayString *result;
14223 PyObject * obj0 = 0 ;
14224 char *kwnames[] = {
14225 (char *) "self", NULL
14226 };
14227
14228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14230 if (SWIG_arg_fail(1)) SWIG_fail;
14231 {
14232 PyThreadState* __tstate = wxPyBeginAllowThreads();
14233 {
14234 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14235 result = (wxArrayString *) &_result_ref;
14236 }
14237
14238 wxPyEndAllowThreads(__tstate);
14239 if (PyErr_Occurred()) SWIG_fail;
14240 }
14241 {
14242 resultobj = wxArrayString2PyList_helper(*result);
14243 }
14244 return resultobj;
14245 fail:
14246 return NULL;
14247 }
14248
14249
14250 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14251 PyObject *resultobj;
14252 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14253 int result;
14254 PyObject * obj0 = 0 ;
14255 char *kwnames[] = {
14256 (char *) "self", NULL
14257 };
14258
14259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14261 if (SWIG_arg_fail(1)) SWIG_fail;
14262 {
14263 PyThreadState* __tstate = wxPyBeginAllowThreads();
14264 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14265
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 {
14270 resultobj = SWIG_From_int((int)(result));
14271 }
14272 return resultobj;
14273 fail:
14274 return NULL;
14275 }
14276
14277
14278 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14279 PyObject *resultobj;
14280 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14281 wxString *result;
14282 PyObject * obj0 = 0 ;
14283 char *kwnames[] = {
14284 (char *) "self", NULL
14285 };
14286
14287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14289 if (SWIG_arg_fail(1)) SWIG_fail;
14290 {
14291 PyThreadState* __tstate = wxPyBeginAllowThreads();
14292 {
14293 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14294 result = (wxString *) &_result_ref;
14295 }
14296
14297 wxPyEndAllowThreads(__tstate);
14298 if (PyErr_Occurred()) SWIG_fail;
14299 }
14300 {
14301 #if wxUSE_UNICODE
14302 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14303 #else
14304 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14305 #endif
14306 }
14307 return resultobj;
14308 fail:
14309 return NULL;
14310 }
14311
14312
14313 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14314 PyObject *resultobj;
14315 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14316 int result;
14317 PyObject * obj0 = 0 ;
14318 char *kwnames[] = {
14319 (char *) "self", NULL
14320 };
14321
14322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14324 if (SWIG_arg_fail(1)) SWIG_fail;
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14328
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 {
14333 resultobj = SWIG_From_int((int)(result));
14334 }
14335 return resultobj;
14336 fail:
14337 return NULL;
14338 }
14339
14340
14341 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14342 PyObject *obj;
14343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14344 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14345 Py_INCREF(obj);
14346 return Py_BuildValue((char *)"");
14347 }
14348 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14349 PyObject *resultobj;
14350 wxFileTypeInfo *arg1 = 0 ;
14351 wxFileType *result;
14352 PyObject * obj0 = 0 ;
14353 char *kwnames[] = {
14354 (char *) "ftInfo", NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14358 {
14359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14360 if (SWIG_arg_fail(1)) SWIG_fail;
14361 if (arg1 == NULL) {
14362 SWIG_null_ref("wxFileTypeInfo");
14363 }
14364 if (SWIG_arg_fail(1)) SWIG_fail;
14365 }
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14369
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14381 PyObject *resultobj;
14382 wxFileType *arg1 = (wxFileType *) 0 ;
14383 PyObject * obj0 = 0 ;
14384 char *kwnames[] = {
14385 (char *) "self", NULL
14386 };
14387
14388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14390 if (SWIG_arg_fail(1)) SWIG_fail;
14391 {
14392 PyThreadState* __tstate = wxPyBeginAllowThreads();
14393 delete arg1;
14394
14395 wxPyEndAllowThreads(__tstate);
14396 if (PyErr_Occurred()) SWIG_fail;
14397 }
14398 Py_INCREF(Py_None); resultobj = Py_None;
14399 return resultobj;
14400 fail:
14401 return NULL;
14402 }
14403
14404
14405 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14406 PyObject *resultobj;
14407 wxFileType *arg1 = (wxFileType *) 0 ;
14408 PyObject *result;
14409 PyObject * obj0 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 {
14418 PyThreadState* __tstate = wxPyBeginAllowThreads();
14419 result = (PyObject *)wxFileType_GetMimeType(arg1);
14420
14421 wxPyEndAllowThreads(__tstate);
14422 if (PyErr_Occurred()) SWIG_fail;
14423 }
14424 resultobj = result;
14425 return resultobj;
14426 fail:
14427 return NULL;
14428 }
14429
14430
14431 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14432 PyObject *resultobj;
14433 wxFileType *arg1 = (wxFileType *) 0 ;
14434 PyObject *result;
14435 PyObject * obj0 = 0 ;
14436 char *kwnames[] = {
14437 (char *) "self", NULL
14438 };
14439
14440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14442 if (SWIG_arg_fail(1)) SWIG_fail;
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 resultobj = result;
14451 return resultobj;
14452 fail:
14453 return NULL;
14454 }
14455
14456
14457 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj;
14459 wxFileType *arg1 = (wxFileType *) 0 ;
14460 PyObject *result;
14461 PyObject * obj0 = 0 ;
14462 char *kwnames[] = {
14463 (char *) "self", NULL
14464 };
14465
14466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14468 if (SWIG_arg_fail(1)) SWIG_fail;
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 result = (PyObject *)wxFileType_GetExtensions(arg1);
14472
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 resultobj = result;
14477 return resultobj;
14478 fail:
14479 return NULL;
14480 }
14481
14482
14483 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14484 PyObject *resultobj;
14485 wxFileType *arg1 = (wxFileType *) 0 ;
14486 wxIcon *result;
14487 PyObject * obj0 = 0 ;
14488 char *kwnames[] = {
14489 (char *) "self", NULL
14490 };
14491
14492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14494 if (SWIG_arg_fail(1)) SWIG_fail;
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 result = (wxIcon *)wxFileType_GetIcon(arg1);
14498
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14510 PyObject *resultobj;
14511 wxFileType *arg1 = (wxFileType *) 0 ;
14512 PyObject *result;
14513 PyObject * obj0 = 0 ;
14514 char *kwnames[] = {
14515 (char *) "self", NULL
14516 };
14517
14518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14520 if (SWIG_arg_fail(1)) SWIG_fail;
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14524
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 resultobj = result;
14529 return resultobj;
14530 fail:
14531 return NULL;
14532 }
14533
14534
14535 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14536 PyObject *resultobj;
14537 wxFileType *arg1 = (wxFileType *) 0 ;
14538 PyObject *result;
14539 PyObject * obj0 = 0 ;
14540 char *kwnames[] = {
14541 (char *) "self", NULL
14542 };
14543
14544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14546 if (SWIG_arg_fail(1)) SWIG_fail;
14547 {
14548 PyThreadState* __tstate = wxPyBeginAllowThreads();
14549 result = (PyObject *)wxFileType_GetDescription(arg1);
14550
14551 wxPyEndAllowThreads(__tstate);
14552 if (PyErr_Occurred()) SWIG_fail;
14553 }
14554 resultobj = result;
14555 return resultobj;
14556 fail:
14557 return NULL;
14558 }
14559
14560
14561 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14562 PyObject *resultobj;
14563 wxFileType *arg1 = (wxFileType *) 0 ;
14564 wxString *arg2 = 0 ;
14565 wxString const &arg3_defvalue = wxPyEmptyString ;
14566 wxString *arg3 = (wxString *) &arg3_defvalue ;
14567 PyObject *result;
14568 bool temp2 = false ;
14569 bool temp3 = false ;
14570 PyObject * obj0 = 0 ;
14571 PyObject * obj1 = 0 ;
14572 PyObject * obj2 = 0 ;
14573 char *kwnames[] = {
14574 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14575 };
14576
14577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14579 if (SWIG_arg_fail(1)) SWIG_fail;
14580 {
14581 arg2 = wxString_in_helper(obj1);
14582 if (arg2 == NULL) SWIG_fail;
14583 temp2 = true;
14584 }
14585 if (obj2) {
14586 {
14587 arg3 = wxString_in_helper(obj2);
14588 if (arg3 == NULL) SWIG_fail;
14589 temp3 = true;
14590 }
14591 }
14592 {
14593 PyThreadState* __tstate = wxPyBeginAllowThreads();
14594 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14595
14596 wxPyEndAllowThreads(__tstate);
14597 if (PyErr_Occurred()) SWIG_fail;
14598 }
14599 resultobj = result;
14600 {
14601 if (temp2)
14602 delete arg2;
14603 }
14604 {
14605 if (temp3)
14606 delete arg3;
14607 }
14608 return resultobj;
14609 fail:
14610 {
14611 if (temp2)
14612 delete arg2;
14613 }
14614 {
14615 if (temp3)
14616 delete arg3;
14617 }
14618 return NULL;
14619 }
14620
14621
14622 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14623 PyObject *resultobj;
14624 wxFileType *arg1 = (wxFileType *) 0 ;
14625 wxString *arg2 = 0 ;
14626 wxString const &arg3_defvalue = wxPyEmptyString ;
14627 wxString *arg3 = (wxString *) &arg3_defvalue ;
14628 PyObject *result;
14629 bool temp2 = false ;
14630 bool temp3 = false ;
14631 PyObject * obj0 = 0 ;
14632 PyObject * obj1 = 0 ;
14633 PyObject * obj2 = 0 ;
14634 char *kwnames[] = {
14635 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14636 };
14637
14638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14640 if (SWIG_arg_fail(1)) SWIG_fail;
14641 {
14642 arg2 = wxString_in_helper(obj1);
14643 if (arg2 == NULL) SWIG_fail;
14644 temp2 = true;
14645 }
14646 if (obj2) {
14647 {
14648 arg3 = wxString_in_helper(obj2);
14649 if (arg3 == NULL) SWIG_fail;
14650 temp3 = true;
14651 }
14652 }
14653 {
14654 PyThreadState* __tstate = wxPyBeginAllowThreads();
14655 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14656
14657 wxPyEndAllowThreads(__tstate);
14658 if (PyErr_Occurred()) SWIG_fail;
14659 }
14660 resultobj = result;
14661 {
14662 if (temp2)
14663 delete arg2;
14664 }
14665 {
14666 if (temp3)
14667 delete arg3;
14668 }
14669 return resultobj;
14670 fail:
14671 {
14672 if (temp2)
14673 delete arg2;
14674 }
14675 {
14676 if (temp3)
14677 delete arg3;
14678 }
14679 return NULL;
14680 }
14681
14682
14683 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14684 PyObject *resultobj;
14685 wxFileType *arg1 = (wxFileType *) 0 ;
14686 wxString *arg2 = 0 ;
14687 wxString const &arg3_defvalue = wxPyEmptyString ;
14688 wxString *arg3 = (wxString *) &arg3_defvalue ;
14689 PyObject *result;
14690 bool temp2 = false ;
14691 bool temp3 = false ;
14692 PyObject * obj0 = 0 ;
14693 PyObject * obj1 = 0 ;
14694 PyObject * obj2 = 0 ;
14695 char *kwnames[] = {
14696 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14697 };
14698
14699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14701 if (SWIG_arg_fail(1)) SWIG_fail;
14702 {
14703 arg2 = wxString_in_helper(obj1);
14704 if (arg2 == NULL) SWIG_fail;
14705 temp2 = true;
14706 }
14707 if (obj2) {
14708 {
14709 arg3 = wxString_in_helper(obj2);
14710 if (arg3 == NULL) SWIG_fail;
14711 temp3 = true;
14712 }
14713 }
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14717
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 resultobj = result;
14722 {
14723 if (temp2)
14724 delete arg2;
14725 }
14726 {
14727 if (temp3)
14728 delete arg3;
14729 }
14730 return resultobj;
14731 fail:
14732 {
14733 if (temp2)
14734 delete arg2;
14735 }
14736 {
14737 if (temp3)
14738 delete arg3;
14739 }
14740 return NULL;
14741 }
14742
14743
14744 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14745 PyObject *resultobj;
14746 wxFileType *arg1 = (wxFileType *) 0 ;
14747 wxString *arg2 = 0 ;
14748 wxString *arg3 = 0 ;
14749 bool arg4 = (bool) true ;
14750 bool result;
14751 bool temp2 = false ;
14752 bool temp3 = false ;
14753 PyObject * obj0 = 0 ;
14754 PyObject * obj1 = 0 ;
14755 PyObject * obj2 = 0 ;
14756 PyObject * obj3 = 0 ;
14757 char *kwnames[] = {
14758 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14759 };
14760
14761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14763 if (SWIG_arg_fail(1)) SWIG_fail;
14764 {
14765 arg2 = wxString_in_helper(obj1);
14766 if (arg2 == NULL) SWIG_fail;
14767 temp2 = true;
14768 }
14769 {
14770 arg3 = wxString_in_helper(obj2);
14771 if (arg3 == NULL) SWIG_fail;
14772 temp3 = true;
14773 }
14774 if (obj3) {
14775 {
14776 arg4 = (bool)(SWIG_As_bool(obj3));
14777 if (SWIG_arg_fail(4)) SWIG_fail;
14778 }
14779 }
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14783
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 {
14788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14789 }
14790 {
14791 if (temp2)
14792 delete arg2;
14793 }
14794 {
14795 if (temp3)
14796 delete arg3;
14797 }
14798 return resultobj;
14799 fail:
14800 {
14801 if (temp2)
14802 delete arg2;
14803 }
14804 {
14805 if (temp3)
14806 delete arg3;
14807 }
14808 return NULL;
14809 }
14810
14811
14812 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14813 PyObject *resultobj;
14814 wxFileType *arg1 = (wxFileType *) 0 ;
14815 wxString const &arg2_defvalue = wxPyEmptyString ;
14816 wxString *arg2 = (wxString *) &arg2_defvalue ;
14817 int arg3 = (int) 0 ;
14818 bool result;
14819 bool temp2 = false ;
14820 PyObject * obj0 = 0 ;
14821 PyObject * obj1 = 0 ;
14822 PyObject * obj2 = 0 ;
14823 char *kwnames[] = {
14824 (char *) "self",(char *) "cmd",(char *) "index", NULL
14825 };
14826
14827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14829 if (SWIG_arg_fail(1)) SWIG_fail;
14830 if (obj1) {
14831 {
14832 arg2 = wxString_in_helper(obj1);
14833 if (arg2 == NULL) SWIG_fail;
14834 temp2 = true;
14835 }
14836 }
14837 if (obj2) {
14838 {
14839 arg3 = (int)(SWIG_As_int(obj2));
14840 if (SWIG_arg_fail(3)) SWIG_fail;
14841 }
14842 }
14843 {
14844 PyThreadState* __tstate = wxPyBeginAllowThreads();
14845 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14846
14847 wxPyEndAllowThreads(__tstate);
14848 if (PyErr_Occurred()) SWIG_fail;
14849 }
14850 {
14851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14852 }
14853 {
14854 if (temp2)
14855 delete arg2;
14856 }
14857 return resultobj;
14858 fail:
14859 {
14860 if (temp2)
14861 delete arg2;
14862 }
14863 return NULL;
14864 }
14865
14866
14867 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14868 PyObject *resultobj;
14869 wxFileType *arg1 = (wxFileType *) 0 ;
14870 bool result;
14871 PyObject * obj0 = 0 ;
14872 char *kwnames[] = {
14873 (char *) "self", NULL
14874 };
14875
14876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14878 if (SWIG_arg_fail(1)) SWIG_fail;
14879 {
14880 PyThreadState* __tstate = wxPyBeginAllowThreads();
14881 result = (bool)(arg1)->Unassociate();
14882
14883 wxPyEndAllowThreads(__tstate);
14884 if (PyErr_Occurred()) SWIG_fail;
14885 }
14886 {
14887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14888 }
14889 return resultobj;
14890 fail:
14891 return NULL;
14892 }
14893
14894
14895 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14896 PyObject *resultobj;
14897 wxString *arg1 = 0 ;
14898 wxString *arg2 = 0 ;
14899 wxString const &arg3_defvalue = wxPyEmptyString ;
14900 wxString *arg3 = (wxString *) &arg3_defvalue ;
14901 wxString result;
14902 bool temp1 = false ;
14903 bool temp2 = false ;
14904 bool temp3 = false ;
14905 PyObject * obj0 = 0 ;
14906 PyObject * obj1 = 0 ;
14907 PyObject * obj2 = 0 ;
14908 char *kwnames[] = {
14909 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14910 };
14911
14912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14913 {
14914 arg1 = wxString_in_helper(obj0);
14915 if (arg1 == NULL) SWIG_fail;
14916 temp1 = true;
14917 }
14918 {
14919 arg2 = wxString_in_helper(obj1);
14920 if (arg2 == NULL) SWIG_fail;
14921 temp2 = true;
14922 }
14923 if (obj2) {
14924 {
14925 arg3 = wxString_in_helper(obj2);
14926 if (arg3 == NULL) SWIG_fail;
14927 temp3 = true;
14928 }
14929 }
14930 {
14931 PyThreadState* __tstate = wxPyBeginAllowThreads();
14932 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14933
14934 wxPyEndAllowThreads(__tstate);
14935 if (PyErr_Occurred()) SWIG_fail;
14936 }
14937 {
14938 #if wxUSE_UNICODE
14939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14940 #else
14941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14942 #endif
14943 }
14944 {
14945 if (temp1)
14946 delete arg1;
14947 }
14948 {
14949 if (temp2)
14950 delete arg2;
14951 }
14952 {
14953 if (temp3)
14954 delete arg3;
14955 }
14956 return resultobj;
14957 fail:
14958 {
14959 if (temp1)
14960 delete arg1;
14961 }
14962 {
14963 if (temp2)
14964 delete arg2;
14965 }
14966 {
14967 if (temp3)
14968 delete arg3;
14969 }
14970 return NULL;
14971 }
14972
14973
14974 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14975 PyObject *obj;
14976 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14977 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14978 Py_INCREF(obj);
14979 return Py_BuildValue((char *)"");
14980 }
14981 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14982 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14983 return 1;
14984 }
14985
14986
14987 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14988 PyObject *pyobj;
14989
14990 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14991 return pyobj;
14992 }
14993
14994
14995 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14996 PyObject *resultobj;
14997 wxString *arg1 = 0 ;
14998 wxString *arg2 = 0 ;
14999 bool result;
15000 bool temp1 = false ;
15001 bool temp2 = false ;
15002 PyObject * obj0 = 0 ;
15003 PyObject * obj1 = 0 ;
15004 char *kwnames[] = {
15005 (char *) "mimeType",(char *) "wildcard", NULL
15006 };
15007
15008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15009 {
15010 arg1 = wxString_in_helper(obj0);
15011 if (arg1 == NULL) SWIG_fail;
15012 temp1 = true;
15013 }
15014 {
15015 arg2 = wxString_in_helper(obj1);
15016 if (arg2 == NULL) SWIG_fail;
15017 temp2 = true;
15018 }
15019 {
15020 PyThreadState* __tstate = wxPyBeginAllowThreads();
15021 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15022
15023 wxPyEndAllowThreads(__tstate);
15024 if (PyErr_Occurred()) SWIG_fail;
15025 }
15026 {
15027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15028 }
15029 {
15030 if (temp1)
15031 delete arg1;
15032 }
15033 {
15034 if (temp2)
15035 delete arg2;
15036 }
15037 return resultobj;
15038 fail:
15039 {
15040 if (temp1)
15041 delete arg1;
15042 }
15043 {
15044 if (temp2)
15045 delete arg2;
15046 }
15047 return NULL;
15048 }
15049
15050
15051 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15052 PyObject *resultobj;
15053 wxMimeTypesManager *result;
15054 char *kwnames[] = {
15055 NULL
15056 };
15057
15058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15059 {
15060 PyThreadState* __tstate = wxPyBeginAllowThreads();
15061 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15062
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15067 return resultobj;
15068 fail:
15069 return NULL;
15070 }
15071
15072
15073 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15074 PyObject *resultobj;
15075 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15076 int arg2 = (int) wxMAILCAP_ALL ;
15077 wxString const &arg3_defvalue = wxPyEmptyString ;
15078 wxString *arg3 = (wxString *) &arg3_defvalue ;
15079 bool temp3 = false ;
15080 PyObject * obj0 = 0 ;
15081 PyObject * obj1 = 0 ;
15082 PyObject * obj2 = 0 ;
15083 char *kwnames[] = {
15084 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15085 };
15086
15087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15089 if (SWIG_arg_fail(1)) SWIG_fail;
15090 if (obj1) {
15091 {
15092 arg2 = (int)(SWIG_As_int(obj1));
15093 if (SWIG_arg_fail(2)) SWIG_fail;
15094 }
15095 }
15096 if (obj2) {
15097 {
15098 arg3 = wxString_in_helper(obj2);
15099 if (arg3 == NULL) SWIG_fail;
15100 temp3 = true;
15101 }
15102 }
15103 {
15104 PyThreadState* __tstate = wxPyBeginAllowThreads();
15105 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15106
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 Py_INCREF(Py_None); resultobj = Py_None;
15111 {
15112 if (temp3)
15113 delete arg3;
15114 }
15115 return resultobj;
15116 fail:
15117 {
15118 if (temp3)
15119 delete arg3;
15120 }
15121 return NULL;
15122 }
15123
15124
15125 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15126 PyObject *resultobj;
15127 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15128 PyObject * obj0 = 0 ;
15129 char *kwnames[] = {
15130 (char *) "self", NULL
15131 };
15132
15133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15135 if (SWIG_arg_fail(1)) SWIG_fail;
15136 {
15137 PyThreadState* __tstate = wxPyBeginAllowThreads();
15138 (arg1)->ClearData();
15139
15140 wxPyEndAllowThreads(__tstate);
15141 if (PyErr_Occurred()) SWIG_fail;
15142 }
15143 Py_INCREF(Py_None); resultobj = Py_None;
15144 return resultobj;
15145 fail:
15146 return NULL;
15147 }
15148
15149
15150 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15151 PyObject *resultobj;
15152 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15153 wxString *arg2 = 0 ;
15154 wxFileType *result;
15155 bool temp2 = false ;
15156 PyObject * obj0 = 0 ;
15157 PyObject * obj1 = 0 ;
15158 char *kwnames[] = {
15159 (char *) "self",(char *) "ext", NULL
15160 };
15161
15162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15164 if (SWIG_arg_fail(1)) SWIG_fail;
15165 {
15166 arg2 = wxString_in_helper(obj1);
15167 if (arg2 == NULL) SWIG_fail;
15168 temp2 = true;
15169 }
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15173
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15178 {
15179 if (temp2)
15180 delete arg2;
15181 }
15182 return resultobj;
15183 fail:
15184 {
15185 if (temp2)
15186 delete arg2;
15187 }
15188 return NULL;
15189 }
15190
15191
15192 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15193 PyObject *resultobj;
15194 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15195 wxString *arg2 = 0 ;
15196 wxFileType *result;
15197 bool temp2 = false ;
15198 PyObject * obj0 = 0 ;
15199 PyObject * obj1 = 0 ;
15200 char *kwnames[] = {
15201 (char *) "self",(char *) "mimeType", NULL
15202 };
15203
15204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15206 if (SWIG_arg_fail(1)) SWIG_fail;
15207 {
15208 arg2 = wxString_in_helper(obj1);
15209 if (arg2 == NULL) SWIG_fail;
15210 temp2 = true;
15211 }
15212 {
15213 PyThreadState* __tstate = wxPyBeginAllowThreads();
15214 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15215
15216 wxPyEndAllowThreads(__tstate);
15217 if (PyErr_Occurred()) SWIG_fail;
15218 }
15219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15220 {
15221 if (temp2)
15222 delete arg2;
15223 }
15224 return resultobj;
15225 fail:
15226 {
15227 if (temp2)
15228 delete arg2;
15229 }
15230 return NULL;
15231 }
15232
15233
15234 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15235 PyObject *resultobj;
15236 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15237 wxString *arg2 = 0 ;
15238 bool arg3 = (bool) false ;
15239 bool result;
15240 bool temp2 = false ;
15241 PyObject * obj0 = 0 ;
15242 PyObject * obj1 = 0 ;
15243 PyObject * obj2 = 0 ;
15244 char *kwnames[] = {
15245 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15246 };
15247
15248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15250 if (SWIG_arg_fail(1)) SWIG_fail;
15251 {
15252 arg2 = wxString_in_helper(obj1);
15253 if (arg2 == NULL) SWIG_fail;
15254 temp2 = true;
15255 }
15256 if (obj2) {
15257 {
15258 arg3 = (bool)(SWIG_As_bool(obj2));
15259 if (SWIG_arg_fail(3)) SWIG_fail;
15260 }
15261 }
15262 {
15263 PyThreadState* __tstate = wxPyBeginAllowThreads();
15264 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15265
15266 wxPyEndAllowThreads(__tstate);
15267 if (PyErr_Occurred()) SWIG_fail;
15268 }
15269 {
15270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15271 }
15272 {
15273 if (temp2)
15274 delete arg2;
15275 }
15276 return resultobj;
15277 fail:
15278 {
15279 if (temp2)
15280 delete arg2;
15281 }
15282 return NULL;
15283 }
15284
15285
15286 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15287 PyObject *resultobj;
15288 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15289 wxString *arg2 = 0 ;
15290 bool result;
15291 bool temp2 = false ;
15292 PyObject * obj0 = 0 ;
15293 PyObject * obj1 = 0 ;
15294 char *kwnames[] = {
15295 (char *) "self",(char *) "filename", NULL
15296 };
15297
15298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15300 if (SWIG_arg_fail(1)) SWIG_fail;
15301 {
15302 arg2 = wxString_in_helper(obj1);
15303 if (arg2 == NULL) SWIG_fail;
15304 temp2 = true;
15305 }
15306 {
15307 PyThreadState* __tstate = wxPyBeginAllowThreads();
15308 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15309
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 {
15314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15315 }
15316 {
15317 if (temp2)
15318 delete arg2;
15319 }
15320 return resultobj;
15321 fail:
15322 {
15323 if (temp2)
15324 delete arg2;
15325 }
15326 return NULL;
15327 }
15328
15329
15330 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15331 PyObject *resultobj;
15332 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15333 PyObject *result;
15334 PyObject * obj0 = 0 ;
15335 char *kwnames[] = {
15336 (char *) "self", NULL
15337 };
15338
15339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15341 if (SWIG_arg_fail(1)) SWIG_fail;
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15345
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 resultobj = result;
15350 return resultobj;
15351 fail:
15352 return NULL;
15353 }
15354
15355
15356 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15357 PyObject *resultobj;
15358 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15359 wxFileTypeInfo *arg2 = 0 ;
15360 PyObject * obj0 = 0 ;
15361 PyObject * obj1 = 0 ;
15362 char *kwnames[] = {
15363 (char *) "self",(char *) "ft", NULL
15364 };
15365
15366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15368 if (SWIG_arg_fail(1)) SWIG_fail;
15369 {
15370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15371 if (SWIG_arg_fail(2)) SWIG_fail;
15372 if (arg2 == NULL) {
15373 SWIG_null_ref("wxFileTypeInfo");
15374 }
15375 if (SWIG_arg_fail(2)) SWIG_fail;
15376 }
15377 {
15378 PyThreadState* __tstate = wxPyBeginAllowThreads();
15379 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15380
15381 wxPyEndAllowThreads(__tstate);
15382 if (PyErr_Occurred()) SWIG_fail;
15383 }
15384 Py_INCREF(Py_None); resultobj = Py_None;
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15392 PyObject *resultobj;
15393 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15394 wxFileTypeInfo *arg2 = 0 ;
15395 wxFileType *result;
15396 PyObject * obj0 = 0 ;
15397 PyObject * obj1 = 0 ;
15398 char *kwnames[] = {
15399 (char *) "self",(char *) "ftInfo", NULL
15400 };
15401
15402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15404 if (SWIG_arg_fail(1)) SWIG_fail;
15405 {
15406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15407 if (SWIG_arg_fail(2)) SWIG_fail;
15408 if (arg2 == NULL) {
15409 SWIG_null_ref("wxFileTypeInfo");
15410 }
15411 if (SWIG_arg_fail(2)) SWIG_fail;
15412 }
15413 {
15414 PyThreadState* __tstate = wxPyBeginAllowThreads();
15415 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15416
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15421 return resultobj;
15422 fail:
15423 return NULL;
15424 }
15425
15426
15427 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15428 PyObject *resultobj;
15429 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15430 wxFileType *arg2 = (wxFileType *) 0 ;
15431 bool result;
15432 PyObject * obj0 = 0 ;
15433 PyObject * obj1 = 0 ;
15434 char *kwnames[] = {
15435 (char *) "self",(char *) "ft", NULL
15436 };
15437
15438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15440 if (SWIG_arg_fail(1)) SWIG_fail;
15441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15442 if (SWIG_arg_fail(2)) SWIG_fail;
15443 {
15444 PyThreadState* __tstate = wxPyBeginAllowThreads();
15445 result = (bool)(arg1)->Unassociate(arg2);
15446
15447 wxPyEndAllowThreads(__tstate);
15448 if (PyErr_Occurred()) SWIG_fail;
15449 }
15450 {
15451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15452 }
15453 return resultobj;
15454 fail:
15455 return NULL;
15456 }
15457
15458
15459 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15460 PyObject *resultobj;
15461 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15462 PyObject * obj0 = 0 ;
15463 char *kwnames[] = {
15464 (char *) "self", NULL
15465 };
15466
15467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15469 if (SWIG_arg_fail(1)) SWIG_fail;
15470 {
15471 PyThreadState* __tstate = wxPyBeginAllowThreads();
15472 delete arg1;
15473
15474 wxPyEndAllowThreads(__tstate);
15475 if (PyErr_Occurred()) SWIG_fail;
15476 }
15477 Py_INCREF(Py_None); resultobj = Py_None;
15478 return resultobj;
15479 fail:
15480 return NULL;
15481 }
15482
15483
15484 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15485 PyObject *obj;
15486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15487 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15488 Py_INCREF(obj);
15489 return Py_BuildValue((char *)"");
15490 }
15491 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15492 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15493 return 1;
15494 }
15495
15496
15497 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15498 PyObject *pyobj;
15499
15500 {
15501 #if wxUSE_UNICODE
15502 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15503 #else
15504 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15505 #endif
15506 }
15507 return pyobj;
15508 }
15509
15510
15511 static int _wrap_ART_MENU_set(PyObject *) {
15512 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15513 return 1;
15514 }
15515
15516
15517 static PyObject *_wrap_ART_MENU_get(void) {
15518 PyObject *pyobj;
15519
15520 {
15521 #if wxUSE_UNICODE
15522 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15523 #else
15524 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15525 #endif
15526 }
15527 return pyobj;
15528 }
15529
15530
15531 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15532 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15533 return 1;
15534 }
15535
15536
15537 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15538 PyObject *pyobj;
15539
15540 {
15541 #if wxUSE_UNICODE
15542 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15543 #else
15544 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15545 #endif
15546 }
15547 return pyobj;
15548 }
15549
15550
15551 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15552 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15553 return 1;
15554 }
15555
15556
15557 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15558 PyObject *pyobj;
15559
15560 {
15561 #if wxUSE_UNICODE
15562 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15563 #else
15564 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15565 #endif
15566 }
15567 return pyobj;
15568 }
15569
15570
15571 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15572 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15573 return 1;
15574 }
15575
15576
15577 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15578 PyObject *pyobj;
15579
15580 {
15581 #if wxUSE_UNICODE
15582 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15583 #else
15584 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15585 #endif
15586 }
15587 return pyobj;
15588 }
15589
15590
15591 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15592 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15593 return 1;
15594 }
15595
15596
15597 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15598 PyObject *pyobj;
15599
15600 {
15601 #if wxUSE_UNICODE
15602 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15603 #else
15604 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15605 #endif
15606 }
15607 return pyobj;
15608 }
15609
15610
15611 static int _wrap_ART_BUTTON_set(PyObject *) {
15612 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15613 return 1;
15614 }
15615
15616
15617 static PyObject *_wrap_ART_BUTTON_get(void) {
15618 PyObject *pyobj;
15619
15620 {
15621 #if wxUSE_UNICODE
15622 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15623 #else
15624 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15625 #endif
15626 }
15627 return pyobj;
15628 }
15629
15630
15631 static int _wrap_ART_OTHER_set(PyObject *) {
15632 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15633 return 1;
15634 }
15635
15636
15637 static PyObject *_wrap_ART_OTHER_get(void) {
15638 PyObject *pyobj;
15639
15640 {
15641 #if wxUSE_UNICODE
15642 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15643 #else
15644 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15645 #endif
15646 }
15647 return pyobj;
15648 }
15649
15650
15651 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15652 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15653 return 1;
15654 }
15655
15656
15657 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15658 PyObject *pyobj;
15659
15660 {
15661 #if wxUSE_UNICODE
15662 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15663 #else
15664 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15665 #endif
15666 }
15667 return pyobj;
15668 }
15669
15670
15671 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15672 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15673 return 1;
15674 }
15675
15676
15677 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15678 PyObject *pyobj;
15679
15680 {
15681 #if wxUSE_UNICODE
15682 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15683 #else
15684 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15685 #endif
15686 }
15687 return pyobj;
15688 }
15689
15690
15691 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15692 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15693 return 1;
15694 }
15695
15696
15697 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15698 PyObject *pyobj;
15699
15700 {
15701 #if wxUSE_UNICODE
15702 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15703 #else
15704 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15705 #endif
15706 }
15707 return pyobj;
15708 }
15709
15710
15711 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15712 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15713 return 1;
15714 }
15715
15716
15717 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15718 PyObject *pyobj;
15719
15720 {
15721 #if wxUSE_UNICODE
15722 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15723 #else
15724 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15725 #endif
15726 }
15727 return pyobj;
15728 }
15729
15730
15731 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15732 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15733 return 1;
15734 }
15735
15736
15737 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15738 PyObject *pyobj;
15739
15740 {
15741 #if wxUSE_UNICODE
15742 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15743 #else
15744 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15745 #endif
15746 }
15747 return pyobj;
15748 }
15749
15750
15751 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15752 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15753 return 1;
15754 }
15755
15756
15757 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15758 PyObject *pyobj;
15759
15760 {
15761 #if wxUSE_UNICODE
15762 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15763 #else
15764 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15765 #endif
15766 }
15767 return pyobj;
15768 }
15769
15770
15771 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15772 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15773 return 1;
15774 }
15775
15776
15777 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15778 PyObject *pyobj;
15779
15780 {
15781 #if wxUSE_UNICODE
15782 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15783 #else
15784 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15785 #endif
15786 }
15787 return pyobj;
15788 }
15789
15790
15791 static int _wrap_ART_GO_BACK_set(PyObject *) {
15792 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15793 return 1;
15794 }
15795
15796
15797 static PyObject *_wrap_ART_GO_BACK_get(void) {
15798 PyObject *pyobj;
15799
15800 {
15801 #if wxUSE_UNICODE
15802 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15803 #else
15804 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15805 #endif
15806 }
15807 return pyobj;
15808 }
15809
15810
15811 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15812 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15813 return 1;
15814 }
15815
15816
15817 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15818 PyObject *pyobj;
15819
15820 {
15821 #if wxUSE_UNICODE
15822 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15823 #else
15824 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15825 #endif
15826 }
15827 return pyobj;
15828 }
15829
15830
15831 static int _wrap_ART_GO_UP_set(PyObject *) {
15832 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15833 return 1;
15834 }
15835
15836
15837 static PyObject *_wrap_ART_GO_UP_get(void) {
15838 PyObject *pyobj;
15839
15840 {
15841 #if wxUSE_UNICODE
15842 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15843 #else
15844 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15845 #endif
15846 }
15847 return pyobj;
15848 }
15849
15850
15851 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15852 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15853 return 1;
15854 }
15855
15856
15857 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15858 PyObject *pyobj;
15859
15860 {
15861 #if wxUSE_UNICODE
15862 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15863 #else
15864 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15865 #endif
15866 }
15867 return pyobj;
15868 }
15869
15870
15871 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15872 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15873 return 1;
15874 }
15875
15876
15877 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15878 PyObject *pyobj;
15879
15880 {
15881 #if wxUSE_UNICODE
15882 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15883 #else
15884 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15885 #endif
15886 }
15887 return pyobj;
15888 }
15889
15890
15891 static int _wrap_ART_GO_HOME_set(PyObject *) {
15892 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15893 return 1;
15894 }
15895
15896
15897 static PyObject *_wrap_ART_GO_HOME_get(void) {
15898 PyObject *pyobj;
15899
15900 {
15901 #if wxUSE_UNICODE
15902 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15903 #else
15904 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15905 #endif
15906 }
15907 return pyobj;
15908 }
15909
15910
15911 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15912 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15913 return 1;
15914 }
15915
15916
15917 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15918 PyObject *pyobj;
15919
15920 {
15921 #if wxUSE_UNICODE
15922 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15923 #else
15924 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15925 #endif
15926 }
15927 return pyobj;
15928 }
15929
15930
15931 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15932 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15933 return 1;
15934 }
15935
15936
15937 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15938 PyObject *pyobj;
15939
15940 {
15941 #if wxUSE_UNICODE
15942 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15943 #else
15944 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15945 #endif
15946 }
15947 return pyobj;
15948 }
15949
15950
15951 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15952 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15953 return 1;
15954 }
15955
15956
15957 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15958 PyObject *pyobj;
15959
15960 {
15961 #if wxUSE_UNICODE
15962 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15963 #else
15964 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15965 #endif
15966 }
15967 return pyobj;
15968 }
15969
15970
15971 static int _wrap_ART_PRINT_set(PyObject *) {
15972 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15973 return 1;
15974 }
15975
15976
15977 static PyObject *_wrap_ART_PRINT_get(void) {
15978 PyObject *pyobj;
15979
15980 {
15981 #if wxUSE_UNICODE
15982 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15983 #else
15984 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15985 #endif
15986 }
15987 return pyobj;
15988 }
15989
15990
15991 static int _wrap_ART_HELP_set(PyObject *) {
15992 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15993 return 1;
15994 }
15995
15996
15997 static PyObject *_wrap_ART_HELP_get(void) {
15998 PyObject *pyobj;
15999
16000 {
16001 #if wxUSE_UNICODE
16002 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16003 #else
16004 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16005 #endif
16006 }
16007 return pyobj;
16008 }
16009
16010
16011 static int _wrap_ART_TIP_set(PyObject *) {
16012 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16013 return 1;
16014 }
16015
16016
16017 static PyObject *_wrap_ART_TIP_get(void) {
16018 PyObject *pyobj;
16019
16020 {
16021 #if wxUSE_UNICODE
16022 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16023 #else
16024 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16025 #endif
16026 }
16027 return pyobj;
16028 }
16029
16030
16031 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16032 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16033 return 1;
16034 }
16035
16036
16037 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16038 PyObject *pyobj;
16039
16040 {
16041 #if wxUSE_UNICODE
16042 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16043 #else
16044 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16045 #endif
16046 }
16047 return pyobj;
16048 }
16049
16050
16051 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16052 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16053 return 1;
16054 }
16055
16056
16057 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16058 PyObject *pyobj;
16059
16060 {
16061 #if wxUSE_UNICODE
16062 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16063 #else
16064 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16065 #endif
16066 }
16067 return pyobj;
16068 }
16069
16070
16071 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16072 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16073 return 1;
16074 }
16075
16076
16077 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16078 PyObject *pyobj;
16079
16080 {
16081 #if wxUSE_UNICODE
16082 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16083 #else
16084 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16085 #endif
16086 }
16087 return pyobj;
16088 }
16089
16090
16091 static int _wrap_ART_HARDDISK_set(PyObject *) {
16092 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16093 return 1;
16094 }
16095
16096
16097 static PyObject *_wrap_ART_HARDDISK_get(void) {
16098 PyObject *pyobj;
16099
16100 {
16101 #if wxUSE_UNICODE
16102 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16103 #else
16104 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16105 #endif
16106 }
16107 return pyobj;
16108 }
16109
16110
16111 static int _wrap_ART_FLOPPY_set(PyObject *) {
16112 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16113 return 1;
16114 }
16115
16116
16117 static PyObject *_wrap_ART_FLOPPY_get(void) {
16118 PyObject *pyobj;
16119
16120 {
16121 #if wxUSE_UNICODE
16122 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16123 #else
16124 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16125 #endif
16126 }
16127 return pyobj;
16128 }
16129
16130
16131 static int _wrap_ART_CDROM_set(PyObject *) {
16132 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16133 return 1;
16134 }
16135
16136
16137 static PyObject *_wrap_ART_CDROM_get(void) {
16138 PyObject *pyobj;
16139
16140 {
16141 #if wxUSE_UNICODE
16142 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16143 #else
16144 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16145 #endif
16146 }
16147 return pyobj;
16148 }
16149
16150
16151 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16152 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16153 return 1;
16154 }
16155
16156
16157 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16158 PyObject *pyobj;
16159
16160 {
16161 #if wxUSE_UNICODE
16162 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16163 #else
16164 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16165 #endif
16166 }
16167 return pyobj;
16168 }
16169
16170
16171 static int _wrap_ART_FOLDER_set(PyObject *) {
16172 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16173 return 1;
16174 }
16175
16176
16177 static PyObject *_wrap_ART_FOLDER_get(void) {
16178 PyObject *pyobj;
16179
16180 {
16181 #if wxUSE_UNICODE
16182 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16183 #else
16184 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16185 #endif
16186 }
16187 return pyobj;
16188 }
16189
16190
16191 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16192 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16193 return 1;
16194 }
16195
16196
16197 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16198 PyObject *pyobj;
16199
16200 {
16201 #if wxUSE_UNICODE
16202 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16203 #else
16204 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16205 #endif
16206 }
16207 return pyobj;
16208 }
16209
16210
16211 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16212 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16213 return 1;
16214 }
16215
16216
16217 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16218 PyObject *pyobj;
16219
16220 {
16221 #if wxUSE_UNICODE
16222 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16223 #else
16224 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16225 #endif
16226 }
16227 return pyobj;
16228 }
16229
16230
16231 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16232 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16233 return 1;
16234 }
16235
16236
16237 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16238 PyObject *pyobj;
16239
16240 {
16241 #if wxUSE_UNICODE
16242 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16243 #else
16244 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16245 #endif
16246 }
16247 return pyobj;
16248 }
16249
16250
16251 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16252 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16253 return 1;
16254 }
16255
16256
16257 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16258 PyObject *pyobj;
16259
16260 {
16261 #if wxUSE_UNICODE
16262 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16263 #else
16264 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16265 #endif
16266 }
16267 return pyobj;
16268 }
16269
16270
16271 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16272 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16273 return 1;
16274 }
16275
16276
16277 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16278 PyObject *pyobj;
16279
16280 {
16281 #if wxUSE_UNICODE
16282 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16283 #else
16284 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16285 #endif
16286 }
16287 return pyobj;
16288 }
16289
16290
16291 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16292 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16293 return 1;
16294 }
16295
16296
16297 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16298 PyObject *pyobj;
16299
16300 {
16301 #if wxUSE_UNICODE
16302 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16303 #else
16304 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16305 #endif
16306 }
16307 return pyobj;
16308 }
16309
16310
16311 static int _wrap_ART_ERROR_set(PyObject *) {
16312 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16313 return 1;
16314 }
16315
16316
16317 static PyObject *_wrap_ART_ERROR_get(void) {
16318 PyObject *pyobj;
16319
16320 {
16321 #if wxUSE_UNICODE
16322 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16323 #else
16324 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16325 #endif
16326 }
16327 return pyobj;
16328 }
16329
16330
16331 static int _wrap_ART_QUESTION_set(PyObject *) {
16332 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16333 return 1;
16334 }
16335
16336
16337 static PyObject *_wrap_ART_QUESTION_get(void) {
16338 PyObject *pyobj;
16339
16340 {
16341 #if wxUSE_UNICODE
16342 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16343 #else
16344 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16345 #endif
16346 }
16347 return pyobj;
16348 }
16349
16350
16351 static int _wrap_ART_WARNING_set(PyObject *) {
16352 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16353 return 1;
16354 }
16355
16356
16357 static PyObject *_wrap_ART_WARNING_get(void) {
16358 PyObject *pyobj;
16359
16360 {
16361 #if wxUSE_UNICODE
16362 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16363 #else
16364 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16365 #endif
16366 }
16367 return pyobj;
16368 }
16369
16370
16371 static int _wrap_ART_INFORMATION_set(PyObject *) {
16372 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16373 return 1;
16374 }
16375
16376
16377 static PyObject *_wrap_ART_INFORMATION_get(void) {
16378 PyObject *pyobj;
16379
16380 {
16381 #if wxUSE_UNICODE
16382 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16383 #else
16384 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16385 #endif
16386 }
16387 return pyobj;
16388 }
16389
16390
16391 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16392 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16393 return 1;
16394 }
16395
16396
16397 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16398 PyObject *pyobj;
16399
16400 {
16401 #if wxUSE_UNICODE
16402 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16403 #else
16404 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16405 #endif
16406 }
16407 return pyobj;
16408 }
16409
16410
16411 static int _wrap_ART_COPY_set(PyObject *) {
16412 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16413 return 1;
16414 }
16415
16416
16417 static PyObject *_wrap_ART_COPY_get(void) {
16418 PyObject *pyobj;
16419
16420 {
16421 #if wxUSE_UNICODE
16422 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16423 #else
16424 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16425 #endif
16426 }
16427 return pyobj;
16428 }
16429
16430
16431 static int _wrap_ART_CUT_set(PyObject *) {
16432 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16433 return 1;
16434 }
16435
16436
16437 static PyObject *_wrap_ART_CUT_get(void) {
16438 PyObject *pyobj;
16439
16440 {
16441 #if wxUSE_UNICODE
16442 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16443 #else
16444 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16445 #endif
16446 }
16447 return pyobj;
16448 }
16449
16450
16451 static int _wrap_ART_PASTE_set(PyObject *) {
16452 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16453 return 1;
16454 }
16455
16456
16457 static PyObject *_wrap_ART_PASTE_get(void) {
16458 PyObject *pyobj;
16459
16460 {
16461 #if wxUSE_UNICODE
16462 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16463 #else
16464 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16465 #endif
16466 }
16467 return pyobj;
16468 }
16469
16470
16471 static int _wrap_ART_DELETE_set(PyObject *) {
16472 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16473 return 1;
16474 }
16475
16476
16477 static PyObject *_wrap_ART_DELETE_get(void) {
16478 PyObject *pyobj;
16479
16480 {
16481 #if wxUSE_UNICODE
16482 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16483 #else
16484 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16485 #endif
16486 }
16487 return pyobj;
16488 }
16489
16490
16491 static int _wrap_ART_UNDO_set(PyObject *) {
16492 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16493 return 1;
16494 }
16495
16496
16497 static PyObject *_wrap_ART_UNDO_get(void) {
16498 PyObject *pyobj;
16499
16500 {
16501 #if wxUSE_UNICODE
16502 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16503 #else
16504 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16505 #endif
16506 }
16507 return pyobj;
16508 }
16509
16510
16511 static int _wrap_ART_REDO_set(PyObject *) {
16512 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16513 return 1;
16514 }
16515
16516
16517 static PyObject *_wrap_ART_REDO_get(void) {
16518 PyObject *pyobj;
16519
16520 {
16521 #if wxUSE_UNICODE
16522 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16523 #else
16524 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16525 #endif
16526 }
16527 return pyobj;
16528 }
16529
16530
16531 static int _wrap_ART_QUIT_set(PyObject *) {
16532 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16533 return 1;
16534 }
16535
16536
16537 static PyObject *_wrap_ART_QUIT_get(void) {
16538 PyObject *pyobj;
16539
16540 {
16541 #if wxUSE_UNICODE
16542 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16543 #else
16544 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16545 #endif
16546 }
16547 return pyobj;
16548 }
16549
16550
16551 static int _wrap_ART_FIND_set(PyObject *) {
16552 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16553 return 1;
16554 }
16555
16556
16557 static PyObject *_wrap_ART_FIND_get(void) {
16558 PyObject *pyobj;
16559
16560 {
16561 #if wxUSE_UNICODE
16562 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16563 #else
16564 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16565 #endif
16566 }
16567 return pyobj;
16568 }
16569
16570
16571 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16572 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16573 return 1;
16574 }
16575
16576
16577 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16578 PyObject *pyobj;
16579
16580 {
16581 #if wxUSE_UNICODE
16582 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16583 #else
16584 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16585 #endif
16586 }
16587 return pyobj;
16588 }
16589
16590
16591 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj;
16593 wxPyArtProvider *result;
16594 char *kwnames[] = {
16595 NULL
16596 };
16597
16598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16599 {
16600 if (!wxPyCheckForApp()) SWIG_fail;
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 result = (wxPyArtProvider *)new wxPyArtProvider();
16603
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16608 return resultobj;
16609 fail:
16610 return NULL;
16611 }
16612
16613
16614 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16615 PyObject *resultobj;
16616 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16617 PyObject *arg2 = (PyObject *) 0 ;
16618 PyObject *arg3 = (PyObject *) 0 ;
16619 PyObject * obj0 = 0 ;
16620 PyObject * obj1 = 0 ;
16621 PyObject * obj2 = 0 ;
16622 char *kwnames[] = {
16623 (char *) "self",(char *) "self",(char *) "_class", NULL
16624 };
16625
16626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16628 if (SWIG_arg_fail(1)) SWIG_fail;
16629 arg2 = obj1;
16630 arg3 = obj2;
16631 {
16632 PyThreadState* __tstate = wxPyBeginAllowThreads();
16633 (arg1)->_setCallbackInfo(arg2,arg3);
16634
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 Py_INCREF(Py_None); resultobj = Py_None;
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj;
16647 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16648 PyObject * obj0 = 0 ;
16649 char *kwnames[] = {
16650 (char *) "provider", NULL
16651 };
16652
16653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16655 if (SWIG_arg_fail(1)) SWIG_fail;
16656 {
16657 PyThreadState* __tstate = wxPyBeginAllowThreads();
16658 wxPyArtProvider::PushProvider(arg1);
16659
16660 wxPyEndAllowThreads(__tstate);
16661 if (PyErr_Occurred()) SWIG_fail;
16662 }
16663 Py_INCREF(Py_None); resultobj = Py_None;
16664 return resultobj;
16665 fail:
16666 return NULL;
16667 }
16668
16669
16670 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16671 PyObject *resultobj;
16672 bool result;
16673 char *kwnames[] = {
16674 NULL
16675 };
16676
16677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16678 {
16679 PyThreadState* __tstate = wxPyBeginAllowThreads();
16680 result = (bool)wxPyArtProvider::PopProvider();
16681
16682 wxPyEndAllowThreads(__tstate);
16683 if (PyErr_Occurred()) SWIG_fail;
16684 }
16685 {
16686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16687 }
16688 return resultobj;
16689 fail:
16690 return NULL;
16691 }
16692
16693
16694 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16695 PyObject *resultobj;
16696 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16697 bool result;
16698 PyObject * obj0 = 0 ;
16699 char *kwnames[] = {
16700 (char *) "provider", NULL
16701 };
16702
16703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16705 if (SWIG_arg_fail(1)) SWIG_fail;
16706 {
16707 PyThreadState* __tstate = wxPyBeginAllowThreads();
16708 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16709
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 {
16714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16715 }
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj;
16724 wxString *arg1 = 0 ;
16725 wxString const &arg2_defvalue = wxPyART_OTHER ;
16726 wxString *arg2 = (wxString *) &arg2_defvalue ;
16727 wxSize const &arg3_defvalue = wxDefaultSize ;
16728 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16729 wxBitmap result;
16730 bool temp1 = false ;
16731 bool temp2 = false ;
16732 wxSize temp3 ;
16733 PyObject * obj0 = 0 ;
16734 PyObject * obj1 = 0 ;
16735 PyObject * obj2 = 0 ;
16736 char *kwnames[] = {
16737 (char *) "id",(char *) "client",(char *) "size", NULL
16738 };
16739
16740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16741 {
16742 arg1 = wxString_in_helper(obj0);
16743 if (arg1 == NULL) SWIG_fail;
16744 temp1 = true;
16745 }
16746 if (obj1) {
16747 {
16748 arg2 = wxString_in_helper(obj1);
16749 if (arg2 == NULL) SWIG_fail;
16750 temp2 = true;
16751 }
16752 }
16753 if (obj2) {
16754 {
16755 arg3 = &temp3;
16756 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16757 }
16758 }
16759 {
16760 if (!wxPyCheckForApp()) SWIG_fail;
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16763
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 {
16768 wxBitmap * resultptr;
16769 resultptr = new wxBitmap((wxBitmap &)(result));
16770 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16771 }
16772 {
16773 if (temp1)
16774 delete arg1;
16775 }
16776 {
16777 if (temp2)
16778 delete arg2;
16779 }
16780 return resultobj;
16781 fail:
16782 {
16783 if (temp1)
16784 delete arg1;
16785 }
16786 {
16787 if (temp2)
16788 delete arg2;
16789 }
16790 return NULL;
16791 }
16792
16793
16794 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16795 PyObject *resultobj;
16796 wxString *arg1 = 0 ;
16797 wxString const &arg2_defvalue = wxPyART_OTHER ;
16798 wxString *arg2 = (wxString *) &arg2_defvalue ;
16799 wxSize const &arg3_defvalue = wxDefaultSize ;
16800 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16801 wxIcon result;
16802 bool temp1 = false ;
16803 bool temp2 = false ;
16804 wxSize temp3 ;
16805 PyObject * obj0 = 0 ;
16806 PyObject * obj1 = 0 ;
16807 PyObject * obj2 = 0 ;
16808 char *kwnames[] = {
16809 (char *) "id",(char *) "client",(char *) "size", NULL
16810 };
16811
16812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16813 {
16814 arg1 = wxString_in_helper(obj0);
16815 if (arg1 == NULL) SWIG_fail;
16816 temp1 = true;
16817 }
16818 if (obj1) {
16819 {
16820 arg2 = wxString_in_helper(obj1);
16821 if (arg2 == NULL) SWIG_fail;
16822 temp2 = true;
16823 }
16824 }
16825 if (obj2) {
16826 {
16827 arg3 = &temp3;
16828 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16829 }
16830 }
16831 {
16832 if (!wxPyCheckForApp()) SWIG_fail;
16833 PyThreadState* __tstate = wxPyBeginAllowThreads();
16834 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16835
16836 wxPyEndAllowThreads(__tstate);
16837 if (PyErr_Occurred()) SWIG_fail;
16838 }
16839 {
16840 wxIcon * resultptr;
16841 resultptr = new wxIcon((wxIcon &)(result));
16842 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16843 }
16844 {
16845 if (temp1)
16846 delete arg1;
16847 }
16848 {
16849 if (temp2)
16850 delete arg2;
16851 }
16852 return resultobj;
16853 fail:
16854 {
16855 if (temp1)
16856 delete arg1;
16857 }
16858 {
16859 if (temp2)
16860 delete arg2;
16861 }
16862 return NULL;
16863 }
16864
16865
16866 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj;
16868 wxString *arg1 = 0 ;
16869 bool arg2 = (bool) false ;
16870 wxSize result;
16871 bool temp1 = false ;
16872 PyObject * obj0 = 0 ;
16873 PyObject * obj1 = 0 ;
16874 char *kwnames[] = {
16875 (char *) "client",(char *) "platform_dependent", NULL
16876 };
16877
16878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16879 {
16880 arg1 = wxString_in_helper(obj0);
16881 if (arg1 == NULL) SWIG_fail;
16882 temp1 = true;
16883 }
16884 if (obj1) {
16885 {
16886 arg2 = (bool)(SWIG_As_bool(obj1));
16887 if (SWIG_arg_fail(2)) SWIG_fail;
16888 }
16889 }
16890 {
16891 PyThreadState* __tstate = wxPyBeginAllowThreads();
16892 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16893
16894 wxPyEndAllowThreads(__tstate);
16895 if (PyErr_Occurred()) SWIG_fail;
16896 }
16897 {
16898 wxSize * resultptr;
16899 resultptr = new wxSize((wxSize &)(result));
16900 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16901 }
16902 {
16903 if (temp1)
16904 delete arg1;
16905 }
16906 return resultobj;
16907 fail:
16908 {
16909 if (temp1)
16910 delete arg1;
16911 }
16912 return NULL;
16913 }
16914
16915
16916 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16917 PyObject *resultobj;
16918 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16919 PyObject * obj0 = 0 ;
16920 char *kwnames[] = {
16921 (char *) "self", NULL
16922 };
16923
16924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16926 if (SWIG_arg_fail(1)) SWIG_fail;
16927 {
16928 PyThreadState* __tstate = wxPyBeginAllowThreads();
16929 wxPyArtProvider_Destroy(arg1);
16930
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 Py_INCREF(Py_None); resultobj = Py_None;
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16942 PyObject *obj;
16943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16944 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16945 Py_INCREF(obj);
16946 return Py_BuildValue((char *)"");
16947 }
16948 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16949 PyObject *resultobj;
16950 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16951 PyObject * obj0 = 0 ;
16952 char *kwnames[] = {
16953 (char *) "self", NULL
16954 };
16955
16956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16958 if (SWIG_arg_fail(1)) SWIG_fail;
16959 {
16960 PyThreadState* __tstate = wxPyBeginAllowThreads();
16961 delete arg1;
16962
16963 wxPyEndAllowThreads(__tstate);
16964 if (PyErr_Occurred()) SWIG_fail;
16965 }
16966 Py_INCREF(Py_None); resultobj = Py_None;
16967 return resultobj;
16968 fail:
16969 return NULL;
16970 }
16971
16972
16973 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16974 PyObject *resultobj;
16975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16976 wxConfigBase *result;
16977 PyObject * obj0 = 0 ;
16978 char *kwnames[] = {
16979 (char *) "config", NULL
16980 };
16981
16982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16984 if (SWIG_arg_fail(1)) SWIG_fail;
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16988
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16993 return resultobj;
16994 fail:
16995 return NULL;
16996 }
16997
16998
16999 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17000 PyObject *resultobj;
17001 bool arg1 = (bool) true ;
17002 wxConfigBase *result;
17003 PyObject * obj0 = 0 ;
17004 char *kwnames[] = {
17005 (char *) "createOnDemand", NULL
17006 };
17007
17008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17009 if (obj0) {
17010 {
17011 arg1 = (bool)(SWIG_As_bool(obj0));
17012 if (SWIG_arg_fail(1)) SWIG_fail;
17013 }
17014 }
17015 {
17016 PyThreadState* __tstate = wxPyBeginAllowThreads();
17017 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17018
17019 wxPyEndAllowThreads(__tstate);
17020 if (PyErr_Occurred()) SWIG_fail;
17021 }
17022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17023 return resultobj;
17024 fail:
17025 return NULL;
17026 }
17027
17028
17029 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17030 PyObject *resultobj;
17031 wxConfigBase *result;
17032 char *kwnames[] = {
17033 NULL
17034 };
17035
17036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17037 {
17038 PyThreadState* __tstate = wxPyBeginAllowThreads();
17039 result = (wxConfigBase *)wxConfigBase::Create();
17040
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17045 return resultobj;
17046 fail:
17047 return NULL;
17048 }
17049
17050
17051 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj;
17053 char *kwnames[] = {
17054 NULL
17055 };
17056
17057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 wxConfigBase::DontCreateOnDemand();
17061
17062 wxPyEndAllowThreads(__tstate);
17063 if (PyErr_Occurred()) SWIG_fail;
17064 }
17065 Py_INCREF(Py_None); resultobj = Py_None;
17066 return resultobj;
17067 fail:
17068 return NULL;
17069 }
17070
17071
17072 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17073 PyObject *resultobj;
17074 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17075 wxString *arg2 = 0 ;
17076 bool temp2 = false ;
17077 PyObject * obj0 = 0 ;
17078 PyObject * obj1 = 0 ;
17079 char *kwnames[] = {
17080 (char *) "self",(char *) "path", NULL
17081 };
17082
17083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17085 if (SWIG_arg_fail(1)) SWIG_fail;
17086 {
17087 arg2 = wxString_in_helper(obj1);
17088 if (arg2 == NULL) SWIG_fail;
17089 temp2 = true;
17090 }
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 (arg1)->SetPath((wxString const &)*arg2);
17094
17095 wxPyEndAllowThreads(__tstate);
17096 if (PyErr_Occurred()) SWIG_fail;
17097 }
17098 Py_INCREF(Py_None); resultobj = Py_None;
17099 {
17100 if (temp2)
17101 delete arg2;
17102 }
17103 return resultobj;
17104 fail:
17105 {
17106 if (temp2)
17107 delete arg2;
17108 }
17109 return NULL;
17110 }
17111
17112
17113 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj;
17115 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17116 wxString *result;
17117 PyObject * obj0 = 0 ;
17118 char *kwnames[] = {
17119 (char *) "self", NULL
17120 };
17121
17122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17124 if (SWIG_arg_fail(1)) SWIG_fail;
17125 {
17126 PyThreadState* __tstate = wxPyBeginAllowThreads();
17127 {
17128 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17129 result = (wxString *) &_result_ref;
17130 }
17131
17132 wxPyEndAllowThreads(__tstate);
17133 if (PyErr_Occurred()) SWIG_fail;
17134 }
17135 {
17136 #if wxUSE_UNICODE
17137 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17138 #else
17139 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17140 #endif
17141 }
17142 return resultobj;
17143 fail:
17144 return NULL;
17145 }
17146
17147
17148 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17149 PyObject *resultobj;
17150 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17151 PyObject *result;
17152 PyObject * obj0 = 0 ;
17153 char *kwnames[] = {
17154 (char *) "self", NULL
17155 };
17156
17157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17159 if (SWIG_arg_fail(1)) SWIG_fail;
17160 {
17161 PyThreadState* __tstate = wxPyBeginAllowThreads();
17162 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17163
17164 wxPyEndAllowThreads(__tstate);
17165 if (PyErr_Occurred()) SWIG_fail;
17166 }
17167 resultobj = result;
17168 return resultobj;
17169 fail:
17170 return NULL;
17171 }
17172
17173
17174 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17175 PyObject *resultobj;
17176 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17177 long arg2 ;
17178 PyObject *result;
17179 PyObject * obj0 = 0 ;
17180 PyObject * obj1 = 0 ;
17181 char *kwnames[] = {
17182 (char *) "self",(char *) "index", NULL
17183 };
17184
17185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17187 if (SWIG_arg_fail(1)) SWIG_fail;
17188 {
17189 arg2 = (long)(SWIG_As_long(obj1));
17190 if (SWIG_arg_fail(2)) SWIG_fail;
17191 }
17192 {
17193 PyThreadState* __tstate = wxPyBeginAllowThreads();
17194 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17195
17196 wxPyEndAllowThreads(__tstate);
17197 if (PyErr_Occurred()) SWIG_fail;
17198 }
17199 resultobj = result;
17200 return resultobj;
17201 fail:
17202 return NULL;
17203 }
17204
17205
17206 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17207 PyObject *resultobj;
17208 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17209 PyObject *result;
17210 PyObject * obj0 = 0 ;
17211 char *kwnames[] = {
17212 (char *) "self", NULL
17213 };
17214
17215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17217 if (SWIG_arg_fail(1)) SWIG_fail;
17218 {
17219 PyThreadState* __tstate = wxPyBeginAllowThreads();
17220 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17221
17222 wxPyEndAllowThreads(__tstate);
17223 if (PyErr_Occurred()) SWIG_fail;
17224 }
17225 resultobj = result;
17226 return resultobj;
17227 fail:
17228 return NULL;
17229 }
17230
17231
17232 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17233 PyObject *resultobj;
17234 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17235 long arg2 ;
17236 PyObject *result;
17237 PyObject * obj0 = 0 ;
17238 PyObject * obj1 = 0 ;
17239 char *kwnames[] = {
17240 (char *) "self",(char *) "index", NULL
17241 };
17242
17243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17245 if (SWIG_arg_fail(1)) SWIG_fail;
17246 {
17247 arg2 = (long)(SWIG_As_long(obj1));
17248 if (SWIG_arg_fail(2)) SWIG_fail;
17249 }
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17253
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 resultobj = result;
17258 return resultobj;
17259 fail:
17260 return NULL;
17261 }
17262
17263
17264 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17265 PyObject *resultobj;
17266 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17267 bool arg2 = (bool) false ;
17268 size_t result;
17269 PyObject * obj0 = 0 ;
17270 PyObject * obj1 = 0 ;
17271 char *kwnames[] = {
17272 (char *) "self",(char *) "recursive", NULL
17273 };
17274
17275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17277 if (SWIG_arg_fail(1)) SWIG_fail;
17278 if (obj1) {
17279 {
17280 arg2 = (bool)(SWIG_As_bool(obj1));
17281 if (SWIG_arg_fail(2)) SWIG_fail;
17282 }
17283 }
17284 {
17285 PyThreadState* __tstate = wxPyBeginAllowThreads();
17286 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17287
17288 wxPyEndAllowThreads(__tstate);
17289 if (PyErr_Occurred()) SWIG_fail;
17290 }
17291 {
17292 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17293 }
17294 return resultobj;
17295 fail:
17296 return NULL;
17297 }
17298
17299
17300 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17301 PyObject *resultobj;
17302 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17303 bool arg2 = (bool) false ;
17304 size_t result;
17305 PyObject * obj0 = 0 ;
17306 PyObject * obj1 = 0 ;
17307 char *kwnames[] = {
17308 (char *) "self",(char *) "recursive", NULL
17309 };
17310
17311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17313 if (SWIG_arg_fail(1)) SWIG_fail;
17314 if (obj1) {
17315 {
17316 arg2 = (bool)(SWIG_As_bool(obj1));
17317 if (SWIG_arg_fail(2)) SWIG_fail;
17318 }
17319 }
17320 {
17321 PyThreadState* __tstate = wxPyBeginAllowThreads();
17322 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17323
17324 wxPyEndAllowThreads(__tstate);
17325 if (PyErr_Occurred()) SWIG_fail;
17326 }
17327 {
17328 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17329 }
17330 return resultobj;
17331 fail:
17332 return NULL;
17333 }
17334
17335
17336 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17337 PyObject *resultobj;
17338 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17339 wxString *arg2 = 0 ;
17340 bool result;
17341 bool temp2 = false ;
17342 PyObject * obj0 = 0 ;
17343 PyObject * obj1 = 0 ;
17344 char *kwnames[] = {
17345 (char *) "self",(char *) "name", NULL
17346 };
17347
17348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17350 if (SWIG_arg_fail(1)) SWIG_fail;
17351 {
17352 arg2 = wxString_in_helper(obj1);
17353 if (arg2 == NULL) SWIG_fail;
17354 temp2 = true;
17355 }
17356 {
17357 PyThreadState* __tstate = wxPyBeginAllowThreads();
17358 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17359
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 {
17364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17365 }
17366 {
17367 if (temp2)
17368 delete arg2;
17369 }
17370 return resultobj;
17371 fail:
17372 {
17373 if (temp2)
17374 delete arg2;
17375 }
17376 return NULL;
17377 }
17378
17379
17380 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj;
17382 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17383 wxString *arg2 = 0 ;
17384 bool result;
17385 bool temp2 = false ;
17386 PyObject * obj0 = 0 ;
17387 PyObject * obj1 = 0 ;
17388 char *kwnames[] = {
17389 (char *) "self",(char *) "name", NULL
17390 };
17391
17392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17394 if (SWIG_arg_fail(1)) SWIG_fail;
17395 {
17396 arg2 = wxString_in_helper(obj1);
17397 if (arg2 == NULL) SWIG_fail;
17398 temp2 = true;
17399 }
17400 {
17401 PyThreadState* __tstate = wxPyBeginAllowThreads();
17402 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17403
17404 wxPyEndAllowThreads(__tstate);
17405 if (PyErr_Occurred()) SWIG_fail;
17406 }
17407 {
17408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17409 }
17410 {
17411 if (temp2)
17412 delete arg2;
17413 }
17414 return resultobj;
17415 fail:
17416 {
17417 if (temp2)
17418 delete arg2;
17419 }
17420 return NULL;
17421 }
17422
17423
17424 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17425 PyObject *resultobj;
17426 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17427 wxString *arg2 = 0 ;
17428 bool result;
17429 bool temp2 = false ;
17430 PyObject * obj0 = 0 ;
17431 PyObject * obj1 = 0 ;
17432 char *kwnames[] = {
17433 (char *) "self",(char *) "name", NULL
17434 };
17435
17436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17438 if (SWIG_arg_fail(1)) SWIG_fail;
17439 {
17440 arg2 = wxString_in_helper(obj1);
17441 if (arg2 == NULL) SWIG_fail;
17442 temp2 = true;
17443 }
17444 {
17445 PyThreadState* __tstate = wxPyBeginAllowThreads();
17446 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17447
17448 wxPyEndAllowThreads(__tstate);
17449 if (PyErr_Occurred()) SWIG_fail;
17450 }
17451 {
17452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17453 }
17454 {
17455 if (temp2)
17456 delete arg2;
17457 }
17458 return resultobj;
17459 fail:
17460 {
17461 if (temp2)
17462 delete arg2;
17463 }
17464 return NULL;
17465 }
17466
17467
17468 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj;
17470 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17471 wxString *arg2 = 0 ;
17472 wxConfigBase::EntryType result;
17473 bool temp2 = false ;
17474 PyObject * obj0 = 0 ;
17475 PyObject * obj1 = 0 ;
17476 char *kwnames[] = {
17477 (char *) "self",(char *) "name", NULL
17478 };
17479
17480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17482 if (SWIG_arg_fail(1)) SWIG_fail;
17483 {
17484 arg2 = wxString_in_helper(obj1);
17485 if (arg2 == NULL) SWIG_fail;
17486 temp2 = true;
17487 }
17488 {
17489 PyThreadState* __tstate = wxPyBeginAllowThreads();
17490 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17491
17492 wxPyEndAllowThreads(__tstate);
17493 if (PyErr_Occurred()) SWIG_fail;
17494 }
17495 resultobj = SWIG_From_int((result));
17496 {
17497 if (temp2)
17498 delete arg2;
17499 }
17500 return resultobj;
17501 fail:
17502 {
17503 if (temp2)
17504 delete arg2;
17505 }
17506 return NULL;
17507 }
17508
17509
17510 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17511 PyObject *resultobj;
17512 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17513 wxString *arg2 = 0 ;
17514 wxString const &arg3_defvalue = wxPyEmptyString ;
17515 wxString *arg3 = (wxString *) &arg3_defvalue ;
17516 wxString result;
17517 bool temp2 = false ;
17518 bool temp3 = false ;
17519 PyObject * obj0 = 0 ;
17520 PyObject * obj1 = 0 ;
17521 PyObject * obj2 = 0 ;
17522 char *kwnames[] = {
17523 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17524 };
17525
17526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17528 if (SWIG_arg_fail(1)) SWIG_fail;
17529 {
17530 arg2 = wxString_in_helper(obj1);
17531 if (arg2 == NULL) SWIG_fail;
17532 temp2 = true;
17533 }
17534 if (obj2) {
17535 {
17536 arg3 = wxString_in_helper(obj2);
17537 if (arg3 == NULL) SWIG_fail;
17538 temp3 = true;
17539 }
17540 }
17541 {
17542 PyThreadState* __tstate = wxPyBeginAllowThreads();
17543 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17544
17545 wxPyEndAllowThreads(__tstate);
17546 if (PyErr_Occurred()) SWIG_fail;
17547 }
17548 {
17549 #if wxUSE_UNICODE
17550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17551 #else
17552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17553 #endif
17554 }
17555 {
17556 if (temp2)
17557 delete arg2;
17558 }
17559 {
17560 if (temp3)
17561 delete arg3;
17562 }
17563 return resultobj;
17564 fail:
17565 {
17566 if (temp2)
17567 delete arg2;
17568 }
17569 {
17570 if (temp3)
17571 delete arg3;
17572 }
17573 return NULL;
17574 }
17575
17576
17577 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17578 PyObject *resultobj;
17579 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17580 wxString *arg2 = 0 ;
17581 long arg3 = (long) 0 ;
17582 long result;
17583 bool temp2 = false ;
17584 PyObject * obj0 = 0 ;
17585 PyObject * obj1 = 0 ;
17586 PyObject * obj2 = 0 ;
17587 char *kwnames[] = {
17588 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17589 };
17590
17591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17593 if (SWIG_arg_fail(1)) SWIG_fail;
17594 {
17595 arg2 = wxString_in_helper(obj1);
17596 if (arg2 == NULL) SWIG_fail;
17597 temp2 = true;
17598 }
17599 if (obj2) {
17600 {
17601 arg3 = (long)(SWIG_As_long(obj2));
17602 if (SWIG_arg_fail(3)) SWIG_fail;
17603 }
17604 }
17605 {
17606 PyThreadState* __tstate = wxPyBeginAllowThreads();
17607 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17608
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 {
17613 resultobj = SWIG_From_long((long)(result));
17614 }
17615 {
17616 if (temp2)
17617 delete arg2;
17618 }
17619 return resultobj;
17620 fail:
17621 {
17622 if (temp2)
17623 delete arg2;
17624 }
17625 return NULL;
17626 }
17627
17628
17629 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17630 PyObject *resultobj;
17631 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17632 wxString *arg2 = 0 ;
17633 double arg3 = (double) 0.0 ;
17634 double result;
17635 bool temp2 = false ;
17636 PyObject * obj0 = 0 ;
17637 PyObject * obj1 = 0 ;
17638 PyObject * obj2 = 0 ;
17639 char *kwnames[] = {
17640 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17641 };
17642
17643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17645 if (SWIG_arg_fail(1)) SWIG_fail;
17646 {
17647 arg2 = wxString_in_helper(obj1);
17648 if (arg2 == NULL) SWIG_fail;
17649 temp2 = true;
17650 }
17651 if (obj2) {
17652 {
17653 arg3 = (double)(SWIG_As_double(obj2));
17654 if (SWIG_arg_fail(3)) SWIG_fail;
17655 }
17656 }
17657 {
17658 PyThreadState* __tstate = wxPyBeginAllowThreads();
17659 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17660
17661 wxPyEndAllowThreads(__tstate);
17662 if (PyErr_Occurred()) SWIG_fail;
17663 }
17664 {
17665 resultobj = SWIG_From_double((double)(result));
17666 }
17667 {
17668 if (temp2)
17669 delete arg2;
17670 }
17671 return resultobj;
17672 fail:
17673 {
17674 if (temp2)
17675 delete arg2;
17676 }
17677 return NULL;
17678 }
17679
17680
17681 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17682 PyObject *resultobj;
17683 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17684 wxString *arg2 = 0 ;
17685 bool arg3 = (bool) false ;
17686 bool result;
17687 bool temp2 = false ;
17688 PyObject * obj0 = 0 ;
17689 PyObject * obj1 = 0 ;
17690 PyObject * obj2 = 0 ;
17691 char *kwnames[] = {
17692 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17693 };
17694
17695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17697 if (SWIG_arg_fail(1)) SWIG_fail;
17698 {
17699 arg2 = wxString_in_helper(obj1);
17700 if (arg2 == NULL) SWIG_fail;
17701 temp2 = true;
17702 }
17703 if (obj2) {
17704 {
17705 arg3 = (bool)(SWIG_As_bool(obj2));
17706 if (SWIG_arg_fail(3)) SWIG_fail;
17707 }
17708 }
17709 {
17710 PyThreadState* __tstate = wxPyBeginAllowThreads();
17711 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17712
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 {
17717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17718 }
17719 {
17720 if (temp2)
17721 delete arg2;
17722 }
17723 return resultobj;
17724 fail:
17725 {
17726 if (temp2)
17727 delete arg2;
17728 }
17729 return NULL;
17730 }
17731
17732
17733 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17734 PyObject *resultobj;
17735 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17736 wxString *arg2 = 0 ;
17737 wxString *arg3 = 0 ;
17738 bool result;
17739 bool temp2 = false ;
17740 bool temp3 = false ;
17741 PyObject * obj0 = 0 ;
17742 PyObject * obj1 = 0 ;
17743 PyObject * obj2 = 0 ;
17744 char *kwnames[] = {
17745 (char *) "self",(char *) "key",(char *) "value", NULL
17746 };
17747
17748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17750 if (SWIG_arg_fail(1)) SWIG_fail;
17751 {
17752 arg2 = wxString_in_helper(obj1);
17753 if (arg2 == NULL) SWIG_fail;
17754 temp2 = true;
17755 }
17756 {
17757 arg3 = wxString_in_helper(obj2);
17758 if (arg3 == NULL) SWIG_fail;
17759 temp3 = true;
17760 }
17761 {
17762 PyThreadState* __tstate = wxPyBeginAllowThreads();
17763 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17764
17765 wxPyEndAllowThreads(__tstate);
17766 if (PyErr_Occurred()) SWIG_fail;
17767 }
17768 {
17769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17770 }
17771 {
17772 if (temp2)
17773 delete arg2;
17774 }
17775 {
17776 if (temp3)
17777 delete arg3;
17778 }
17779 return resultobj;
17780 fail:
17781 {
17782 if (temp2)
17783 delete arg2;
17784 }
17785 {
17786 if (temp3)
17787 delete arg3;
17788 }
17789 return NULL;
17790 }
17791
17792
17793 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj;
17795 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17796 wxString *arg2 = 0 ;
17797 long arg3 ;
17798 bool result;
17799 bool temp2 = false ;
17800 PyObject * obj0 = 0 ;
17801 PyObject * obj1 = 0 ;
17802 PyObject * obj2 = 0 ;
17803 char *kwnames[] = {
17804 (char *) "self",(char *) "key",(char *) "value", NULL
17805 };
17806
17807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17809 if (SWIG_arg_fail(1)) SWIG_fail;
17810 {
17811 arg2 = wxString_in_helper(obj1);
17812 if (arg2 == NULL) SWIG_fail;
17813 temp2 = true;
17814 }
17815 {
17816 arg3 = (long)(SWIG_As_long(obj2));
17817 if (SWIG_arg_fail(3)) SWIG_fail;
17818 }
17819 {
17820 PyThreadState* __tstate = wxPyBeginAllowThreads();
17821 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17822
17823 wxPyEndAllowThreads(__tstate);
17824 if (PyErr_Occurred()) SWIG_fail;
17825 }
17826 {
17827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17828 }
17829 {
17830 if (temp2)
17831 delete arg2;
17832 }
17833 return resultobj;
17834 fail:
17835 {
17836 if (temp2)
17837 delete arg2;
17838 }
17839 return NULL;
17840 }
17841
17842
17843 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj;
17845 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17846 wxString *arg2 = 0 ;
17847 double arg3 ;
17848 bool result;
17849 bool temp2 = false ;
17850 PyObject * obj0 = 0 ;
17851 PyObject * obj1 = 0 ;
17852 PyObject * obj2 = 0 ;
17853 char *kwnames[] = {
17854 (char *) "self",(char *) "key",(char *) "value", NULL
17855 };
17856
17857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17859 if (SWIG_arg_fail(1)) SWIG_fail;
17860 {
17861 arg2 = wxString_in_helper(obj1);
17862 if (arg2 == NULL) SWIG_fail;
17863 temp2 = true;
17864 }
17865 {
17866 arg3 = (double)(SWIG_As_double(obj2));
17867 if (SWIG_arg_fail(3)) SWIG_fail;
17868 }
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17872
17873 wxPyEndAllowThreads(__tstate);
17874 if (PyErr_Occurred()) SWIG_fail;
17875 }
17876 {
17877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17878 }
17879 {
17880 if (temp2)
17881 delete arg2;
17882 }
17883 return resultobj;
17884 fail:
17885 {
17886 if (temp2)
17887 delete arg2;
17888 }
17889 return NULL;
17890 }
17891
17892
17893 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj;
17895 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17896 wxString *arg2 = 0 ;
17897 bool arg3 ;
17898 bool result;
17899 bool temp2 = false ;
17900 PyObject * obj0 = 0 ;
17901 PyObject * obj1 = 0 ;
17902 PyObject * obj2 = 0 ;
17903 char *kwnames[] = {
17904 (char *) "self",(char *) "key",(char *) "value", NULL
17905 };
17906
17907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17909 if (SWIG_arg_fail(1)) SWIG_fail;
17910 {
17911 arg2 = wxString_in_helper(obj1);
17912 if (arg2 == NULL) SWIG_fail;
17913 temp2 = true;
17914 }
17915 {
17916 arg3 = (bool)(SWIG_As_bool(obj2));
17917 if (SWIG_arg_fail(3)) SWIG_fail;
17918 }
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17922
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 {
17927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17928 }
17929 {
17930 if (temp2)
17931 delete arg2;
17932 }
17933 return resultobj;
17934 fail:
17935 {
17936 if (temp2)
17937 delete arg2;
17938 }
17939 return NULL;
17940 }
17941
17942
17943 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17944 PyObject *resultobj;
17945 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17946 bool arg2 = (bool) false ;
17947 bool result;
17948 PyObject * obj0 = 0 ;
17949 PyObject * obj1 = 0 ;
17950 char *kwnames[] = {
17951 (char *) "self",(char *) "currentOnly", NULL
17952 };
17953
17954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17956 if (SWIG_arg_fail(1)) SWIG_fail;
17957 if (obj1) {
17958 {
17959 arg2 = (bool)(SWIG_As_bool(obj1));
17960 if (SWIG_arg_fail(2)) SWIG_fail;
17961 }
17962 }
17963 {
17964 PyThreadState* __tstate = wxPyBeginAllowThreads();
17965 result = (bool)(arg1)->Flush(arg2);
17966
17967 wxPyEndAllowThreads(__tstate);
17968 if (PyErr_Occurred()) SWIG_fail;
17969 }
17970 {
17971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17972 }
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17980 PyObject *resultobj;
17981 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17982 wxString *arg2 = 0 ;
17983 wxString *arg3 = 0 ;
17984 bool result;
17985 bool temp2 = false ;
17986 bool temp3 = false ;
17987 PyObject * obj0 = 0 ;
17988 PyObject * obj1 = 0 ;
17989 PyObject * obj2 = 0 ;
17990 char *kwnames[] = {
17991 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17992 };
17993
17994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17996 if (SWIG_arg_fail(1)) SWIG_fail;
17997 {
17998 arg2 = wxString_in_helper(obj1);
17999 if (arg2 == NULL) SWIG_fail;
18000 temp2 = true;
18001 }
18002 {
18003 arg3 = wxString_in_helper(obj2);
18004 if (arg3 == NULL) SWIG_fail;
18005 temp3 = true;
18006 }
18007 {
18008 PyThreadState* __tstate = wxPyBeginAllowThreads();
18009 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18010
18011 wxPyEndAllowThreads(__tstate);
18012 if (PyErr_Occurred()) SWIG_fail;
18013 }
18014 {
18015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18016 }
18017 {
18018 if (temp2)
18019 delete arg2;
18020 }
18021 {
18022 if (temp3)
18023 delete arg3;
18024 }
18025 return resultobj;
18026 fail:
18027 {
18028 if (temp2)
18029 delete arg2;
18030 }
18031 {
18032 if (temp3)
18033 delete arg3;
18034 }
18035 return NULL;
18036 }
18037
18038
18039 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18040 PyObject *resultobj;
18041 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18042 wxString *arg2 = 0 ;
18043 wxString *arg3 = 0 ;
18044 bool result;
18045 bool temp2 = false ;
18046 bool temp3 = false ;
18047 PyObject * obj0 = 0 ;
18048 PyObject * obj1 = 0 ;
18049 PyObject * obj2 = 0 ;
18050 char *kwnames[] = {
18051 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18052 };
18053
18054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18056 if (SWIG_arg_fail(1)) SWIG_fail;
18057 {
18058 arg2 = wxString_in_helper(obj1);
18059 if (arg2 == NULL) SWIG_fail;
18060 temp2 = true;
18061 }
18062 {
18063 arg3 = wxString_in_helper(obj2);
18064 if (arg3 == NULL) SWIG_fail;
18065 temp3 = true;
18066 }
18067 {
18068 PyThreadState* __tstate = wxPyBeginAllowThreads();
18069 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18070
18071 wxPyEndAllowThreads(__tstate);
18072 if (PyErr_Occurred()) SWIG_fail;
18073 }
18074 {
18075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18076 }
18077 {
18078 if (temp2)
18079 delete arg2;
18080 }
18081 {
18082 if (temp3)
18083 delete arg3;
18084 }
18085 return resultobj;
18086 fail:
18087 {
18088 if (temp2)
18089 delete arg2;
18090 }
18091 {
18092 if (temp3)
18093 delete arg3;
18094 }
18095 return NULL;
18096 }
18097
18098
18099 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18100 PyObject *resultobj;
18101 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18102 wxString *arg2 = 0 ;
18103 bool arg3 = (bool) true ;
18104 bool result;
18105 bool temp2 = false ;
18106 PyObject * obj0 = 0 ;
18107 PyObject * obj1 = 0 ;
18108 PyObject * obj2 = 0 ;
18109 char *kwnames[] = {
18110 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18111 };
18112
18113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18115 if (SWIG_arg_fail(1)) SWIG_fail;
18116 {
18117 arg2 = wxString_in_helper(obj1);
18118 if (arg2 == NULL) SWIG_fail;
18119 temp2 = true;
18120 }
18121 if (obj2) {
18122 {
18123 arg3 = (bool)(SWIG_As_bool(obj2));
18124 if (SWIG_arg_fail(3)) SWIG_fail;
18125 }
18126 }
18127 {
18128 PyThreadState* __tstate = wxPyBeginAllowThreads();
18129 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18130
18131 wxPyEndAllowThreads(__tstate);
18132 if (PyErr_Occurred()) SWIG_fail;
18133 }
18134 {
18135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18136 }
18137 {
18138 if (temp2)
18139 delete arg2;
18140 }
18141 return resultobj;
18142 fail:
18143 {
18144 if (temp2)
18145 delete arg2;
18146 }
18147 return NULL;
18148 }
18149
18150
18151 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18152 PyObject *resultobj;
18153 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18154 wxString *arg2 = 0 ;
18155 bool result;
18156 bool temp2 = false ;
18157 PyObject * obj0 = 0 ;
18158 PyObject * obj1 = 0 ;
18159 char *kwnames[] = {
18160 (char *) "self",(char *) "key", NULL
18161 };
18162
18163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18165 if (SWIG_arg_fail(1)) SWIG_fail;
18166 {
18167 arg2 = wxString_in_helper(obj1);
18168 if (arg2 == NULL) SWIG_fail;
18169 temp2 = true;
18170 }
18171 {
18172 PyThreadState* __tstate = wxPyBeginAllowThreads();
18173 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18174
18175 wxPyEndAllowThreads(__tstate);
18176 if (PyErr_Occurred()) SWIG_fail;
18177 }
18178 {
18179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18180 }
18181 {
18182 if (temp2)
18183 delete arg2;
18184 }
18185 return resultobj;
18186 fail:
18187 {
18188 if (temp2)
18189 delete arg2;
18190 }
18191 return NULL;
18192 }
18193
18194
18195 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18196 PyObject *resultobj;
18197 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18198 bool result;
18199 PyObject * obj0 = 0 ;
18200 char *kwnames[] = {
18201 (char *) "self", NULL
18202 };
18203
18204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18206 if (SWIG_arg_fail(1)) SWIG_fail;
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 result = (bool)(arg1)->DeleteAll();
18210
18211 wxPyEndAllowThreads(__tstate);
18212 if (PyErr_Occurred()) SWIG_fail;
18213 }
18214 {
18215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18216 }
18217 return resultobj;
18218 fail:
18219 return NULL;
18220 }
18221
18222
18223 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18224 PyObject *resultobj;
18225 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18226 bool arg2 = (bool) true ;
18227 PyObject * obj0 = 0 ;
18228 PyObject * obj1 = 0 ;
18229 char *kwnames[] = {
18230 (char *) "self",(char *) "doIt", NULL
18231 };
18232
18233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18235 if (SWIG_arg_fail(1)) SWIG_fail;
18236 if (obj1) {
18237 {
18238 arg2 = (bool)(SWIG_As_bool(obj1));
18239 if (SWIG_arg_fail(2)) SWIG_fail;
18240 }
18241 }
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 (arg1)->SetExpandEnvVars(arg2);
18245
18246 wxPyEndAllowThreads(__tstate);
18247 if (PyErr_Occurred()) SWIG_fail;
18248 }
18249 Py_INCREF(Py_None); resultobj = Py_None;
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18257 PyObject *resultobj;
18258 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18259 bool result;
18260 PyObject * obj0 = 0 ;
18261 char *kwnames[] = {
18262 (char *) "self", NULL
18263 };
18264
18265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18267 if (SWIG_arg_fail(1)) SWIG_fail;
18268 {
18269 PyThreadState* __tstate = wxPyBeginAllowThreads();
18270 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18271
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 {
18276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18277 }
18278 return resultobj;
18279 fail:
18280 return NULL;
18281 }
18282
18283
18284 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18285 PyObject *resultobj;
18286 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18287 bool arg2 = (bool) true ;
18288 PyObject * obj0 = 0 ;
18289 PyObject * obj1 = 0 ;
18290 char *kwnames[] = {
18291 (char *) "self",(char *) "doIt", NULL
18292 };
18293
18294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18296 if (SWIG_arg_fail(1)) SWIG_fail;
18297 if (obj1) {
18298 {
18299 arg2 = (bool)(SWIG_As_bool(obj1));
18300 if (SWIG_arg_fail(2)) SWIG_fail;
18301 }
18302 }
18303 {
18304 PyThreadState* __tstate = wxPyBeginAllowThreads();
18305 (arg1)->SetRecordDefaults(arg2);
18306
18307 wxPyEndAllowThreads(__tstate);
18308 if (PyErr_Occurred()) SWIG_fail;
18309 }
18310 Py_INCREF(Py_None); resultobj = Py_None;
18311 return resultobj;
18312 fail:
18313 return NULL;
18314 }
18315
18316
18317 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18318 PyObject *resultobj;
18319 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18320 bool result;
18321 PyObject * obj0 = 0 ;
18322 char *kwnames[] = {
18323 (char *) "self", NULL
18324 };
18325
18326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18328 if (SWIG_arg_fail(1)) SWIG_fail;
18329 {
18330 PyThreadState* __tstate = wxPyBeginAllowThreads();
18331 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18332
18333 wxPyEndAllowThreads(__tstate);
18334 if (PyErr_Occurred()) SWIG_fail;
18335 }
18336 {
18337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18338 }
18339 return resultobj;
18340 fail:
18341 return NULL;
18342 }
18343
18344
18345 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18346 PyObject *resultobj;
18347 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18348 wxString *arg2 = 0 ;
18349 wxString result;
18350 bool temp2 = false ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 char *kwnames[] = {
18354 (char *) "self",(char *) "str", NULL
18355 };
18356
18357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18359 if (SWIG_arg_fail(1)) SWIG_fail;
18360 {
18361 arg2 = wxString_in_helper(obj1);
18362 if (arg2 == NULL) SWIG_fail;
18363 temp2 = true;
18364 }
18365 {
18366 PyThreadState* __tstate = wxPyBeginAllowThreads();
18367 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18368
18369 wxPyEndAllowThreads(__tstate);
18370 if (PyErr_Occurred()) SWIG_fail;
18371 }
18372 {
18373 #if wxUSE_UNICODE
18374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18375 #else
18376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18377 #endif
18378 }
18379 {
18380 if (temp2)
18381 delete arg2;
18382 }
18383 return resultobj;
18384 fail:
18385 {
18386 if (temp2)
18387 delete arg2;
18388 }
18389 return NULL;
18390 }
18391
18392
18393 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18394 PyObject *resultobj;
18395 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18396 wxString result;
18397 PyObject * obj0 = 0 ;
18398 char *kwnames[] = {
18399 (char *) "self", NULL
18400 };
18401
18402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18404 if (SWIG_arg_fail(1)) SWIG_fail;
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 result = ((wxConfigBase const *)arg1)->GetAppName();
18408
18409 wxPyEndAllowThreads(__tstate);
18410 if (PyErr_Occurred()) SWIG_fail;
18411 }
18412 {
18413 #if wxUSE_UNICODE
18414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18415 #else
18416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18417 #endif
18418 }
18419 return resultobj;
18420 fail:
18421 return NULL;
18422 }
18423
18424
18425 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18426 PyObject *resultobj;
18427 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18428 wxString result;
18429 PyObject * obj0 = 0 ;
18430 char *kwnames[] = {
18431 (char *) "self", NULL
18432 };
18433
18434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18436 if (SWIG_arg_fail(1)) SWIG_fail;
18437 {
18438 PyThreadState* __tstate = wxPyBeginAllowThreads();
18439 result = ((wxConfigBase const *)arg1)->GetVendorName();
18440
18441 wxPyEndAllowThreads(__tstate);
18442 if (PyErr_Occurred()) SWIG_fail;
18443 }
18444 {
18445 #if wxUSE_UNICODE
18446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18447 #else
18448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18449 #endif
18450 }
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj;
18459 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18460 wxString *arg2 = 0 ;
18461 bool temp2 = false ;
18462 PyObject * obj0 = 0 ;
18463 PyObject * obj1 = 0 ;
18464 char *kwnames[] = {
18465 (char *) "self",(char *) "appName", NULL
18466 };
18467
18468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18470 if (SWIG_arg_fail(1)) SWIG_fail;
18471 {
18472 arg2 = wxString_in_helper(obj1);
18473 if (arg2 == NULL) SWIG_fail;
18474 temp2 = true;
18475 }
18476 {
18477 PyThreadState* __tstate = wxPyBeginAllowThreads();
18478 (arg1)->SetAppName((wxString const &)*arg2);
18479
18480 wxPyEndAllowThreads(__tstate);
18481 if (PyErr_Occurred()) SWIG_fail;
18482 }
18483 Py_INCREF(Py_None); resultobj = Py_None;
18484 {
18485 if (temp2)
18486 delete arg2;
18487 }
18488 return resultobj;
18489 fail:
18490 {
18491 if (temp2)
18492 delete arg2;
18493 }
18494 return NULL;
18495 }
18496
18497
18498 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18499 PyObject *resultobj;
18500 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18501 wxString *arg2 = 0 ;
18502 bool temp2 = false ;
18503 PyObject * obj0 = 0 ;
18504 PyObject * obj1 = 0 ;
18505 char *kwnames[] = {
18506 (char *) "self",(char *) "vendorName", NULL
18507 };
18508
18509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18511 if (SWIG_arg_fail(1)) SWIG_fail;
18512 {
18513 arg2 = wxString_in_helper(obj1);
18514 if (arg2 == NULL) SWIG_fail;
18515 temp2 = true;
18516 }
18517 {
18518 PyThreadState* __tstate = wxPyBeginAllowThreads();
18519 (arg1)->SetVendorName((wxString const &)*arg2);
18520
18521 wxPyEndAllowThreads(__tstate);
18522 if (PyErr_Occurred()) SWIG_fail;
18523 }
18524 Py_INCREF(Py_None); resultobj = Py_None;
18525 {
18526 if (temp2)
18527 delete arg2;
18528 }
18529 return resultobj;
18530 fail:
18531 {
18532 if (temp2)
18533 delete arg2;
18534 }
18535 return NULL;
18536 }
18537
18538
18539 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18540 PyObject *resultobj;
18541 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18542 long arg2 ;
18543 PyObject * obj0 = 0 ;
18544 PyObject * obj1 = 0 ;
18545 char *kwnames[] = {
18546 (char *) "self",(char *) "style", NULL
18547 };
18548
18549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18551 if (SWIG_arg_fail(1)) SWIG_fail;
18552 {
18553 arg2 = (long)(SWIG_As_long(obj1));
18554 if (SWIG_arg_fail(2)) SWIG_fail;
18555 }
18556 {
18557 PyThreadState* __tstate = wxPyBeginAllowThreads();
18558 (arg1)->SetStyle(arg2);
18559
18560 wxPyEndAllowThreads(__tstate);
18561 if (PyErr_Occurred()) SWIG_fail;
18562 }
18563 Py_INCREF(Py_None); resultobj = Py_None;
18564 return resultobj;
18565 fail:
18566 return NULL;
18567 }
18568
18569
18570 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18571 PyObject *resultobj;
18572 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18573 long result;
18574 PyObject * obj0 = 0 ;
18575 char *kwnames[] = {
18576 (char *) "self", NULL
18577 };
18578
18579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18581 if (SWIG_arg_fail(1)) SWIG_fail;
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18585
18586 wxPyEndAllowThreads(__tstate);
18587 if (PyErr_Occurred()) SWIG_fail;
18588 }
18589 {
18590 resultobj = SWIG_From_long((long)(result));
18591 }
18592 return resultobj;
18593 fail:
18594 return NULL;
18595 }
18596
18597
18598 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18599 PyObject *obj;
18600 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18601 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18602 Py_INCREF(obj);
18603 return Py_BuildValue((char *)"");
18604 }
18605 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18606 PyObject *resultobj;
18607 wxString const &arg1_defvalue = wxPyEmptyString ;
18608 wxString *arg1 = (wxString *) &arg1_defvalue ;
18609 wxString const &arg2_defvalue = wxPyEmptyString ;
18610 wxString *arg2 = (wxString *) &arg2_defvalue ;
18611 wxString const &arg3_defvalue = wxPyEmptyString ;
18612 wxString *arg3 = (wxString *) &arg3_defvalue ;
18613 wxString const &arg4_defvalue = wxPyEmptyString ;
18614 wxString *arg4 = (wxString *) &arg4_defvalue ;
18615 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18616 wxConfig *result;
18617 bool temp1 = false ;
18618 bool temp2 = false ;
18619 bool temp3 = false ;
18620 bool temp4 = false ;
18621 PyObject * obj0 = 0 ;
18622 PyObject * obj1 = 0 ;
18623 PyObject * obj2 = 0 ;
18624 PyObject * obj3 = 0 ;
18625 PyObject * obj4 = 0 ;
18626 char *kwnames[] = {
18627 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18628 };
18629
18630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18631 if (obj0) {
18632 {
18633 arg1 = wxString_in_helper(obj0);
18634 if (arg1 == NULL) SWIG_fail;
18635 temp1 = true;
18636 }
18637 }
18638 if (obj1) {
18639 {
18640 arg2 = wxString_in_helper(obj1);
18641 if (arg2 == NULL) SWIG_fail;
18642 temp2 = true;
18643 }
18644 }
18645 if (obj2) {
18646 {
18647 arg3 = wxString_in_helper(obj2);
18648 if (arg3 == NULL) SWIG_fail;
18649 temp3 = true;
18650 }
18651 }
18652 if (obj3) {
18653 {
18654 arg4 = wxString_in_helper(obj3);
18655 if (arg4 == NULL) SWIG_fail;
18656 temp4 = true;
18657 }
18658 }
18659 if (obj4) {
18660 {
18661 arg5 = (long)(SWIG_As_long(obj4));
18662 if (SWIG_arg_fail(5)) SWIG_fail;
18663 }
18664 }
18665 {
18666 PyThreadState* __tstate = wxPyBeginAllowThreads();
18667 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18668
18669 wxPyEndAllowThreads(__tstate);
18670 if (PyErr_Occurred()) SWIG_fail;
18671 }
18672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18673 {
18674 if (temp1)
18675 delete arg1;
18676 }
18677 {
18678 if (temp2)
18679 delete arg2;
18680 }
18681 {
18682 if (temp3)
18683 delete arg3;
18684 }
18685 {
18686 if (temp4)
18687 delete arg4;
18688 }
18689 return resultobj;
18690 fail:
18691 {
18692 if (temp1)
18693 delete arg1;
18694 }
18695 {
18696 if (temp2)
18697 delete arg2;
18698 }
18699 {
18700 if (temp3)
18701 delete arg3;
18702 }
18703 {
18704 if (temp4)
18705 delete arg4;
18706 }
18707 return NULL;
18708 }
18709
18710
18711 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18712 PyObject *resultobj;
18713 wxConfig *arg1 = (wxConfig *) 0 ;
18714 PyObject * obj0 = 0 ;
18715 char *kwnames[] = {
18716 (char *) "self", NULL
18717 };
18718
18719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18721 if (SWIG_arg_fail(1)) SWIG_fail;
18722 {
18723 PyThreadState* __tstate = wxPyBeginAllowThreads();
18724 delete arg1;
18725
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 Py_INCREF(Py_None); resultobj = Py_None;
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18737 PyObject *obj;
18738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18739 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18740 Py_INCREF(obj);
18741 return Py_BuildValue((char *)"");
18742 }
18743 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18744 PyObject *resultobj;
18745 wxString const &arg1_defvalue = wxPyEmptyString ;
18746 wxString *arg1 = (wxString *) &arg1_defvalue ;
18747 wxString const &arg2_defvalue = wxPyEmptyString ;
18748 wxString *arg2 = (wxString *) &arg2_defvalue ;
18749 wxString const &arg3_defvalue = wxPyEmptyString ;
18750 wxString *arg3 = (wxString *) &arg3_defvalue ;
18751 wxString const &arg4_defvalue = wxPyEmptyString ;
18752 wxString *arg4 = (wxString *) &arg4_defvalue ;
18753 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18754 wxFileConfig *result;
18755 bool temp1 = false ;
18756 bool temp2 = false ;
18757 bool temp3 = false ;
18758 bool temp4 = false ;
18759 PyObject * obj0 = 0 ;
18760 PyObject * obj1 = 0 ;
18761 PyObject * obj2 = 0 ;
18762 PyObject * obj3 = 0 ;
18763 PyObject * obj4 = 0 ;
18764 char *kwnames[] = {
18765 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18766 };
18767
18768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18769 if (obj0) {
18770 {
18771 arg1 = wxString_in_helper(obj0);
18772 if (arg1 == NULL) SWIG_fail;
18773 temp1 = true;
18774 }
18775 }
18776 if (obj1) {
18777 {
18778 arg2 = wxString_in_helper(obj1);
18779 if (arg2 == NULL) SWIG_fail;
18780 temp2 = true;
18781 }
18782 }
18783 if (obj2) {
18784 {
18785 arg3 = wxString_in_helper(obj2);
18786 if (arg3 == NULL) SWIG_fail;
18787 temp3 = true;
18788 }
18789 }
18790 if (obj3) {
18791 {
18792 arg4 = wxString_in_helper(obj3);
18793 if (arg4 == NULL) SWIG_fail;
18794 temp4 = true;
18795 }
18796 }
18797 if (obj4) {
18798 {
18799 arg5 = (long)(SWIG_As_long(obj4));
18800 if (SWIG_arg_fail(5)) SWIG_fail;
18801 }
18802 }
18803 {
18804 PyThreadState* __tstate = wxPyBeginAllowThreads();
18805 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18806
18807 wxPyEndAllowThreads(__tstate);
18808 if (PyErr_Occurred()) SWIG_fail;
18809 }
18810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18811 {
18812 if (temp1)
18813 delete arg1;
18814 }
18815 {
18816 if (temp2)
18817 delete arg2;
18818 }
18819 {
18820 if (temp3)
18821 delete arg3;
18822 }
18823 {
18824 if (temp4)
18825 delete arg4;
18826 }
18827 return resultobj;
18828 fail:
18829 {
18830 if (temp1)
18831 delete arg1;
18832 }
18833 {
18834 if (temp2)
18835 delete arg2;
18836 }
18837 {
18838 if (temp3)
18839 delete arg3;
18840 }
18841 {
18842 if (temp4)
18843 delete arg4;
18844 }
18845 return NULL;
18846 }
18847
18848
18849 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18850 PyObject *resultobj;
18851 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18852 PyObject * obj0 = 0 ;
18853 char *kwnames[] = {
18854 (char *) "self", NULL
18855 };
18856
18857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18859 if (SWIG_arg_fail(1)) SWIG_fail;
18860 {
18861 PyThreadState* __tstate = wxPyBeginAllowThreads();
18862 delete arg1;
18863
18864 wxPyEndAllowThreads(__tstate);
18865 if (PyErr_Occurred()) SWIG_fail;
18866 }
18867 Py_INCREF(Py_None); resultobj = Py_None;
18868 return resultobj;
18869 fail:
18870 return NULL;
18871 }
18872
18873
18874 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18875 PyObject *obj;
18876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18877 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18878 Py_INCREF(obj);
18879 return Py_BuildValue((char *)"");
18880 }
18881 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18882 PyObject *resultobj;
18883 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18884 wxString *arg2 = 0 ;
18885 wxConfigPathChanger *result;
18886 bool temp2 = false ;
18887 PyObject * obj0 = 0 ;
18888 PyObject * obj1 = 0 ;
18889 char *kwnames[] = {
18890 (char *) "config",(char *) "entry", NULL
18891 };
18892
18893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18895 if (SWIG_arg_fail(1)) SWIG_fail;
18896 {
18897 arg2 = wxString_in_helper(obj1);
18898 if (arg2 == NULL) SWIG_fail;
18899 temp2 = true;
18900 }
18901 {
18902 PyThreadState* __tstate = wxPyBeginAllowThreads();
18903 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18904
18905 wxPyEndAllowThreads(__tstate);
18906 if (PyErr_Occurred()) SWIG_fail;
18907 }
18908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18909 {
18910 if (temp2)
18911 delete arg2;
18912 }
18913 return resultobj;
18914 fail:
18915 {
18916 if (temp2)
18917 delete arg2;
18918 }
18919 return NULL;
18920 }
18921
18922
18923 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18924 PyObject *resultobj;
18925 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18926 PyObject * obj0 = 0 ;
18927 char *kwnames[] = {
18928 (char *) "self", NULL
18929 };
18930
18931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18933 if (SWIG_arg_fail(1)) SWIG_fail;
18934 {
18935 PyThreadState* __tstate = wxPyBeginAllowThreads();
18936 delete arg1;
18937
18938 wxPyEndAllowThreads(__tstate);
18939 if (PyErr_Occurred()) SWIG_fail;
18940 }
18941 Py_INCREF(Py_None); resultobj = Py_None;
18942 return resultobj;
18943 fail:
18944 return NULL;
18945 }
18946
18947
18948 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18949 PyObject *resultobj;
18950 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18951 wxString *result;
18952 PyObject * obj0 = 0 ;
18953 char *kwnames[] = {
18954 (char *) "self", NULL
18955 };
18956
18957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18959 if (SWIG_arg_fail(1)) SWIG_fail;
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 {
18963 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18964 result = (wxString *) &_result_ref;
18965 }
18966
18967 wxPyEndAllowThreads(__tstate);
18968 if (PyErr_Occurred()) SWIG_fail;
18969 }
18970 {
18971 #if wxUSE_UNICODE
18972 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18973 #else
18974 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18975 #endif
18976 }
18977 return resultobj;
18978 fail:
18979 return NULL;
18980 }
18981
18982
18983 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18984 PyObject *obj;
18985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18986 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18987 Py_INCREF(obj);
18988 return Py_BuildValue((char *)"");
18989 }
18990 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18991 PyObject *resultobj;
18992 wxString *arg1 = 0 ;
18993 wxString result;
18994 bool temp1 = false ;
18995 PyObject * obj0 = 0 ;
18996 char *kwnames[] = {
18997 (char *) "sz", NULL
18998 };
18999
19000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19001 {
19002 arg1 = wxString_in_helper(obj0);
19003 if (arg1 == NULL) SWIG_fail;
19004 temp1 = true;
19005 }
19006 {
19007 PyThreadState* __tstate = wxPyBeginAllowThreads();
19008 result = wxExpandEnvVars((wxString const &)*arg1);
19009
19010 wxPyEndAllowThreads(__tstate);
19011 if (PyErr_Occurred()) SWIG_fail;
19012 }
19013 {
19014 #if wxUSE_UNICODE
19015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19016 #else
19017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19018 #endif
19019 }
19020 {
19021 if (temp1)
19022 delete arg1;
19023 }
19024 return resultobj;
19025 fail:
19026 {
19027 if (temp1)
19028 delete arg1;
19029 }
19030 return NULL;
19031 }
19032
19033
19034 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19035 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19036 return 1;
19037 }
19038
19039
19040 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19041 PyObject *pyobj;
19042
19043 {
19044 #if wxUSE_UNICODE
19045 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19046 #else
19047 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19048 #endif
19049 }
19050 return pyobj;
19051 }
19052
19053
19054 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19055 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19056 return 1;
19057 }
19058
19059
19060 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19061 PyObject *pyobj;
19062
19063 {
19064 #if wxUSE_UNICODE
19065 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19066 #else
19067 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19068 #endif
19069 }
19070 return pyobj;
19071 }
19072
19073
19074 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19075 PyObject *resultobj;
19076 wxDateTime::Country arg1 ;
19077 PyObject * obj0 = 0 ;
19078 char *kwnames[] = {
19079 (char *) "country", NULL
19080 };
19081
19082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19083 {
19084 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19085 if (SWIG_arg_fail(1)) SWIG_fail;
19086 }
19087 {
19088 PyThreadState* __tstate = wxPyBeginAllowThreads();
19089 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19090
19091 wxPyEndAllowThreads(__tstate);
19092 if (PyErr_Occurred()) SWIG_fail;
19093 }
19094 Py_INCREF(Py_None); resultobj = Py_None;
19095 return resultobj;
19096 fail:
19097 return NULL;
19098 }
19099
19100
19101 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19102 PyObject *resultobj;
19103 wxDateTime::Country result;
19104 char *kwnames[] = {
19105 NULL
19106 };
19107
19108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19109 {
19110 PyThreadState* __tstate = wxPyBeginAllowThreads();
19111 result = (wxDateTime::Country)wxDateTime::GetCountry();
19112
19113 wxPyEndAllowThreads(__tstate);
19114 if (PyErr_Occurred()) SWIG_fail;
19115 }
19116 resultobj = SWIG_From_int((result));
19117 return resultobj;
19118 fail:
19119 return NULL;
19120 }
19121
19122
19123 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19124 PyObject *resultobj;
19125 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19126 bool result;
19127 PyObject * obj0 = 0 ;
19128 char *kwnames[] = {
19129 (char *) "country", NULL
19130 };
19131
19132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19133 if (obj0) {
19134 {
19135 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19136 if (SWIG_arg_fail(1)) SWIG_fail;
19137 }
19138 }
19139 {
19140 PyThreadState* __tstate = wxPyBeginAllowThreads();
19141 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19142
19143 wxPyEndAllowThreads(__tstate);
19144 if (PyErr_Occurred()) SWIG_fail;
19145 }
19146 {
19147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19148 }
19149 return resultobj;
19150 fail:
19151 return NULL;
19152 }
19153
19154
19155 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19156 PyObject *resultobj;
19157 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19158 int result;
19159 PyObject * obj0 = 0 ;
19160 char *kwnames[] = {
19161 (char *) "cal", NULL
19162 };
19163
19164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19165 if (obj0) {
19166 {
19167 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19168 if (SWIG_arg_fail(1)) SWIG_fail;
19169 }
19170 }
19171 {
19172 PyThreadState* __tstate = wxPyBeginAllowThreads();
19173 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19174
19175 wxPyEndAllowThreads(__tstate);
19176 if (PyErr_Occurred()) SWIG_fail;
19177 }
19178 {
19179 resultobj = SWIG_From_int((int)(result));
19180 }
19181 return resultobj;
19182 fail:
19183 return NULL;
19184 }
19185
19186
19187 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19188 PyObject *resultobj;
19189 int arg1 ;
19190 int result;
19191 PyObject * obj0 = 0 ;
19192 char *kwnames[] = {
19193 (char *) "year", NULL
19194 };
19195
19196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19197 {
19198 arg1 = (int)(SWIG_As_int(obj0));
19199 if (SWIG_arg_fail(1)) SWIG_fail;
19200 }
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 result = (int)wxDateTime::ConvertYearToBC(arg1);
19204
19205 wxPyEndAllowThreads(__tstate);
19206 if (PyErr_Occurred()) SWIG_fail;
19207 }
19208 {
19209 resultobj = SWIG_From_int((int)(result));
19210 }
19211 return resultobj;
19212 fail:
19213 return NULL;
19214 }
19215
19216
19217 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19218 PyObject *resultobj;
19219 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19220 wxDateTime::Month result;
19221 PyObject * obj0 = 0 ;
19222 char *kwnames[] = {
19223 (char *) "cal", NULL
19224 };
19225
19226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19227 if (obj0) {
19228 {
19229 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 }
19232 }
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19236
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 resultobj = SWIG_From_int((result));
19241 return resultobj;
19242 fail:
19243 return NULL;
19244 }
19245
19246
19247 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19248 PyObject *resultobj;
19249 int arg1 = (int) wxDateTime::Inv_Year ;
19250 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19251 bool result;
19252 PyObject * obj0 = 0 ;
19253 PyObject * obj1 = 0 ;
19254 char *kwnames[] = {
19255 (char *) "year",(char *) "cal", NULL
19256 };
19257
19258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19259 if (obj0) {
19260 {
19261 arg1 = (int)(SWIG_As_int(obj0));
19262 if (SWIG_arg_fail(1)) SWIG_fail;
19263 }
19264 }
19265 if (obj1) {
19266 {
19267 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19268 if (SWIG_arg_fail(2)) SWIG_fail;
19269 }
19270 }
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19274
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 {
19279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19280 }
19281 return resultobj;
19282 fail:
19283 return NULL;
19284 }
19285
19286
19287 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19288 PyObject *resultobj;
19289 int arg1 = (int) wxDateTime::Inv_Year ;
19290 int result;
19291 PyObject * obj0 = 0 ;
19292 char *kwnames[] = {
19293 (char *) "year", NULL
19294 };
19295
19296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19297 if (obj0) {
19298 {
19299 arg1 = (int)(SWIG_As_int(obj0));
19300 if (SWIG_arg_fail(1)) SWIG_fail;
19301 }
19302 }
19303 {
19304 PyThreadState* __tstate = wxPyBeginAllowThreads();
19305 result = (int)wxDateTime::GetCentury(arg1);
19306
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 {
19311 resultobj = SWIG_From_int((int)(result));
19312 }
19313 return resultobj;
19314 fail:
19315 return NULL;
19316 }
19317
19318
19319 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19320 PyObject *resultobj;
19321 int arg1 ;
19322 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19323 int result;
19324 PyObject * obj0 = 0 ;
19325 PyObject * obj1 = 0 ;
19326 char *kwnames[] = {
19327 (char *) "year",(char *) "cal", NULL
19328 };
19329
19330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19331 {
19332 arg1 = (int)(SWIG_As_int(obj0));
19333 if (SWIG_arg_fail(1)) SWIG_fail;
19334 }
19335 if (obj1) {
19336 {
19337 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19338 if (SWIG_arg_fail(2)) SWIG_fail;
19339 }
19340 }
19341 {
19342 PyThreadState* __tstate = wxPyBeginAllowThreads();
19343 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19344
19345 wxPyEndAllowThreads(__tstate);
19346 if (PyErr_Occurred()) SWIG_fail;
19347 }
19348 {
19349 resultobj = SWIG_From_int((int)(result));
19350 }
19351 return resultobj;
19352 fail:
19353 return NULL;
19354 }
19355
19356
19357 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19358 PyObject *resultobj;
19359 wxDateTime::Month arg1 ;
19360 int arg2 = (int) wxDateTime::Inv_Year ;
19361 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19362 int result;
19363 PyObject * obj0 = 0 ;
19364 PyObject * obj1 = 0 ;
19365 PyObject * obj2 = 0 ;
19366 char *kwnames[] = {
19367 (char *) "month",(char *) "year",(char *) "cal", NULL
19368 };
19369
19370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19371 {
19372 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19373 if (SWIG_arg_fail(1)) SWIG_fail;
19374 }
19375 if (obj1) {
19376 {
19377 arg2 = (int)(SWIG_As_int(obj1));
19378 if (SWIG_arg_fail(2)) SWIG_fail;
19379 }
19380 }
19381 if (obj2) {
19382 {
19383 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19384 if (SWIG_arg_fail(3)) SWIG_fail;
19385 }
19386 }
19387 {
19388 PyThreadState* __tstate = wxPyBeginAllowThreads();
19389 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19390
19391 wxPyEndAllowThreads(__tstate);
19392 if (PyErr_Occurred()) SWIG_fail;
19393 }
19394 {
19395 resultobj = SWIG_From_int((int)(result));
19396 }
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj;
19405 wxDateTime::Month arg1 ;
19406 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19407 wxString result;
19408 PyObject * obj0 = 0 ;
19409 PyObject * obj1 = 0 ;
19410 char *kwnames[] = {
19411 (char *) "month",(char *) "flags", NULL
19412 };
19413
19414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19415 {
19416 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19417 if (SWIG_arg_fail(1)) SWIG_fail;
19418 }
19419 if (obj1) {
19420 {
19421 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19422 if (SWIG_arg_fail(2)) SWIG_fail;
19423 }
19424 }
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19428
19429 wxPyEndAllowThreads(__tstate);
19430 if (PyErr_Occurred()) SWIG_fail;
19431 }
19432 {
19433 #if wxUSE_UNICODE
19434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19435 #else
19436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19437 #endif
19438 }
19439 return resultobj;
19440 fail:
19441 return NULL;
19442 }
19443
19444
19445 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19446 PyObject *resultobj;
19447 wxDateTime::WeekDay arg1 ;
19448 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19449 wxString result;
19450 PyObject * obj0 = 0 ;
19451 PyObject * obj1 = 0 ;
19452 char *kwnames[] = {
19453 (char *) "weekday",(char *) "flags", NULL
19454 };
19455
19456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19457 {
19458 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19459 if (SWIG_arg_fail(1)) SWIG_fail;
19460 }
19461 if (obj1) {
19462 {
19463 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19464 if (SWIG_arg_fail(2)) SWIG_fail;
19465 }
19466 }
19467 {
19468 PyThreadState* __tstate = wxPyBeginAllowThreads();
19469 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19470
19471 wxPyEndAllowThreads(__tstate);
19472 if (PyErr_Occurred()) SWIG_fail;
19473 }
19474 {
19475 #if wxUSE_UNICODE
19476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19477 #else
19478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19479 #endif
19480 }
19481 return resultobj;
19482 fail:
19483 return NULL;
19484 }
19485
19486
19487 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19488 PyObject *resultobj;
19489 PyObject *result;
19490 char *kwnames[] = {
19491 NULL
19492 };
19493
19494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19495 {
19496 PyThreadState* __tstate = wxPyBeginAllowThreads();
19497 result = (PyObject *)DateTime_GetAmPmStrings();
19498
19499 wxPyEndAllowThreads(__tstate);
19500 if (PyErr_Occurred()) SWIG_fail;
19501 }
19502 resultobj = result;
19503 return resultobj;
19504 fail:
19505 return NULL;
19506 }
19507
19508
19509 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19510 PyObject *resultobj;
19511 int arg1 = (int) wxDateTime::Inv_Year ;
19512 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19513 bool result;
19514 PyObject * obj0 = 0 ;
19515 PyObject * obj1 = 0 ;
19516 char *kwnames[] = {
19517 (char *) "year",(char *) "country", NULL
19518 };
19519
19520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19521 if (obj0) {
19522 {
19523 arg1 = (int)(SWIG_As_int(obj0));
19524 if (SWIG_arg_fail(1)) SWIG_fail;
19525 }
19526 }
19527 if (obj1) {
19528 {
19529 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19530 if (SWIG_arg_fail(2)) SWIG_fail;
19531 }
19532 }
19533 {
19534 PyThreadState* __tstate = wxPyBeginAllowThreads();
19535 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19536
19537 wxPyEndAllowThreads(__tstate);
19538 if (PyErr_Occurred()) SWIG_fail;
19539 }
19540 {
19541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19542 }
19543 return resultobj;
19544 fail:
19545 return NULL;
19546 }
19547
19548
19549 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19550 PyObject *resultobj;
19551 int arg1 = (int) wxDateTime::Inv_Year ;
19552 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19553 wxDateTime result;
19554 PyObject * obj0 = 0 ;
19555 PyObject * obj1 = 0 ;
19556 char *kwnames[] = {
19557 (char *) "year",(char *) "country", NULL
19558 };
19559
19560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19561 if (obj0) {
19562 {
19563 arg1 = (int)(SWIG_As_int(obj0));
19564 if (SWIG_arg_fail(1)) SWIG_fail;
19565 }
19566 }
19567 if (obj1) {
19568 {
19569 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19570 if (SWIG_arg_fail(2)) SWIG_fail;
19571 }
19572 }
19573 {
19574 PyThreadState* __tstate = wxPyBeginAllowThreads();
19575 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19576
19577 wxPyEndAllowThreads(__tstate);
19578 if (PyErr_Occurred()) SWIG_fail;
19579 }
19580 {
19581 wxDateTime * resultptr;
19582 resultptr = new wxDateTime((wxDateTime &)(result));
19583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19584 }
19585 return resultobj;
19586 fail:
19587 return NULL;
19588 }
19589
19590
19591 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19592 PyObject *resultobj;
19593 int arg1 = (int) wxDateTime::Inv_Year ;
19594 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19595 wxDateTime result;
19596 PyObject * obj0 = 0 ;
19597 PyObject * obj1 = 0 ;
19598 char *kwnames[] = {
19599 (char *) "year",(char *) "country", NULL
19600 };
19601
19602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19603 if (obj0) {
19604 {
19605 arg1 = (int)(SWIG_As_int(obj0));
19606 if (SWIG_arg_fail(1)) SWIG_fail;
19607 }
19608 }
19609 if (obj1) {
19610 {
19611 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19612 if (SWIG_arg_fail(2)) SWIG_fail;
19613 }
19614 }
19615 {
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19618
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 {
19623 wxDateTime * resultptr;
19624 resultptr = new wxDateTime((wxDateTime &)(result));
19625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19626 }
19627 return resultobj;
19628 fail:
19629 return NULL;
19630 }
19631
19632
19633 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19634 PyObject *resultobj;
19635 wxDateTime result;
19636 char *kwnames[] = {
19637 NULL
19638 };
19639
19640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19641 {
19642 PyThreadState* __tstate = wxPyBeginAllowThreads();
19643 result = wxDateTime::Now();
19644
19645 wxPyEndAllowThreads(__tstate);
19646 if (PyErr_Occurred()) SWIG_fail;
19647 }
19648 {
19649 wxDateTime * resultptr;
19650 resultptr = new wxDateTime((wxDateTime &)(result));
19651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19652 }
19653 return resultobj;
19654 fail:
19655 return NULL;
19656 }
19657
19658
19659 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19660 PyObject *resultobj;
19661 wxDateTime result;
19662 char *kwnames[] = {
19663 NULL
19664 };
19665
19666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19667 {
19668 PyThreadState* __tstate = wxPyBeginAllowThreads();
19669 result = wxDateTime::UNow();
19670
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 {
19675 wxDateTime * resultptr;
19676 resultptr = new wxDateTime((wxDateTime &)(result));
19677 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19678 }
19679 return resultobj;
19680 fail:
19681 return NULL;
19682 }
19683
19684
19685 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19686 PyObject *resultobj;
19687 wxDateTime result;
19688 char *kwnames[] = {
19689 NULL
19690 };
19691
19692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19693 {
19694 PyThreadState* __tstate = wxPyBeginAllowThreads();
19695 result = wxDateTime::Today();
19696
19697 wxPyEndAllowThreads(__tstate);
19698 if (PyErr_Occurred()) SWIG_fail;
19699 }
19700 {
19701 wxDateTime * resultptr;
19702 resultptr = new wxDateTime((wxDateTime &)(result));
19703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19704 }
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19712 PyObject *resultobj;
19713 wxDateTime *result;
19714 char *kwnames[] = {
19715 NULL
19716 };
19717
19718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19719 {
19720 PyThreadState* __tstate = wxPyBeginAllowThreads();
19721 result = (wxDateTime *)new wxDateTime();
19722
19723 wxPyEndAllowThreads(__tstate);
19724 if (PyErr_Occurred()) SWIG_fail;
19725 }
19726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19727 return resultobj;
19728 fail:
19729 return NULL;
19730 }
19731
19732
19733 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19734 PyObject *resultobj;
19735 time_t arg1 ;
19736 wxDateTime *result;
19737 PyObject * obj0 = 0 ;
19738 char *kwnames[] = {
19739 (char *) "timet", NULL
19740 };
19741
19742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19743 {
19744 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19745 if (SWIG_arg_fail(1)) SWIG_fail;
19746 }
19747 {
19748 PyThreadState* __tstate = wxPyBeginAllowThreads();
19749 result = (wxDateTime *)new wxDateTime(arg1);
19750
19751 wxPyEndAllowThreads(__tstate);
19752 if (PyErr_Occurred()) SWIG_fail;
19753 }
19754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 double arg1 ;
19764 wxDateTime *result;
19765 PyObject * obj0 = 0 ;
19766 char *kwnames[] = {
19767 (char *) "jdn", NULL
19768 };
19769
19770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19771 {
19772 arg1 = (double)(SWIG_As_double(obj0));
19773 if (SWIG_arg_fail(1)) SWIG_fail;
19774 }
19775 {
19776 PyThreadState* __tstate = wxPyBeginAllowThreads();
19777 result = (wxDateTime *)new wxDateTime(arg1);
19778
19779 wxPyEndAllowThreads(__tstate);
19780 if (PyErr_Occurred()) SWIG_fail;
19781 }
19782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19783 return resultobj;
19784 fail:
19785 return NULL;
19786 }
19787
19788
19789 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19790 PyObject *resultobj;
19791 int arg1 ;
19792 int arg2 = (int) 0 ;
19793 int arg3 = (int) 0 ;
19794 int arg4 = (int) 0 ;
19795 wxDateTime *result;
19796 PyObject * obj0 = 0 ;
19797 PyObject * obj1 = 0 ;
19798 PyObject * obj2 = 0 ;
19799 PyObject * obj3 = 0 ;
19800 char *kwnames[] = {
19801 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19802 };
19803
19804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19805 {
19806 arg1 = (int)(SWIG_As_int(obj0));
19807 if (SWIG_arg_fail(1)) SWIG_fail;
19808 }
19809 if (obj1) {
19810 {
19811 arg2 = (int)(SWIG_As_int(obj1));
19812 if (SWIG_arg_fail(2)) SWIG_fail;
19813 }
19814 }
19815 if (obj2) {
19816 {
19817 arg3 = (int)(SWIG_As_int(obj2));
19818 if (SWIG_arg_fail(3)) SWIG_fail;
19819 }
19820 }
19821 if (obj3) {
19822 {
19823 arg4 = (int)(SWIG_As_int(obj3));
19824 if (SWIG_arg_fail(4)) SWIG_fail;
19825 }
19826 }
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19830
19831 wxPyEndAllowThreads(__tstate);
19832 if (PyErr_Occurred()) SWIG_fail;
19833 }
19834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19835 return resultobj;
19836 fail:
19837 return NULL;
19838 }
19839
19840
19841 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19842 PyObject *resultobj;
19843 int arg1 ;
19844 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19845 int arg3 = (int) wxDateTime::Inv_Year ;
19846 int arg4 = (int) 0 ;
19847 int arg5 = (int) 0 ;
19848 int arg6 = (int) 0 ;
19849 int arg7 = (int) 0 ;
19850 wxDateTime *result;
19851 PyObject * obj0 = 0 ;
19852 PyObject * obj1 = 0 ;
19853 PyObject * obj2 = 0 ;
19854 PyObject * obj3 = 0 ;
19855 PyObject * obj4 = 0 ;
19856 PyObject * obj5 = 0 ;
19857 PyObject * obj6 = 0 ;
19858 char *kwnames[] = {
19859 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19860 };
19861
19862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19863 {
19864 arg1 = (int)(SWIG_As_int(obj0));
19865 if (SWIG_arg_fail(1)) SWIG_fail;
19866 }
19867 if (obj1) {
19868 {
19869 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19870 if (SWIG_arg_fail(2)) SWIG_fail;
19871 }
19872 }
19873 if (obj2) {
19874 {
19875 arg3 = (int)(SWIG_As_int(obj2));
19876 if (SWIG_arg_fail(3)) SWIG_fail;
19877 }
19878 }
19879 if (obj3) {
19880 {
19881 arg4 = (int)(SWIG_As_int(obj3));
19882 if (SWIG_arg_fail(4)) SWIG_fail;
19883 }
19884 }
19885 if (obj4) {
19886 {
19887 arg5 = (int)(SWIG_As_int(obj4));
19888 if (SWIG_arg_fail(5)) SWIG_fail;
19889 }
19890 }
19891 if (obj5) {
19892 {
19893 arg6 = (int)(SWIG_As_int(obj5));
19894 if (SWIG_arg_fail(6)) SWIG_fail;
19895 }
19896 }
19897 if (obj6) {
19898 {
19899 arg7 = (int)(SWIG_As_int(obj6));
19900 if (SWIG_arg_fail(7)) SWIG_fail;
19901 }
19902 }
19903 {
19904 PyThreadState* __tstate = wxPyBeginAllowThreads();
19905 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19906
19907 wxPyEndAllowThreads(__tstate);
19908 if (PyErr_Occurred()) SWIG_fail;
19909 }
19910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19911 return resultobj;
19912 fail:
19913 return NULL;
19914 }
19915
19916
19917 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19918 PyObject *resultobj;
19919 wxDateTime *arg1 = (wxDateTime *) 0 ;
19920 PyObject * obj0 = 0 ;
19921 char *kwnames[] = {
19922 (char *) "self", NULL
19923 };
19924
19925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19927 if (SWIG_arg_fail(1)) SWIG_fail;
19928 {
19929 PyThreadState* __tstate = wxPyBeginAllowThreads();
19930 delete arg1;
19931
19932 wxPyEndAllowThreads(__tstate);
19933 if (PyErr_Occurred()) SWIG_fail;
19934 }
19935 Py_INCREF(Py_None); resultobj = Py_None;
19936 return resultobj;
19937 fail:
19938 return NULL;
19939 }
19940
19941
19942 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19943 PyObject *resultobj;
19944 wxDateTime *arg1 = (wxDateTime *) 0 ;
19945 wxDateTime *result;
19946 PyObject * obj0 = 0 ;
19947 char *kwnames[] = {
19948 (char *) "self", NULL
19949 };
19950
19951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19953 if (SWIG_arg_fail(1)) SWIG_fail;
19954 {
19955 PyThreadState* __tstate = wxPyBeginAllowThreads();
19956 {
19957 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19958 result = (wxDateTime *) &_result_ref;
19959 }
19960
19961 wxPyEndAllowThreads(__tstate);
19962 if (PyErr_Occurred()) SWIG_fail;
19963 }
19964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19965 return resultobj;
19966 fail:
19967 return NULL;
19968 }
19969
19970
19971 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19972 PyObject *resultobj;
19973 wxDateTime *arg1 = (wxDateTime *) 0 ;
19974 time_t arg2 ;
19975 wxDateTime *result;
19976 PyObject * obj0 = 0 ;
19977 PyObject * obj1 = 0 ;
19978 char *kwnames[] = {
19979 (char *) "self",(char *) "timet", NULL
19980 };
19981
19982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19984 if (SWIG_arg_fail(1)) SWIG_fail;
19985 {
19986 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19987 if (SWIG_arg_fail(2)) SWIG_fail;
19988 }
19989 {
19990 PyThreadState* __tstate = wxPyBeginAllowThreads();
19991 {
19992 wxDateTime &_result_ref = (arg1)->Set(arg2);
19993 result = (wxDateTime *) &_result_ref;
19994 }
19995
19996 wxPyEndAllowThreads(__tstate);
19997 if (PyErr_Occurred()) SWIG_fail;
19998 }
19999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20000 return resultobj;
20001 fail:
20002 return NULL;
20003 }
20004
20005
20006 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20007 PyObject *resultobj;
20008 wxDateTime *arg1 = (wxDateTime *) 0 ;
20009 double arg2 ;
20010 wxDateTime *result;
20011 PyObject * obj0 = 0 ;
20012 PyObject * obj1 = 0 ;
20013 char *kwnames[] = {
20014 (char *) "self",(char *) "jdn", NULL
20015 };
20016
20017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20019 if (SWIG_arg_fail(1)) SWIG_fail;
20020 {
20021 arg2 = (double)(SWIG_As_double(obj1));
20022 if (SWIG_arg_fail(2)) SWIG_fail;
20023 }
20024 {
20025 PyThreadState* __tstate = wxPyBeginAllowThreads();
20026 {
20027 wxDateTime &_result_ref = (arg1)->Set(arg2);
20028 result = (wxDateTime *) &_result_ref;
20029 }
20030
20031 wxPyEndAllowThreads(__tstate);
20032 if (PyErr_Occurred()) SWIG_fail;
20033 }
20034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20035 return resultobj;
20036 fail:
20037 return NULL;
20038 }
20039
20040
20041 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20042 PyObject *resultobj;
20043 wxDateTime *arg1 = (wxDateTime *) 0 ;
20044 int arg2 ;
20045 int arg3 = (int) 0 ;
20046 int arg4 = (int) 0 ;
20047 int arg5 = (int) 0 ;
20048 wxDateTime *result;
20049 PyObject * obj0 = 0 ;
20050 PyObject * obj1 = 0 ;
20051 PyObject * obj2 = 0 ;
20052 PyObject * obj3 = 0 ;
20053 PyObject * obj4 = 0 ;
20054 char *kwnames[] = {
20055 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20056 };
20057
20058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20060 if (SWIG_arg_fail(1)) SWIG_fail;
20061 {
20062 arg2 = (int)(SWIG_As_int(obj1));
20063 if (SWIG_arg_fail(2)) SWIG_fail;
20064 }
20065 if (obj2) {
20066 {
20067 arg3 = (int)(SWIG_As_int(obj2));
20068 if (SWIG_arg_fail(3)) SWIG_fail;
20069 }
20070 }
20071 if (obj3) {
20072 {
20073 arg4 = (int)(SWIG_As_int(obj3));
20074 if (SWIG_arg_fail(4)) SWIG_fail;
20075 }
20076 }
20077 if (obj4) {
20078 {
20079 arg5 = (int)(SWIG_As_int(obj4));
20080 if (SWIG_arg_fail(5)) SWIG_fail;
20081 }
20082 }
20083 {
20084 PyThreadState* __tstate = wxPyBeginAllowThreads();
20085 {
20086 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20087 result = (wxDateTime *) &_result_ref;
20088 }
20089
20090 wxPyEndAllowThreads(__tstate);
20091 if (PyErr_Occurred()) SWIG_fail;
20092 }
20093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20094 return resultobj;
20095 fail:
20096 return NULL;
20097 }
20098
20099
20100 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20101 PyObject *resultobj;
20102 wxDateTime *arg1 = (wxDateTime *) 0 ;
20103 int arg2 ;
20104 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20105 int arg4 = (int) wxDateTime::Inv_Year ;
20106 int arg5 = (int) 0 ;
20107 int arg6 = (int) 0 ;
20108 int arg7 = (int) 0 ;
20109 int arg8 = (int) 0 ;
20110 wxDateTime *result;
20111 PyObject * obj0 = 0 ;
20112 PyObject * obj1 = 0 ;
20113 PyObject * obj2 = 0 ;
20114 PyObject * obj3 = 0 ;
20115 PyObject * obj4 = 0 ;
20116 PyObject * obj5 = 0 ;
20117 PyObject * obj6 = 0 ;
20118 PyObject * obj7 = 0 ;
20119 char *kwnames[] = {
20120 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20121 };
20122
20123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20125 if (SWIG_arg_fail(1)) SWIG_fail;
20126 {
20127 arg2 = (int)(SWIG_As_int(obj1));
20128 if (SWIG_arg_fail(2)) SWIG_fail;
20129 }
20130 if (obj2) {
20131 {
20132 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20133 if (SWIG_arg_fail(3)) SWIG_fail;
20134 }
20135 }
20136 if (obj3) {
20137 {
20138 arg4 = (int)(SWIG_As_int(obj3));
20139 if (SWIG_arg_fail(4)) SWIG_fail;
20140 }
20141 }
20142 if (obj4) {
20143 {
20144 arg5 = (int)(SWIG_As_int(obj4));
20145 if (SWIG_arg_fail(5)) SWIG_fail;
20146 }
20147 }
20148 if (obj5) {
20149 {
20150 arg6 = (int)(SWIG_As_int(obj5));
20151 if (SWIG_arg_fail(6)) SWIG_fail;
20152 }
20153 }
20154 if (obj6) {
20155 {
20156 arg7 = (int)(SWIG_As_int(obj6));
20157 if (SWIG_arg_fail(7)) SWIG_fail;
20158 }
20159 }
20160 if (obj7) {
20161 {
20162 arg8 = (int)(SWIG_As_int(obj7));
20163 if (SWIG_arg_fail(8)) SWIG_fail;
20164 }
20165 }
20166 {
20167 PyThreadState* __tstate = wxPyBeginAllowThreads();
20168 {
20169 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20170 result = (wxDateTime *) &_result_ref;
20171 }
20172
20173 wxPyEndAllowThreads(__tstate);
20174 if (PyErr_Occurred()) SWIG_fail;
20175 }
20176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20177 return resultobj;
20178 fail:
20179 return NULL;
20180 }
20181
20182
20183 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20184 PyObject *resultobj;
20185 wxDateTime *arg1 = (wxDateTime *) 0 ;
20186 wxDateTime *result;
20187 PyObject * obj0 = 0 ;
20188 char *kwnames[] = {
20189 (char *) "self", NULL
20190 };
20191
20192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20194 if (SWIG_arg_fail(1)) SWIG_fail;
20195 {
20196 PyThreadState* __tstate = wxPyBeginAllowThreads();
20197 {
20198 wxDateTime &_result_ref = (arg1)->ResetTime();
20199 result = (wxDateTime *) &_result_ref;
20200 }
20201
20202 wxPyEndAllowThreads(__tstate);
20203 if (PyErr_Occurred()) SWIG_fail;
20204 }
20205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20206 return resultobj;
20207 fail:
20208 return NULL;
20209 }
20210
20211
20212 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20213 PyObject *resultobj;
20214 wxDateTime *arg1 = (wxDateTime *) 0 ;
20215 int arg2 ;
20216 wxDateTime *result;
20217 PyObject * obj0 = 0 ;
20218 PyObject * obj1 = 0 ;
20219 char *kwnames[] = {
20220 (char *) "self",(char *) "year", NULL
20221 };
20222
20223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20225 if (SWIG_arg_fail(1)) SWIG_fail;
20226 {
20227 arg2 = (int)(SWIG_As_int(obj1));
20228 if (SWIG_arg_fail(2)) SWIG_fail;
20229 }
20230 {
20231 PyThreadState* __tstate = wxPyBeginAllowThreads();
20232 {
20233 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20234 result = (wxDateTime *) &_result_ref;
20235 }
20236
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20248 PyObject *resultobj;
20249 wxDateTime *arg1 = (wxDateTime *) 0 ;
20250 wxDateTime::Month arg2 ;
20251 wxDateTime *result;
20252 PyObject * obj0 = 0 ;
20253 PyObject * obj1 = 0 ;
20254 char *kwnames[] = {
20255 (char *) "self",(char *) "month", NULL
20256 };
20257
20258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 {
20262 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20263 if (SWIG_arg_fail(2)) SWIG_fail;
20264 }
20265 {
20266 PyThreadState* __tstate = wxPyBeginAllowThreads();
20267 {
20268 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20269 result = (wxDateTime *) &_result_ref;
20270 }
20271
20272 wxPyEndAllowThreads(__tstate);
20273 if (PyErr_Occurred()) SWIG_fail;
20274 }
20275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20276 return resultobj;
20277 fail:
20278 return NULL;
20279 }
20280
20281
20282 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20283 PyObject *resultobj;
20284 wxDateTime *arg1 = (wxDateTime *) 0 ;
20285 int arg2 ;
20286 wxDateTime *result;
20287 PyObject * obj0 = 0 ;
20288 PyObject * obj1 = 0 ;
20289 char *kwnames[] = {
20290 (char *) "self",(char *) "day", NULL
20291 };
20292
20293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20295 if (SWIG_arg_fail(1)) SWIG_fail;
20296 {
20297 arg2 = (int)(SWIG_As_int(obj1));
20298 if (SWIG_arg_fail(2)) SWIG_fail;
20299 }
20300 {
20301 PyThreadState* __tstate = wxPyBeginAllowThreads();
20302 {
20303 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20304 result = (wxDateTime *) &_result_ref;
20305 }
20306
20307 wxPyEndAllowThreads(__tstate);
20308 if (PyErr_Occurred()) SWIG_fail;
20309 }
20310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20311 return resultobj;
20312 fail:
20313 return NULL;
20314 }
20315
20316
20317 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20318 PyObject *resultobj;
20319 wxDateTime *arg1 = (wxDateTime *) 0 ;
20320 int arg2 ;
20321 wxDateTime *result;
20322 PyObject * obj0 = 0 ;
20323 PyObject * obj1 = 0 ;
20324 char *kwnames[] = {
20325 (char *) "self",(char *) "hour", NULL
20326 };
20327
20328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20330 if (SWIG_arg_fail(1)) SWIG_fail;
20331 {
20332 arg2 = (int)(SWIG_As_int(obj1));
20333 if (SWIG_arg_fail(2)) SWIG_fail;
20334 }
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 {
20338 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20339 result = (wxDateTime *) &_result_ref;
20340 }
20341
20342 wxPyEndAllowThreads(__tstate);
20343 if (PyErr_Occurred()) SWIG_fail;
20344 }
20345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20346 return resultobj;
20347 fail:
20348 return NULL;
20349 }
20350
20351
20352 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20353 PyObject *resultobj;
20354 wxDateTime *arg1 = (wxDateTime *) 0 ;
20355 int arg2 ;
20356 wxDateTime *result;
20357 PyObject * obj0 = 0 ;
20358 PyObject * obj1 = 0 ;
20359 char *kwnames[] = {
20360 (char *) "self",(char *) "minute", NULL
20361 };
20362
20363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20365 if (SWIG_arg_fail(1)) SWIG_fail;
20366 {
20367 arg2 = (int)(SWIG_As_int(obj1));
20368 if (SWIG_arg_fail(2)) SWIG_fail;
20369 }
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 {
20373 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20374 result = (wxDateTime *) &_result_ref;
20375 }
20376
20377 wxPyEndAllowThreads(__tstate);
20378 if (PyErr_Occurred()) SWIG_fail;
20379 }
20380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20381 return resultobj;
20382 fail:
20383 return NULL;
20384 }
20385
20386
20387 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20388 PyObject *resultobj;
20389 wxDateTime *arg1 = (wxDateTime *) 0 ;
20390 int arg2 ;
20391 wxDateTime *result;
20392 PyObject * obj0 = 0 ;
20393 PyObject * obj1 = 0 ;
20394 char *kwnames[] = {
20395 (char *) "self",(char *) "second", NULL
20396 };
20397
20398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20400 if (SWIG_arg_fail(1)) SWIG_fail;
20401 {
20402 arg2 = (int)(SWIG_As_int(obj1));
20403 if (SWIG_arg_fail(2)) SWIG_fail;
20404 }
20405 {
20406 PyThreadState* __tstate = wxPyBeginAllowThreads();
20407 {
20408 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20409 result = (wxDateTime *) &_result_ref;
20410 }
20411
20412 wxPyEndAllowThreads(__tstate);
20413 if (PyErr_Occurred()) SWIG_fail;
20414 }
20415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20416 return resultobj;
20417 fail:
20418 return NULL;
20419 }
20420
20421
20422 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20423 PyObject *resultobj;
20424 wxDateTime *arg1 = (wxDateTime *) 0 ;
20425 int arg2 ;
20426 wxDateTime *result;
20427 PyObject * obj0 = 0 ;
20428 PyObject * obj1 = 0 ;
20429 char *kwnames[] = {
20430 (char *) "self",(char *) "millisecond", NULL
20431 };
20432
20433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20435 if (SWIG_arg_fail(1)) SWIG_fail;
20436 {
20437 arg2 = (int)(SWIG_As_int(obj1));
20438 if (SWIG_arg_fail(2)) SWIG_fail;
20439 }
20440 {
20441 PyThreadState* __tstate = wxPyBeginAllowThreads();
20442 {
20443 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20444 result = (wxDateTime *) &_result_ref;
20445 }
20446
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20451 return resultobj;
20452 fail:
20453 return NULL;
20454 }
20455
20456
20457 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20458 PyObject *resultobj;
20459 wxDateTime *arg1 = (wxDateTime *) 0 ;
20460 wxDateTime::WeekDay arg2 ;
20461 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20462 wxDateTime *result;
20463 PyObject * obj0 = 0 ;
20464 PyObject * obj1 = 0 ;
20465 PyObject * obj2 = 0 ;
20466 char *kwnames[] = {
20467 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20468 };
20469
20470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20472 if (SWIG_arg_fail(1)) SWIG_fail;
20473 {
20474 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20475 if (SWIG_arg_fail(2)) SWIG_fail;
20476 }
20477 if (obj2) {
20478 {
20479 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20480 if (SWIG_arg_fail(3)) SWIG_fail;
20481 }
20482 }
20483 {
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 {
20486 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20487 result = (wxDateTime *) &_result_ref;
20488 }
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20494 return resultobj;
20495 fail:
20496 return NULL;
20497 }
20498
20499
20500 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20501 PyObject *resultobj;
20502 wxDateTime *arg1 = (wxDateTime *) 0 ;
20503 wxDateTime::WeekDay arg2 ;
20504 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20505 wxDateTime result;
20506 PyObject * obj0 = 0 ;
20507 PyObject * obj1 = 0 ;
20508 PyObject * obj2 = 0 ;
20509 char *kwnames[] = {
20510 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20511 };
20512
20513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20515 if (SWIG_arg_fail(1)) SWIG_fail;
20516 {
20517 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20518 if (SWIG_arg_fail(2)) SWIG_fail;
20519 }
20520 if (obj2) {
20521 {
20522 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20523 if (SWIG_arg_fail(3)) SWIG_fail;
20524 }
20525 }
20526 {
20527 PyThreadState* __tstate = wxPyBeginAllowThreads();
20528 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20529
20530 wxPyEndAllowThreads(__tstate);
20531 if (PyErr_Occurred()) SWIG_fail;
20532 }
20533 {
20534 wxDateTime * resultptr;
20535 resultptr = new wxDateTime((wxDateTime &)(result));
20536 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20537 }
20538 return resultobj;
20539 fail:
20540 return NULL;
20541 }
20542
20543
20544 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20545 PyObject *resultobj;
20546 wxDateTime *arg1 = (wxDateTime *) 0 ;
20547 wxDateTime::WeekDay arg2 ;
20548 wxDateTime *result;
20549 PyObject * obj0 = 0 ;
20550 PyObject * obj1 = 0 ;
20551 char *kwnames[] = {
20552 (char *) "self",(char *) "weekday", NULL
20553 };
20554
20555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20557 if (SWIG_arg_fail(1)) SWIG_fail;
20558 {
20559 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20560 if (SWIG_arg_fail(2)) SWIG_fail;
20561 }
20562 {
20563 PyThreadState* __tstate = wxPyBeginAllowThreads();
20564 {
20565 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20566 result = (wxDateTime *) &_result_ref;
20567 }
20568
20569 wxPyEndAllowThreads(__tstate);
20570 if (PyErr_Occurred()) SWIG_fail;
20571 }
20572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20573 return resultobj;
20574 fail:
20575 return NULL;
20576 }
20577
20578
20579 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20580 PyObject *resultobj;
20581 wxDateTime *arg1 = (wxDateTime *) 0 ;
20582 wxDateTime::WeekDay arg2 ;
20583 wxDateTime result;
20584 PyObject * obj0 = 0 ;
20585 PyObject * obj1 = 0 ;
20586 char *kwnames[] = {
20587 (char *) "self",(char *) "weekday", NULL
20588 };
20589
20590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20592 if (SWIG_arg_fail(1)) SWIG_fail;
20593 {
20594 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20595 if (SWIG_arg_fail(2)) SWIG_fail;
20596 }
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20600
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 {
20605 wxDateTime * resultptr;
20606 resultptr = new wxDateTime((wxDateTime &)(result));
20607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20608 }
20609 return resultobj;
20610 fail:
20611 return NULL;
20612 }
20613
20614
20615 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20616 PyObject *resultobj;
20617 wxDateTime *arg1 = (wxDateTime *) 0 ;
20618 wxDateTime::WeekDay arg2 ;
20619 wxDateTime *result;
20620 PyObject * obj0 = 0 ;
20621 PyObject * obj1 = 0 ;
20622 char *kwnames[] = {
20623 (char *) "self",(char *) "weekday", NULL
20624 };
20625
20626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20628 if (SWIG_arg_fail(1)) SWIG_fail;
20629 {
20630 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20631 if (SWIG_arg_fail(2)) SWIG_fail;
20632 }
20633 {
20634 PyThreadState* __tstate = wxPyBeginAllowThreads();
20635 {
20636 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20637 result = (wxDateTime *) &_result_ref;
20638 }
20639
20640 wxPyEndAllowThreads(__tstate);
20641 if (PyErr_Occurred()) SWIG_fail;
20642 }
20643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20644 return resultobj;
20645 fail:
20646 return NULL;
20647 }
20648
20649
20650 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20651 PyObject *resultobj;
20652 wxDateTime *arg1 = (wxDateTime *) 0 ;
20653 wxDateTime::WeekDay arg2 ;
20654 wxDateTime result;
20655 PyObject * obj0 = 0 ;
20656 PyObject * obj1 = 0 ;
20657 char *kwnames[] = {
20658 (char *) "self",(char *) "weekday", NULL
20659 };
20660
20661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20663 if (SWIG_arg_fail(1)) SWIG_fail;
20664 {
20665 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20666 if (SWIG_arg_fail(2)) SWIG_fail;
20667 }
20668 {
20669 PyThreadState* __tstate = wxPyBeginAllowThreads();
20670 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20671
20672 wxPyEndAllowThreads(__tstate);
20673 if (PyErr_Occurred()) SWIG_fail;
20674 }
20675 {
20676 wxDateTime * resultptr;
20677 resultptr = new wxDateTime((wxDateTime &)(result));
20678 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20679 }
20680 return resultobj;
20681 fail:
20682 return NULL;
20683 }
20684
20685
20686 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20687 PyObject *resultobj;
20688 wxDateTime *arg1 = (wxDateTime *) 0 ;
20689 wxDateTime::WeekDay arg2 ;
20690 int arg3 = (int) 1 ;
20691 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20692 int arg5 = (int) wxDateTime::Inv_Year ;
20693 bool result;
20694 PyObject * obj0 = 0 ;
20695 PyObject * obj1 = 0 ;
20696 PyObject * obj2 = 0 ;
20697 PyObject * obj3 = 0 ;
20698 PyObject * obj4 = 0 ;
20699 char *kwnames[] = {
20700 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20701 };
20702
20703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20705 if (SWIG_arg_fail(1)) SWIG_fail;
20706 {
20707 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20708 if (SWIG_arg_fail(2)) SWIG_fail;
20709 }
20710 if (obj2) {
20711 {
20712 arg3 = (int)(SWIG_As_int(obj2));
20713 if (SWIG_arg_fail(3)) SWIG_fail;
20714 }
20715 }
20716 if (obj3) {
20717 {
20718 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20719 if (SWIG_arg_fail(4)) SWIG_fail;
20720 }
20721 }
20722 if (obj4) {
20723 {
20724 arg5 = (int)(SWIG_As_int(obj4));
20725 if (SWIG_arg_fail(5)) SWIG_fail;
20726 }
20727 }
20728 {
20729 PyThreadState* __tstate = wxPyBeginAllowThreads();
20730 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20731
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 {
20736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20737 }
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20745 PyObject *resultobj;
20746 wxDateTime *arg1 = (wxDateTime *) 0 ;
20747 wxDateTime::WeekDay arg2 ;
20748 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20749 int arg4 = (int) wxDateTime::Inv_Year ;
20750 bool result;
20751 PyObject * obj0 = 0 ;
20752 PyObject * obj1 = 0 ;
20753 PyObject * obj2 = 0 ;
20754 PyObject * obj3 = 0 ;
20755 char *kwnames[] = {
20756 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20757 };
20758
20759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20761 if (SWIG_arg_fail(1)) SWIG_fail;
20762 {
20763 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20764 if (SWIG_arg_fail(2)) SWIG_fail;
20765 }
20766 if (obj2) {
20767 {
20768 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20769 if (SWIG_arg_fail(3)) SWIG_fail;
20770 }
20771 }
20772 if (obj3) {
20773 {
20774 arg4 = (int)(SWIG_As_int(obj3));
20775 if (SWIG_arg_fail(4)) SWIG_fail;
20776 }
20777 }
20778 {
20779 PyThreadState* __tstate = wxPyBeginAllowThreads();
20780 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20781
20782 wxPyEndAllowThreads(__tstate);
20783 if (PyErr_Occurred()) SWIG_fail;
20784 }
20785 {
20786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20787 }
20788 return resultobj;
20789 fail:
20790 return NULL;
20791 }
20792
20793
20794 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20795 PyObject *resultobj;
20796 wxDateTime *arg1 = (wxDateTime *) 0 ;
20797 wxDateTime::WeekDay arg2 ;
20798 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20799 int arg4 = (int) wxDateTime::Inv_Year ;
20800 wxDateTime result;
20801 PyObject * obj0 = 0 ;
20802 PyObject * obj1 = 0 ;
20803 PyObject * obj2 = 0 ;
20804 PyObject * obj3 = 0 ;
20805 char *kwnames[] = {
20806 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20807 };
20808
20809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20811 if (SWIG_arg_fail(1)) SWIG_fail;
20812 {
20813 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20814 if (SWIG_arg_fail(2)) SWIG_fail;
20815 }
20816 if (obj2) {
20817 {
20818 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20819 if (SWIG_arg_fail(3)) SWIG_fail;
20820 }
20821 }
20822 if (obj3) {
20823 {
20824 arg4 = (int)(SWIG_As_int(obj3));
20825 if (SWIG_arg_fail(4)) SWIG_fail;
20826 }
20827 }
20828 {
20829 PyThreadState* __tstate = wxPyBeginAllowThreads();
20830 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20831
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 {
20836 wxDateTime * resultptr;
20837 resultptr = new wxDateTime((wxDateTime &)(result));
20838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20839 }
20840 return resultobj;
20841 fail:
20842 return NULL;
20843 }
20844
20845
20846 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20847 PyObject *resultobj;
20848 wxDateTime *arg1 = (wxDateTime *) 0 ;
20849 int arg2 ;
20850 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20851 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20852 bool result;
20853 PyObject * obj0 = 0 ;
20854 PyObject * obj1 = 0 ;
20855 PyObject * obj2 = 0 ;
20856 PyObject * obj3 = 0 ;
20857 char *kwnames[] = {
20858 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20859 };
20860
20861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20863 if (SWIG_arg_fail(1)) SWIG_fail;
20864 {
20865 arg2 = (int)(SWIG_As_int(obj1));
20866 if (SWIG_arg_fail(2)) SWIG_fail;
20867 }
20868 if (obj2) {
20869 {
20870 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20871 if (SWIG_arg_fail(3)) SWIG_fail;
20872 }
20873 }
20874 if (obj3) {
20875 {
20876 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20877 if (SWIG_arg_fail(4)) SWIG_fail;
20878 }
20879 }
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20883
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 {
20888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20889 }
20890 return resultobj;
20891 fail:
20892 return NULL;
20893 }
20894
20895
20896 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20897 PyObject *resultobj;
20898 wxDateTime *arg1 = (wxDateTime *) 0 ;
20899 int arg2 ;
20900 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20901 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20902 wxDateTime result;
20903 PyObject * obj0 = 0 ;
20904 PyObject * obj1 = 0 ;
20905 PyObject * obj2 = 0 ;
20906 PyObject * obj3 = 0 ;
20907 char *kwnames[] = {
20908 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20909 };
20910
20911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20913 if (SWIG_arg_fail(1)) SWIG_fail;
20914 {
20915 arg2 = (int)(SWIG_As_int(obj1));
20916 if (SWIG_arg_fail(2)) SWIG_fail;
20917 }
20918 if (obj2) {
20919 {
20920 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20921 if (SWIG_arg_fail(3)) SWIG_fail;
20922 }
20923 }
20924 if (obj3) {
20925 {
20926 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20927 if (SWIG_arg_fail(4)) SWIG_fail;
20928 }
20929 }
20930 {
20931 PyThreadState* __tstate = wxPyBeginAllowThreads();
20932 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20933
20934 wxPyEndAllowThreads(__tstate);
20935 if (PyErr_Occurred()) SWIG_fail;
20936 }
20937 {
20938 wxDateTime * resultptr;
20939 resultptr = new wxDateTime((wxDateTime &)(result));
20940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20941 }
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20949 PyObject *resultobj;
20950 int arg1 ;
20951 int arg2 ;
20952 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20953 wxDateTime result;
20954 PyObject * obj0 = 0 ;
20955 PyObject * obj1 = 0 ;
20956 PyObject * obj2 = 0 ;
20957 char *kwnames[] = {
20958 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20959 };
20960
20961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20962 {
20963 arg1 = (int)(SWIG_As_int(obj0));
20964 if (SWIG_arg_fail(1)) SWIG_fail;
20965 }
20966 {
20967 arg2 = (int)(SWIG_As_int(obj1));
20968 if (SWIG_arg_fail(2)) SWIG_fail;
20969 }
20970 if (obj2) {
20971 {
20972 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20973 if (SWIG_arg_fail(3)) SWIG_fail;
20974 }
20975 }
20976 {
20977 PyThreadState* __tstate = wxPyBeginAllowThreads();
20978 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20979
20980 wxPyEndAllowThreads(__tstate);
20981 if (PyErr_Occurred()) SWIG_fail;
20982 }
20983 {
20984 wxDateTime * resultptr;
20985 resultptr = new wxDateTime((wxDateTime &)(result));
20986 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20987 }
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj;
20996 wxDateTime *arg1 = (wxDateTime *) 0 ;
20997 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20998 int arg3 = (int) wxDateTime::Inv_Year ;
20999 wxDateTime *result;
21000 PyObject * obj0 = 0 ;
21001 PyObject * obj1 = 0 ;
21002 PyObject * obj2 = 0 ;
21003 char *kwnames[] = {
21004 (char *) "self",(char *) "month",(char *) "year", NULL
21005 };
21006
21007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21009 if (SWIG_arg_fail(1)) SWIG_fail;
21010 if (obj1) {
21011 {
21012 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21013 if (SWIG_arg_fail(2)) SWIG_fail;
21014 }
21015 }
21016 if (obj2) {
21017 {
21018 arg3 = (int)(SWIG_As_int(obj2));
21019 if (SWIG_arg_fail(3)) SWIG_fail;
21020 }
21021 }
21022 {
21023 PyThreadState* __tstate = wxPyBeginAllowThreads();
21024 {
21025 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21026 result = (wxDateTime *) &_result_ref;
21027 }
21028
21029 wxPyEndAllowThreads(__tstate);
21030 if (PyErr_Occurred()) SWIG_fail;
21031 }
21032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21033 return resultobj;
21034 fail:
21035 return NULL;
21036 }
21037
21038
21039 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21040 PyObject *resultobj;
21041 wxDateTime *arg1 = (wxDateTime *) 0 ;
21042 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21043 int arg3 = (int) wxDateTime::Inv_Year ;
21044 wxDateTime result;
21045 PyObject * obj0 = 0 ;
21046 PyObject * obj1 = 0 ;
21047 PyObject * obj2 = 0 ;
21048 char *kwnames[] = {
21049 (char *) "self",(char *) "month",(char *) "year", NULL
21050 };
21051
21052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21054 if (SWIG_arg_fail(1)) SWIG_fail;
21055 if (obj1) {
21056 {
21057 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21058 if (SWIG_arg_fail(2)) SWIG_fail;
21059 }
21060 }
21061 if (obj2) {
21062 {
21063 arg3 = (int)(SWIG_As_int(obj2));
21064 if (SWIG_arg_fail(3)) SWIG_fail;
21065 }
21066 }
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21070
21071 wxPyEndAllowThreads(__tstate);
21072 if (PyErr_Occurred()) SWIG_fail;
21073 }
21074 {
21075 wxDateTime * resultptr;
21076 resultptr = new wxDateTime((wxDateTime &)(result));
21077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21078 }
21079 return resultobj;
21080 fail:
21081 return NULL;
21082 }
21083
21084
21085 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21086 PyObject *resultobj;
21087 wxDateTime *arg1 = (wxDateTime *) 0 ;
21088 int arg2 ;
21089 wxDateTime *result;
21090 PyObject * obj0 = 0 ;
21091 PyObject * obj1 = 0 ;
21092 char *kwnames[] = {
21093 (char *) "self",(char *) "yday", NULL
21094 };
21095
21096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21098 if (SWIG_arg_fail(1)) SWIG_fail;
21099 {
21100 arg2 = (int)(SWIG_As_int(obj1));
21101 if (SWIG_arg_fail(2)) SWIG_fail;
21102 }
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 {
21106 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21107 result = (wxDateTime *) &_result_ref;
21108 }
21109
21110 wxPyEndAllowThreads(__tstate);
21111 if (PyErr_Occurred()) SWIG_fail;
21112 }
21113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21114 return resultobj;
21115 fail:
21116 return NULL;
21117 }
21118
21119
21120 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21121 PyObject *resultobj;
21122 wxDateTime *arg1 = (wxDateTime *) 0 ;
21123 int arg2 ;
21124 wxDateTime result;
21125 PyObject * obj0 = 0 ;
21126 PyObject * obj1 = 0 ;
21127 char *kwnames[] = {
21128 (char *) "self",(char *) "yday", NULL
21129 };
21130
21131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21133 if (SWIG_arg_fail(1)) SWIG_fail;
21134 {
21135 arg2 = (int)(SWIG_As_int(obj1));
21136 if (SWIG_arg_fail(2)) SWIG_fail;
21137 }
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 result = (arg1)->GetYearDay(arg2);
21141
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 {
21146 wxDateTime * resultptr;
21147 resultptr = new wxDateTime((wxDateTime &)(result));
21148 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21149 }
21150 return resultobj;
21151 fail:
21152 return NULL;
21153 }
21154
21155
21156 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21157 PyObject *resultobj;
21158 wxDateTime *arg1 = (wxDateTime *) 0 ;
21159 double result;
21160 PyObject * obj0 = 0 ;
21161 char *kwnames[] = {
21162 (char *) "self", NULL
21163 };
21164
21165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21167 if (SWIG_arg_fail(1)) SWIG_fail;
21168 {
21169 PyThreadState* __tstate = wxPyBeginAllowThreads();
21170 result = (double)(arg1)->GetJulianDayNumber();
21171
21172 wxPyEndAllowThreads(__tstate);
21173 if (PyErr_Occurred()) SWIG_fail;
21174 }
21175 {
21176 resultobj = SWIG_From_double((double)(result));
21177 }
21178 return resultobj;
21179 fail:
21180 return NULL;
21181 }
21182
21183
21184 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21185 PyObject *resultobj;
21186 wxDateTime *arg1 = (wxDateTime *) 0 ;
21187 double result;
21188 PyObject * obj0 = 0 ;
21189 char *kwnames[] = {
21190 (char *) "self", NULL
21191 };
21192
21193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21195 if (SWIG_arg_fail(1)) SWIG_fail;
21196 {
21197 PyThreadState* __tstate = wxPyBeginAllowThreads();
21198 result = (double)(arg1)->GetJDN();
21199
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 {
21204 resultobj = SWIG_From_double((double)(result));
21205 }
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21213 PyObject *resultobj;
21214 wxDateTime *arg1 = (wxDateTime *) 0 ;
21215 double result;
21216 PyObject * obj0 = 0 ;
21217 char *kwnames[] = {
21218 (char *) "self", NULL
21219 };
21220
21221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21223 if (SWIG_arg_fail(1)) SWIG_fail;
21224 {
21225 PyThreadState* __tstate = wxPyBeginAllowThreads();
21226 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21227
21228 wxPyEndAllowThreads(__tstate);
21229 if (PyErr_Occurred()) SWIG_fail;
21230 }
21231 {
21232 resultobj = SWIG_From_double((double)(result));
21233 }
21234 return resultobj;
21235 fail:
21236 return NULL;
21237 }
21238
21239
21240 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21241 PyObject *resultobj;
21242 wxDateTime *arg1 = (wxDateTime *) 0 ;
21243 double result;
21244 PyObject * obj0 = 0 ;
21245 char *kwnames[] = {
21246 (char *) "self", NULL
21247 };
21248
21249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21251 if (SWIG_arg_fail(1)) SWIG_fail;
21252 {
21253 PyThreadState* __tstate = wxPyBeginAllowThreads();
21254 result = (double)(arg1)->GetMJD();
21255
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 {
21260 resultobj = SWIG_From_double((double)(result));
21261 }
21262 return resultobj;
21263 fail:
21264 return NULL;
21265 }
21266
21267
21268 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21269 PyObject *resultobj;
21270 wxDateTime *arg1 = (wxDateTime *) 0 ;
21271 double result;
21272 PyObject * obj0 = 0 ;
21273 char *kwnames[] = {
21274 (char *) "self", NULL
21275 };
21276
21277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21279 if (SWIG_arg_fail(1)) SWIG_fail;
21280 {
21281 PyThreadState* __tstate = wxPyBeginAllowThreads();
21282 result = (double)(arg1)->GetRataDie();
21283
21284 wxPyEndAllowThreads(__tstate);
21285 if (PyErr_Occurred()) SWIG_fail;
21286 }
21287 {
21288 resultobj = SWIG_From_double((double)(result));
21289 }
21290 return resultobj;
21291 fail:
21292 return NULL;
21293 }
21294
21295
21296 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21297 PyObject *resultobj;
21298 wxDateTime *arg1 = (wxDateTime *) 0 ;
21299 wxDateTime::TimeZone *arg2 = 0 ;
21300 bool arg3 = (bool) false ;
21301 wxDateTime result;
21302 bool temp2 = false ;
21303 PyObject * obj0 = 0 ;
21304 PyObject * obj1 = 0 ;
21305 PyObject * obj2 = 0 ;
21306 char *kwnames[] = {
21307 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21308 };
21309
21310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21312 if (SWIG_arg_fail(1)) SWIG_fail;
21313 {
21314 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21315 temp2 = true;
21316 }
21317 if (obj2) {
21318 {
21319 arg3 = (bool)(SWIG_As_bool(obj2));
21320 if (SWIG_arg_fail(3)) SWIG_fail;
21321 }
21322 }
21323 {
21324 PyThreadState* __tstate = wxPyBeginAllowThreads();
21325 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21326
21327 wxPyEndAllowThreads(__tstate);
21328 if (PyErr_Occurred()) SWIG_fail;
21329 }
21330 {
21331 wxDateTime * resultptr;
21332 resultptr = new wxDateTime((wxDateTime &)(result));
21333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21334 }
21335 {
21336 if (temp2) delete arg2;
21337 }
21338 return resultobj;
21339 fail:
21340 {
21341 if (temp2) delete arg2;
21342 }
21343 return NULL;
21344 }
21345
21346
21347 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21348 PyObject *resultobj;
21349 wxDateTime *arg1 = (wxDateTime *) 0 ;
21350 wxDateTime::TimeZone *arg2 = 0 ;
21351 bool arg3 = (bool) false ;
21352 wxDateTime *result;
21353 bool temp2 = false ;
21354 PyObject * obj0 = 0 ;
21355 PyObject * obj1 = 0 ;
21356 PyObject * obj2 = 0 ;
21357 char *kwnames[] = {
21358 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21359 };
21360
21361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21363 if (SWIG_arg_fail(1)) SWIG_fail;
21364 {
21365 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21366 temp2 = true;
21367 }
21368 if (obj2) {
21369 {
21370 arg3 = (bool)(SWIG_As_bool(obj2));
21371 if (SWIG_arg_fail(3)) SWIG_fail;
21372 }
21373 }
21374 {
21375 PyThreadState* __tstate = wxPyBeginAllowThreads();
21376 {
21377 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21378 result = (wxDateTime *) &_result_ref;
21379 }
21380
21381 wxPyEndAllowThreads(__tstate);
21382 if (PyErr_Occurred()) SWIG_fail;
21383 }
21384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21385 {
21386 if (temp2) delete arg2;
21387 }
21388 return resultobj;
21389 fail:
21390 {
21391 if (temp2) delete arg2;
21392 }
21393 return NULL;
21394 }
21395
21396
21397 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21398 PyObject *resultobj;
21399 wxDateTime *arg1 = (wxDateTime *) 0 ;
21400 bool arg2 = (bool) false ;
21401 wxDateTime result;
21402 PyObject * obj0 = 0 ;
21403 PyObject * obj1 = 0 ;
21404 char *kwnames[] = {
21405 (char *) "self",(char *) "noDST", NULL
21406 };
21407
21408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21410 if (SWIG_arg_fail(1)) SWIG_fail;
21411 if (obj1) {
21412 {
21413 arg2 = (bool)(SWIG_As_bool(obj1));
21414 if (SWIG_arg_fail(2)) SWIG_fail;
21415 }
21416 }
21417 {
21418 PyThreadState* __tstate = wxPyBeginAllowThreads();
21419 result = (arg1)->ToGMT(arg2);
21420
21421 wxPyEndAllowThreads(__tstate);
21422 if (PyErr_Occurred()) SWIG_fail;
21423 }
21424 {
21425 wxDateTime * resultptr;
21426 resultptr = new wxDateTime((wxDateTime &)(result));
21427 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21428 }
21429 return resultobj;
21430 fail:
21431 return NULL;
21432 }
21433
21434
21435 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21436 PyObject *resultobj;
21437 wxDateTime *arg1 = (wxDateTime *) 0 ;
21438 bool arg2 = (bool) false ;
21439 wxDateTime *result;
21440 PyObject * obj0 = 0 ;
21441 PyObject * obj1 = 0 ;
21442 char *kwnames[] = {
21443 (char *) "self",(char *) "noDST", NULL
21444 };
21445
21446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21448 if (SWIG_arg_fail(1)) SWIG_fail;
21449 if (obj1) {
21450 {
21451 arg2 = (bool)(SWIG_As_bool(obj1));
21452 if (SWIG_arg_fail(2)) SWIG_fail;
21453 }
21454 }
21455 {
21456 PyThreadState* __tstate = wxPyBeginAllowThreads();
21457 {
21458 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21459 result = (wxDateTime *) &_result_ref;
21460 }
21461
21462 wxPyEndAllowThreads(__tstate);
21463 if (PyErr_Occurred()) SWIG_fail;
21464 }
21465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21466 return resultobj;
21467 fail:
21468 return NULL;
21469 }
21470
21471
21472 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21473 PyObject *resultobj;
21474 wxDateTime *arg1 = (wxDateTime *) 0 ;
21475 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21476 int result;
21477 PyObject * obj0 = 0 ;
21478 PyObject * obj1 = 0 ;
21479 char *kwnames[] = {
21480 (char *) "self",(char *) "country", NULL
21481 };
21482
21483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21485 if (SWIG_arg_fail(1)) SWIG_fail;
21486 if (obj1) {
21487 {
21488 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21489 if (SWIG_arg_fail(2)) SWIG_fail;
21490 }
21491 }
21492 {
21493 PyThreadState* __tstate = wxPyBeginAllowThreads();
21494 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21495
21496 wxPyEndAllowThreads(__tstate);
21497 if (PyErr_Occurred()) SWIG_fail;
21498 }
21499 {
21500 resultobj = SWIG_From_int((int)(result));
21501 }
21502 return resultobj;
21503 fail:
21504 return NULL;
21505 }
21506
21507
21508 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21509 PyObject *resultobj;
21510 wxDateTime *arg1 = (wxDateTime *) 0 ;
21511 bool result;
21512 PyObject * obj0 = 0 ;
21513 char *kwnames[] = {
21514 (char *) "self", NULL
21515 };
21516
21517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21519 if (SWIG_arg_fail(1)) SWIG_fail;
21520 {
21521 PyThreadState* __tstate = wxPyBeginAllowThreads();
21522 result = (bool)((wxDateTime const *)arg1)->IsValid();
21523
21524 wxPyEndAllowThreads(__tstate);
21525 if (PyErr_Occurred()) SWIG_fail;
21526 }
21527 {
21528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21529 }
21530 return resultobj;
21531 fail:
21532 return NULL;
21533 }
21534
21535
21536 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21537 PyObject *resultobj;
21538 wxDateTime *arg1 = (wxDateTime *) 0 ;
21539 time_t result;
21540 PyObject * obj0 = 0 ;
21541 char *kwnames[] = {
21542 (char *) "self", NULL
21543 };
21544
21545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21547 if (SWIG_arg_fail(1)) SWIG_fail;
21548 {
21549 PyThreadState* __tstate = wxPyBeginAllowThreads();
21550 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21551
21552 wxPyEndAllowThreads(__tstate);
21553 if (PyErr_Occurred()) SWIG_fail;
21554 }
21555 {
21556 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21557 }
21558 return resultobj;
21559 fail:
21560 return NULL;
21561 }
21562
21563
21564 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21565 PyObject *resultobj;
21566 wxDateTime *arg1 = (wxDateTime *) 0 ;
21567 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21568 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21569 int result;
21570 bool temp2 = false ;
21571 PyObject * obj0 = 0 ;
21572 PyObject * obj1 = 0 ;
21573 char *kwnames[] = {
21574 (char *) "self",(char *) "tz", NULL
21575 };
21576
21577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21579 if (SWIG_arg_fail(1)) SWIG_fail;
21580 if (obj1) {
21581 {
21582 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21583 temp2 = true;
21584 }
21585 }
21586 {
21587 PyThreadState* __tstate = wxPyBeginAllowThreads();
21588 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21589
21590 wxPyEndAllowThreads(__tstate);
21591 if (PyErr_Occurred()) SWIG_fail;
21592 }
21593 {
21594 resultobj = SWIG_From_int((int)(result));
21595 }
21596 {
21597 if (temp2) delete arg2;
21598 }
21599 return resultobj;
21600 fail:
21601 {
21602 if (temp2) delete arg2;
21603 }
21604 return NULL;
21605 }
21606
21607
21608 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21609 PyObject *resultobj;
21610 wxDateTime *arg1 = (wxDateTime *) 0 ;
21611 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21612 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21613 wxDateTime::Month result;
21614 bool temp2 = false ;
21615 PyObject * obj0 = 0 ;
21616 PyObject * obj1 = 0 ;
21617 char *kwnames[] = {
21618 (char *) "self",(char *) "tz", NULL
21619 };
21620
21621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21623 if (SWIG_arg_fail(1)) SWIG_fail;
21624 if (obj1) {
21625 {
21626 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21627 temp2 = true;
21628 }
21629 }
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21633
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 resultobj = SWIG_From_int((result));
21638 {
21639 if (temp2) delete arg2;
21640 }
21641 return resultobj;
21642 fail:
21643 {
21644 if (temp2) delete arg2;
21645 }
21646 return NULL;
21647 }
21648
21649
21650 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21651 PyObject *resultobj;
21652 wxDateTime *arg1 = (wxDateTime *) 0 ;
21653 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21654 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21655 int result;
21656 bool temp2 = false ;
21657 PyObject * obj0 = 0 ;
21658 PyObject * obj1 = 0 ;
21659 char *kwnames[] = {
21660 (char *) "self",(char *) "tz", NULL
21661 };
21662
21663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21665 if (SWIG_arg_fail(1)) SWIG_fail;
21666 if (obj1) {
21667 {
21668 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21669 temp2 = true;
21670 }
21671 }
21672 {
21673 PyThreadState* __tstate = wxPyBeginAllowThreads();
21674 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21675
21676 wxPyEndAllowThreads(__tstate);
21677 if (PyErr_Occurred()) SWIG_fail;
21678 }
21679 {
21680 resultobj = SWIG_From_int((int)(result));
21681 }
21682 {
21683 if (temp2) delete arg2;
21684 }
21685 return resultobj;
21686 fail:
21687 {
21688 if (temp2) delete arg2;
21689 }
21690 return NULL;
21691 }
21692
21693
21694 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21695 PyObject *resultobj;
21696 wxDateTime *arg1 = (wxDateTime *) 0 ;
21697 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21698 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21699 wxDateTime::WeekDay result;
21700 bool temp2 = false ;
21701 PyObject * obj0 = 0 ;
21702 PyObject * obj1 = 0 ;
21703 char *kwnames[] = {
21704 (char *) "self",(char *) "tz", NULL
21705 };
21706
21707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21709 if (SWIG_arg_fail(1)) SWIG_fail;
21710 if (obj1) {
21711 {
21712 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21713 temp2 = true;
21714 }
21715 }
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 resultobj = SWIG_From_int((result));
21724 {
21725 if (temp2) delete arg2;
21726 }
21727 return resultobj;
21728 fail:
21729 {
21730 if (temp2) delete arg2;
21731 }
21732 return NULL;
21733 }
21734
21735
21736 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj;
21738 wxDateTime *arg1 = (wxDateTime *) 0 ;
21739 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21740 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21741 int result;
21742 bool temp2 = false ;
21743 PyObject * obj0 = 0 ;
21744 PyObject * obj1 = 0 ;
21745 char *kwnames[] = {
21746 (char *) "self",(char *) "tz", NULL
21747 };
21748
21749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21751 if (SWIG_arg_fail(1)) SWIG_fail;
21752 if (obj1) {
21753 {
21754 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21755 temp2 = true;
21756 }
21757 }
21758 {
21759 PyThreadState* __tstate = wxPyBeginAllowThreads();
21760 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21761
21762 wxPyEndAllowThreads(__tstate);
21763 if (PyErr_Occurred()) SWIG_fail;
21764 }
21765 {
21766 resultobj = SWIG_From_int((int)(result));
21767 }
21768 {
21769 if (temp2) delete arg2;
21770 }
21771 return resultobj;
21772 fail:
21773 {
21774 if (temp2) delete arg2;
21775 }
21776 return NULL;
21777 }
21778
21779
21780 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21781 PyObject *resultobj;
21782 wxDateTime *arg1 = (wxDateTime *) 0 ;
21783 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21784 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21785 int result;
21786 bool temp2 = false ;
21787 PyObject * obj0 = 0 ;
21788 PyObject * obj1 = 0 ;
21789 char *kwnames[] = {
21790 (char *) "self",(char *) "tz", NULL
21791 };
21792
21793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21795 if (SWIG_arg_fail(1)) SWIG_fail;
21796 if (obj1) {
21797 {
21798 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21799 temp2 = true;
21800 }
21801 }
21802 {
21803 PyThreadState* __tstate = wxPyBeginAllowThreads();
21804 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21805
21806 wxPyEndAllowThreads(__tstate);
21807 if (PyErr_Occurred()) SWIG_fail;
21808 }
21809 {
21810 resultobj = SWIG_From_int((int)(result));
21811 }
21812 {
21813 if (temp2) delete arg2;
21814 }
21815 return resultobj;
21816 fail:
21817 {
21818 if (temp2) delete arg2;
21819 }
21820 return NULL;
21821 }
21822
21823
21824 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21825 PyObject *resultobj;
21826 wxDateTime *arg1 = (wxDateTime *) 0 ;
21827 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21828 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21829 int result;
21830 bool temp2 = false ;
21831 PyObject * obj0 = 0 ;
21832 PyObject * obj1 = 0 ;
21833 char *kwnames[] = {
21834 (char *) "self",(char *) "tz", NULL
21835 };
21836
21837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21839 if (SWIG_arg_fail(1)) SWIG_fail;
21840 if (obj1) {
21841 {
21842 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21843 temp2 = true;
21844 }
21845 }
21846 {
21847 PyThreadState* __tstate = wxPyBeginAllowThreads();
21848 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21849
21850 wxPyEndAllowThreads(__tstate);
21851 if (PyErr_Occurred()) SWIG_fail;
21852 }
21853 {
21854 resultobj = SWIG_From_int((int)(result));
21855 }
21856 {
21857 if (temp2) delete arg2;
21858 }
21859 return resultobj;
21860 fail:
21861 {
21862 if (temp2) delete arg2;
21863 }
21864 return NULL;
21865 }
21866
21867
21868 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21869 PyObject *resultobj;
21870 wxDateTime *arg1 = (wxDateTime *) 0 ;
21871 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21872 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21873 int result;
21874 bool temp2 = false ;
21875 PyObject * obj0 = 0 ;
21876 PyObject * obj1 = 0 ;
21877 char *kwnames[] = {
21878 (char *) "self",(char *) "tz", NULL
21879 };
21880
21881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21883 if (SWIG_arg_fail(1)) SWIG_fail;
21884 if (obj1) {
21885 {
21886 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21887 temp2 = true;
21888 }
21889 }
21890 {
21891 PyThreadState* __tstate = wxPyBeginAllowThreads();
21892 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21893
21894 wxPyEndAllowThreads(__tstate);
21895 if (PyErr_Occurred()) SWIG_fail;
21896 }
21897 {
21898 resultobj = SWIG_From_int((int)(result));
21899 }
21900 {
21901 if (temp2) delete arg2;
21902 }
21903 return resultobj;
21904 fail:
21905 {
21906 if (temp2) delete arg2;
21907 }
21908 return NULL;
21909 }
21910
21911
21912 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21913 PyObject *resultobj;
21914 wxDateTime *arg1 = (wxDateTime *) 0 ;
21915 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21916 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21917 int result;
21918 bool temp2 = false ;
21919 PyObject * obj0 = 0 ;
21920 PyObject * obj1 = 0 ;
21921 char *kwnames[] = {
21922 (char *) "self",(char *) "tz", NULL
21923 };
21924
21925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21927 if (SWIG_arg_fail(1)) SWIG_fail;
21928 if (obj1) {
21929 {
21930 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21931 temp2 = true;
21932 }
21933 }
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21937
21938 wxPyEndAllowThreads(__tstate);
21939 if (PyErr_Occurred()) SWIG_fail;
21940 }
21941 {
21942 resultobj = SWIG_From_int((int)(result));
21943 }
21944 {
21945 if (temp2) delete arg2;
21946 }
21947 return resultobj;
21948 fail:
21949 {
21950 if (temp2) delete arg2;
21951 }
21952 return NULL;
21953 }
21954
21955
21956 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21957 PyObject *resultobj;
21958 wxDateTime *arg1 = (wxDateTime *) 0 ;
21959 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21960 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21961 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21962 int result;
21963 bool temp3 = false ;
21964 PyObject * obj0 = 0 ;
21965 PyObject * obj1 = 0 ;
21966 PyObject * obj2 = 0 ;
21967 char *kwnames[] = {
21968 (char *) "self",(char *) "flags",(char *) "tz", NULL
21969 };
21970
21971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21973 if (SWIG_arg_fail(1)) SWIG_fail;
21974 if (obj1) {
21975 {
21976 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21977 if (SWIG_arg_fail(2)) SWIG_fail;
21978 }
21979 }
21980 if (obj2) {
21981 {
21982 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21983 temp3 = true;
21984 }
21985 }
21986 {
21987 PyThreadState* __tstate = wxPyBeginAllowThreads();
21988 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21989
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = SWIG_From_int((int)(result));
21995 }
21996 {
21997 if (temp3) delete arg3;
21998 }
21999 return resultobj;
22000 fail:
22001 {
22002 if (temp3) delete arg3;
22003 }
22004 return NULL;
22005 }
22006
22007
22008 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22009 PyObject *resultobj;
22010 wxDateTime *arg1 = (wxDateTime *) 0 ;
22011 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22012 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22013 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22014 int result;
22015 bool temp3 = false ;
22016 PyObject * obj0 = 0 ;
22017 PyObject * obj1 = 0 ;
22018 PyObject * obj2 = 0 ;
22019 char *kwnames[] = {
22020 (char *) "self",(char *) "flags",(char *) "tz", NULL
22021 };
22022
22023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22025 if (SWIG_arg_fail(1)) SWIG_fail;
22026 if (obj1) {
22027 {
22028 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22029 if (SWIG_arg_fail(2)) SWIG_fail;
22030 }
22031 }
22032 if (obj2) {
22033 {
22034 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22035 temp3 = true;
22036 }
22037 }
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22041
22042 wxPyEndAllowThreads(__tstate);
22043 if (PyErr_Occurred()) SWIG_fail;
22044 }
22045 {
22046 resultobj = SWIG_From_int((int)(result));
22047 }
22048 {
22049 if (temp3) delete arg3;
22050 }
22051 return resultobj;
22052 fail:
22053 {
22054 if (temp3) delete arg3;
22055 }
22056 return NULL;
22057 }
22058
22059
22060 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22061 PyObject *resultobj;
22062 wxDateTime *arg1 = (wxDateTime *) 0 ;
22063 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22064 bool result;
22065 PyObject * obj0 = 0 ;
22066 PyObject * obj1 = 0 ;
22067 char *kwnames[] = {
22068 (char *) "self",(char *) "country", NULL
22069 };
22070
22071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22073 if (SWIG_arg_fail(1)) SWIG_fail;
22074 if (obj1) {
22075 {
22076 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22077 if (SWIG_arg_fail(2)) SWIG_fail;
22078 }
22079 }
22080 {
22081 PyThreadState* __tstate = wxPyBeginAllowThreads();
22082 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22083
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 {
22088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22089 }
22090 return resultobj;
22091 fail:
22092 return NULL;
22093 }
22094
22095
22096 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22097 PyObject *resultobj;
22098 wxDateTime *arg1 = (wxDateTime *) 0 ;
22099 wxDateTime *arg2 = 0 ;
22100 bool result;
22101 PyObject * obj0 = 0 ;
22102 PyObject * obj1 = 0 ;
22103 char *kwnames[] = {
22104 (char *) "self",(char *) "datetime", NULL
22105 };
22106
22107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22109 if (SWIG_arg_fail(1)) SWIG_fail;
22110 {
22111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22112 if (SWIG_arg_fail(2)) SWIG_fail;
22113 if (arg2 == NULL) {
22114 SWIG_null_ref("wxDateTime");
22115 }
22116 if (SWIG_arg_fail(2)) SWIG_fail;
22117 }
22118 {
22119 PyThreadState* __tstate = wxPyBeginAllowThreads();
22120 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22121
22122 wxPyEndAllowThreads(__tstate);
22123 if (PyErr_Occurred()) SWIG_fail;
22124 }
22125 {
22126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22127 }
22128 return resultobj;
22129 fail:
22130 return NULL;
22131 }
22132
22133
22134 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22135 PyObject *resultobj;
22136 wxDateTime *arg1 = (wxDateTime *) 0 ;
22137 wxDateTime *arg2 = 0 ;
22138 bool result;
22139 PyObject * obj0 = 0 ;
22140 PyObject * obj1 = 0 ;
22141 char *kwnames[] = {
22142 (char *) "self",(char *) "datetime", NULL
22143 };
22144
22145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22147 if (SWIG_arg_fail(1)) SWIG_fail;
22148 {
22149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 if (arg2 == NULL) {
22152 SWIG_null_ref("wxDateTime");
22153 }
22154 if (SWIG_arg_fail(2)) SWIG_fail;
22155 }
22156 {
22157 PyThreadState* __tstate = wxPyBeginAllowThreads();
22158 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22159
22160 wxPyEndAllowThreads(__tstate);
22161 if (PyErr_Occurred()) SWIG_fail;
22162 }
22163 {
22164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22165 }
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22173 PyObject *resultobj;
22174 wxDateTime *arg1 = (wxDateTime *) 0 ;
22175 wxDateTime *arg2 = 0 ;
22176 bool result;
22177 PyObject * obj0 = 0 ;
22178 PyObject * obj1 = 0 ;
22179 char *kwnames[] = {
22180 (char *) "self",(char *) "datetime", NULL
22181 };
22182
22183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22185 if (SWIG_arg_fail(1)) SWIG_fail;
22186 {
22187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22188 if (SWIG_arg_fail(2)) SWIG_fail;
22189 if (arg2 == NULL) {
22190 SWIG_null_ref("wxDateTime");
22191 }
22192 if (SWIG_arg_fail(2)) SWIG_fail;
22193 }
22194 {
22195 PyThreadState* __tstate = wxPyBeginAllowThreads();
22196 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22197
22198 wxPyEndAllowThreads(__tstate);
22199 if (PyErr_Occurred()) SWIG_fail;
22200 }
22201 {
22202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22203 }
22204 return resultobj;
22205 fail:
22206 return NULL;
22207 }
22208
22209
22210 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22211 PyObject *resultobj;
22212 wxDateTime *arg1 = (wxDateTime *) 0 ;
22213 wxDateTime *arg2 = 0 ;
22214 wxDateTime *arg3 = 0 ;
22215 bool result;
22216 PyObject * obj0 = 0 ;
22217 PyObject * obj1 = 0 ;
22218 PyObject * obj2 = 0 ;
22219 char *kwnames[] = {
22220 (char *) "self",(char *) "t1",(char *) "t2", NULL
22221 };
22222
22223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22225 if (SWIG_arg_fail(1)) SWIG_fail;
22226 {
22227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22228 if (SWIG_arg_fail(2)) SWIG_fail;
22229 if (arg2 == NULL) {
22230 SWIG_null_ref("wxDateTime");
22231 }
22232 if (SWIG_arg_fail(2)) SWIG_fail;
22233 }
22234 {
22235 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22236 if (SWIG_arg_fail(3)) SWIG_fail;
22237 if (arg3 == NULL) {
22238 SWIG_null_ref("wxDateTime");
22239 }
22240 if (SWIG_arg_fail(3)) SWIG_fail;
22241 }
22242 {
22243 PyThreadState* __tstate = wxPyBeginAllowThreads();
22244 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22245
22246 wxPyEndAllowThreads(__tstate);
22247 if (PyErr_Occurred()) SWIG_fail;
22248 }
22249 {
22250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22251 }
22252 return resultobj;
22253 fail:
22254 return NULL;
22255 }
22256
22257
22258 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22259 PyObject *resultobj;
22260 wxDateTime *arg1 = (wxDateTime *) 0 ;
22261 wxDateTime *arg2 = 0 ;
22262 wxDateTime *arg3 = 0 ;
22263 bool result;
22264 PyObject * obj0 = 0 ;
22265 PyObject * obj1 = 0 ;
22266 PyObject * obj2 = 0 ;
22267 char *kwnames[] = {
22268 (char *) "self",(char *) "t1",(char *) "t2", NULL
22269 };
22270
22271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22273 if (SWIG_arg_fail(1)) SWIG_fail;
22274 {
22275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22276 if (SWIG_arg_fail(2)) SWIG_fail;
22277 if (arg2 == NULL) {
22278 SWIG_null_ref("wxDateTime");
22279 }
22280 if (SWIG_arg_fail(2)) SWIG_fail;
22281 }
22282 {
22283 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22284 if (SWIG_arg_fail(3)) SWIG_fail;
22285 if (arg3 == NULL) {
22286 SWIG_null_ref("wxDateTime");
22287 }
22288 if (SWIG_arg_fail(3)) SWIG_fail;
22289 }
22290 {
22291 PyThreadState* __tstate = wxPyBeginAllowThreads();
22292 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22293
22294 wxPyEndAllowThreads(__tstate);
22295 if (PyErr_Occurred()) SWIG_fail;
22296 }
22297 {
22298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22299 }
22300 return resultobj;
22301 fail:
22302 return NULL;
22303 }
22304
22305
22306 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22307 PyObject *resultobj;
22308 wxDateTime *arg1 = (wxDateTime *) 0 ;
22309 wxDateTime *arg2 = 0 ;
22310 bool result;
22311 PyObject * obj0 = 0 ;
22312 PyObject * obj1 = 0 ;
22313 char *kwnames[] = {
22314 (char *) "self",(char *) "dt", NULL
22315 };
22316
22317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22319 if (SWIG_arg_fail(1)) SWIG_fail;
22320 {
22321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22322 if (SWIG_arg_fail(2)) SWIG_fail;
22323 if (arg2 == NULL) {
22324 SWIG_null_ref("wxDateTime");
22325 }
22326 if (SWIG_arg_fail(2)) SWIG_fail;
22327 }
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22331
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 {
22336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22337 }
22338 return resultobj;
22339 fail:
22340 return NULL;
22341 }
22342
22343
22344 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22345 PyObject *resultobj;
22346 wxDateTime *arg1 = (wxDateTime *) 0 ;
22347 wxDateTime *arg2 = 0 ;
22348 bool result;
22349 PyObject * obj0 = 0 ;
22350 PyObject * obj1 = 0 ;
22351 char *kwnames[] = {
22352 (char *) "self",(char *) "dt", NULL
22353 };
22354
22355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22357 if (SWIG_arg_fail(1)) SWIG_fail;
22358 {
22359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22360 if (SWIG_arg_fail(2)) SWIG_fail;
22361 if (arg2 == NULL) {
22362 SWIG_null_ref("wxDateTime");
22363 }
22364 if (SWIG_arg_fail(2)) SWIG_fail;
22365 }
22366 {
22367 PyThreadState* __tstate = wxPyBeginAllowThreads();
22368 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22369
22370 wxPyEndAllowThreads(__tstate);
22371 if (PyErr_Occurred()) SWIG_fail;
22372 }
22373 {
22374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22375 }
22376 return resultobj;
22377 fail:
22378 return NULL;
22379 }
22380
22381
22382 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22383 PyObject *resultobj;
22384 wxDateTime *arg1 = (wxDateTime *) 0 ;
22385 wxDateTime *arg2 = 0 ;
22386 wxTimeSpan *arg3 = 0 ;
22387 bool result;
22388 PyObject * obj0 = 0 ;
22389 PyObject * obj1 = 0 ;
22390 PyObject * obj2 = 0 ;
22391 char *kwnames[] = {
22392 (char *) "self",(char *) "dt",(char *) "ts", NULL
22393 };
22394
22395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22397 if (SWIG_arg_fail(1)) SWIG_fail;
22398 {
22399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22400 if (SWIG_arg_fail(2)) SWIG_fail;
22401 if (arg2 == NULL) {
22402 SWIG_null_ref("wxDateTime");
22403 }
22404 if (SWIG_arg_fail(2)) SWIG_fail;
22405 }
22406 {
22407 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22408 if (SWIG_arg_fail(3)) SWIG_fail;
22409 if (arg3 == NULL) {
22410 SWIG_null_ref("wxTimeSpan");
22411 }
22412 if (SWIG_arg_fail(3)) SWIG_fail;
22413 }
22414 {
22415 PyThreadState* __tstate = wxPyBeginAllowThreads();
22416 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22417
22418 wxPyEndAllowThreads(__tstate);
22419 if (PyErr_Occurred()) SWIG_fail;
22420 }
22421 {
22422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22423 }
22424 return resultobj;
22425 fail:
22426 return NULL;
22427 }
22428
22429
22430 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22431 PyObject *resultobj;
22432 wxDateTime *arg1 = (wxDateTime *) 0 ;
22433 wxTimeSpan *arg2 = 0 ;
22434 wxDateTime *result;
22435 PyObject * obj0 = 0 ;
22436 PyObject * obj1 = 0 ;
22437 char *kwnames[] = {
22438 (char *) "self",(char *) "diff", NULL
22439 };
22440
22441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22443 if (SWIG_arg_fail(1)) SWIG_fail;
22444 {
22445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22446 if (SWIG_arg_fail(2)) SWIG_fail;
22447 if (arg2 == NULL) {
22448 SWIG_null_ref("wxTimeSpan");
22449 }
22450 if (SWIG_arg_fail(2)) SWIG_fail;
22451 }
22452 {
22453 PyThreadState* __tstate = wxPyBeginAllowThreads();
22454 {
22455 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22456 result = (wxDateTime *) &_result_ref;
22457 }
22458
22459 wxPyEndAllowThreads(__tstate);
22460 if (PyErr_Occurred()) SWIG_fail;
22461 }
22462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22463 return resultobj;
22464 fail:
22465 return NULL;
22466 }
22467
22468
22469 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22470 PyObject *resultobj;
22471 wxDateTime *arg1 = (wxDateTime *) 0 ;
22472 wxDateSpan *arg2 = 0 ;
22473 wxDateTime *result;
22474 PyObject * obj0 = 0 ;
22475 PyObject * obj1 = 0 ;
22476 char *kwnames[] = {
22477 (char *) "self",(char *) "diff", NULL
22478 };
22479
22480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22482 if (SWIG_arg_fail(1)) SWIG_fail;
22483 {
22484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22485 if (SWIG_arg_fail(2)) SWIG_fail;
22486 if (arg2 == NULL) {
22487 SWIG_null_ref("wxDateSpan");
22488 }
22489 if (SWIG_arg_fail(2)) SWIG_fail;
22490 }
22491 {
22492 PyThreadState* __tstate = wxPyBeginAllowThreads();
22493 {
22494 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22495 result = (wxDateTime *) &_result_ref;
22496 }
22497
22498 wxPyEndAllowThreads(__tstate);
22499 if (PyErr_Occurred()) SWIG_fail;
22500 }
22501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22502 return resultobj;
22503 fail:
22504 return NULL;
22505 }
22506
22507
22508 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22509 PyObject *resultobj;
22510 wxDateTime *arg1 = (wxDateTime *) 0 ;
22511 wxTimeSpan *arg2 = 0 ;
22512 wxDateTime *result;
22513 PyObject * obj0 = 0 ;
22514 PyObject * obj1 = 0 ;
22515 char *kwnames[] = {
22516 (char *) "self",(char *) "diff", NULL
22517 };
22518
22519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22521 if (SWIG_arg_fail(1)) SWIG_fail;
22522 {
22523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22524 if (SWIG_arg_fail(2)) SWIG_fail;
22525 if (arg2 == NULL) {
22526 SWIG_null_ref("wxTimeSpan");
22527 }
22528 if (SWIG_arg_fail(2)) SWIG_fail;
22529 }
22530 {
22531 PyThreadState* __tstate = wxPyBeginAllowThreads();
22532 {
22533 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22534 result = (wxDateTime *) &_result_ref;
22535 }
22536
22537 wxPyEndAllowThreads(__tstate);
22538 if (PyErr_Occurred()) SWIG_fail;
22539 }
22540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22541 return resultobj;
22542 fail:
22543 return NULL;
22544 }
22545
22546
22547 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22548 PyObject *resultobj;
22549 wxDateTime *arg1 = (wxDateTime *) 0 ;
22550 wxDateSpan *arg2 = 0 ;
22551 wxDateTime *result;
22552 PyObject * obj0 = 0 ;
22553 PyObject * obj1 = 0 ;
22554 char *kwnames[] = {
22555 (char *) "self",(char *) "diff", NULL
22556 };
22557
22558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22560 if (SWIG_arg_fail(1)) SWIG_fail;
22561 {
22562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22563 if (SWIG_arg_fail(2)) SWIG_fail;
22564 if (arg2 == NULL) {
22565 SWIG_null_ref("wxDateSpan");
22566 }
22567 if (SWIG_arg_fail(2)) SWIG_fail;
22568 }
22569 {
22570 PyThreadState* __tstate = wxPyBeginAllowThreads();
22571 {
22572 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22573 result = (wxDateTime *) &_result_ref;
22574 }
22575
22576 wxPyEndAllowThreads(__tstate);
22577 if (PyErr_Occurred()) SWIG_fail;
22578 }
22579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22580 return resultobj;
22581 fail:
22582 return NULL;
22583 }
22584
22585
22586 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22587 PyObject *resultobj;
22588 wxDateTime *arg1 = (wxDateTime *) 0 ;
22589 wxDateTime *arg2 = 0 ;
22590 wxTimeSpan result;
22591 PyObject * obj0 = 0 ;
22592 PyObject * obj1 = 0 ;
22593 char *kwnames[] = {
22594 (char *) "self",(char *) "dt", NULL
22595 };
22596
22597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22599 if (SWIG_arg_fail(1)) SWIG_fail;
22600 {
22601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22602 if (SWIG_arg_fail(2)) SWIG_fail;
22603 if (arg2 == NULL) {
22604 SWIG_null_ref("wxDateTime");
22605 }
22606 if (SWIG_arg_fail(2)) SWIG_fail;
22607 }
22608 {
22609 PyThreadState* __tstate = wxPyBeginAllowThreads();
22610 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22611
22612 wxPyEndAllowThreads(__tstate);
22613 if (PyErr_Occurred()) SWIG_fail;
22614 }
22615 {
22616 wxTimeSpan * resultptr;
22617 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22619 }
22620 return resultobj;
22621 fail:
22622 return NULL;
22623 }
22624
22625
22626 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22627 PyObject *resultobj;
22628 wxDateTime *arg1 = (wxDateTime *) 0 ;
22629 wxTimeSpan *arg2 = 0 ;
22630 wxDateTime *result;
22631 PyObject * obj0 = 0 ;
22632 PyObject * obj1 = 0 ;
22633
22634 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22636 if (SWIG_arg_fail(1)) SWIG_fail;
22637 {
22638 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22639 if (SWIG_arg_fail(2)) SWIG_fail;
22640 if (arg2 == NULL) {
22641 SWIG_null_ref("wxTimeSpan");
22642 }
22643 if (SWIG_arg_fail(2)) SWIG_fail;
22644 }
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 {
22648 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22649 result = (wxDateTime *) &_result_ref;
22650 }
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22663 PyObject *resultobj;
22664 wxDateTime *arg1 = (wxDateTime *) 0 ;
22665 wxDateSpan *arg2 = 0 ;
22666 wxDateTime *result;
22667 PyObject * obj0 = 0 ;
22668 PyObject * obj1 = 0 ;
22669
22670 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22672 if (SWIG_arg_fail(1)) SWIG_fail;
22673 {
22674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22675 if (SWIG_arg_fail(2)) SWIG_fail;
22676 if (arg2 == NULL) {
22677 SWIG_null_ref("wxDateSpan");
22678 }
22679 if (SWIG_arg_fail(2)) SWIG_fail;
22680 }
22681 {
22682 PyThreadState* __tstate = wxPyBeginAllowThreads();
22683 {
22684 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22685 result = (wxDateTime *) &_result_ref;
22686 }
22687
22688 wxPyEndAllowThreads(__tstate);
22689 if (PyErr_Occurred()) SWIG_fail;
22690 }
22691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22692 return resultobj;
22693 fail:
22694 return NULL;
22695 }
22696
22697
22698 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22699 int argc;
22700 PyObject *argv[3];
22701 int ii;
22702
22703 argc = PyObject_Length(args);
22704 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22705 argv[ii] = PyTuple_GetItem(args,ii);
22706 }
22707 if (argc == 2) {
22708 int _v;
22709 {
22710 void *ptr;
22711 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22712 _v = 0;
22713 PyErr_Clear();
22714 } else {
22715 _v = 1;
22716 }
22717 }
22718 if (_v) {
22719 {
22720 void *ptr = 0;
22721 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22722 _v = 0;
22723 PyErr_Clear();
22724 } else {
22725 _v = (ptr != 0);
22726 }
22727 }
22728 if (_v) {
22729 return _wrap_DateTime___iadd____SWIG_0(self,args);
22730 }
22731 }
22732 }
22733 if (argc == 2) {
22734 int _v;
22735 {
22736 void *ptr;
22737 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22738 _v = 0;
22739 PyErr_Clear();
22740 } else {
22741 _v = 1;
22742 }
22743 }
22744 if (_v) {
22745 {
22746 void *ptr = 0;
22747 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22748 _v = 0;
22749 PyErr_Clear();
22750 } else {
22751 _v = (ptr != 0);
22752 }
22753 }
22754 if (_v) {
22755 return _wrap_DateTime___iadd____SWIG_1(self,args);
22756 }
22757 }
22758 }
22759
22760 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22761 return NULL;
22762 }
22763
22764
22765 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22766 PyObject *resultobj;
22767 wxDateTime *arg1 = (wxDateTime *) 0 ;
22768 wxTimeSpan *arg2 = 0 ;
22769 wxDateTime *result;
22770 PyObject * obj0 = 0 ;
22771 PyObject * obj1 = 0 ;
22772
22773 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22775 if (SWIG_arg_fail(1)) SWIG_fail;
22776 {
22777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22778 if (SWIG_arg_fail(2)) SWIG_fail;
22779 if (arg2 == NULL) {
22780 SWIG_null_ref("wxTimeSpan");
22781 }
22782 if (SWIG_arg_fail(2)) SWIG_fail;
22783 }
22784 {
22785 PyThreadState* __tstate = wxPyBeginAllowThreads();
22786 {
22787 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22788 result = (wxDateTime *) &_result_ref;
22789 }
22790
22791 wxPyEndAllowThreads(__tstate);
22792 if (PyErr_Occurred()) SWIG_fail;
22793 }
22794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22802 PyObject *resultobj;
22803 wxDateTime *arg1 = (wxDateTime *) 0 ;
22804 wxDateSpan *arg2 = 0 ;
22805 wxDateTime *result;
22806 PyObject * obj0 = 0 ;
22807 PyObject * obj1 = 0 ;
22808
22809 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22811 if (SWIG_arg_fail(1)) SWIG_fail;
22812 {
22813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22814 if (SWIG_arg_fail(2)) SWIG_fail;
22815 if (arg2 == NULL) {
22816 SWIG_null_ref("wxDateSpan");
22817 }
22818 if (SWIG_arg_fail(2)) SWIG_fail;
22819 }
22820 {
22821 PyThreadState* __tstate = wxPyBeginAllowThreads();
22822 {
22823 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22824 result = (wxDateTime *) &_result_ref;
22825 }
22826
22827 wxPyEndAllowThreads(__tstate);
22828 if (PyErr_Occurred()) SWIG_fail;
22829 }
22830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22831 return resultobj;
22832 fail:
22833 return NULL;
22834 }
22835
22836
22837 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22838 int argc;
22839 PyObject *argv[3];
22840 int ii;
22841
22842 argc = PyObject_Length(args);
22843 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22844 argv[ii] = PyTuple_GetItem(args,ii);
22845 }
22846 if (argc == 2) {
22847 int _v;
22848 {
22849 void *ptr;
22850 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22851 _v = 0;
22852 PyErr_Clear();
22853 } else {
22854 _v = 1;
22855 }
22856 }
22857 if (_v) {
22858 {
22859 void *ptr = 0;
22860 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22861 _v = 0;
22862 PyErr_Clear();
22863 } else {
22864 _v = (ptr != 0);
22865 }
22866 }
22867 if (_v) {
22868 return _wrap_DateTime___isub____SWIG_0(self,args);
22869 }
22870 }
22871 }
22872 if (argc == 2) {
22873 int _v;
22874 {
22875 void *ptr;
22876 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22877 _v = 0;
22878 PyErr_Clear();
22879 } else {
22880 _v = 1;
22881 }
22882 }
22883 if (_v) {
22884 {
22885 void *ptr = 0;
22886 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22887 _v = 0;
22888 PyErr_Clear();
22889 } else {
22890 _v = (ptr != 0);
22891 }
22892 }
22893 if (_v) {
22894 return _wrap_DateTime___isub____SWIG_1(self,args);
22895 }
22896 }
22897 }
22898
22899 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22900 return NULL;
22901 }
22902
22903
22904 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22905 PyObject *resultobj;
22906 wxDateTime *arg1 = (wxDateTime *) 0 ;
22907 wxTimeSpan *arg2 = 0 ;
22908 wxDateTime result;
22909 PyObject * obj0 = 0 ;
22910 PyObject * obj1 = 0 ;
22911
22912 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22914 if (SWIG_arg_fail(1)) SWIG_fail;
22915 {
22916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22917 if (SWIG_arg_fail(2)) SWIG_fail;
22918 if (arg2 == NULL) {
22919 SWIG_null_ref("wxTimeSpan");
22920 }
22921 if (SWIG_arg_fail(2)) SWIG_fail;
22922 }
22923 {
22924 PyThreadState* __tstate = wxPyBeginAllowThreads();
22925 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22926
22927 wxPyEndAllowThreads(__tstate);
22928 if (PyErr_Occurred()) SWIG_fail;
22929 }
22930 {
22931 wxDateTime * resultptr;
22932 resultptr = new wxDateTime((wxDateTime &)(result));
22933 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22934 }
22935 return resultobj;
22936 fail:
22937 return NULL;
22938 }
22939
22940
22941 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22942 PyObject *resultobj;
22943 wxDateTime *arg1 = (wxDateTime *) 0 ;
22944 wxDateSpan *arg2 = 0 ;
22945 wxDateTime result;
22946 PyObject * obj0 = 0 ;
22947 PyObject * obj1 = 0 ;
22948
22949 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22951 if (SWIG_arg_fail(1)) SWIG_fail;
22952 {
22953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22954 if (SWIG_arg_fail(2)) SWIG_fail;
22955 if (arg2 == NULL) {
22956 SWIG_null_ref("wxDateSpan");
22957 }
22958 if (SWIG_arg_fail(2)) SWIG_fail;
22959 }
22960 {
22961 PyThreadState* __tstate = wxPyBeginAllowThreads();
22962 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22963
22964 wxPyEndAllowThreads(__tstate);
22965 if (PyErr_Occurred()) SWIG_fail;
22966 }
22967 {
22968 wxDateTime * resultptr;
22969 resultptr = new wxDateTime((wxDateTime &)(result));
22970 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22971 }
22972 return resultobj;
22973 fail:
22974 return NULL;
22975 }
22976
22977
22978 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22979 int argc;
22980 PyObject *argv[3];
22981 int ii;
22982
22983 argc = PyObject_Length(args);
22984 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22985 argv[ii] = PyTuple_GetItem(args,ii);
22986 }
22987 if (argc == 2) {
22988 int _v;
22989 {
22990 void *ptr;
22991 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22992 _v = 0;
22993 PyErr_Clear();
22994 } else {
22995 _v = 1;
22996 }
22997 }
22998 if (_v) {
22999 {
23000 void *ptr = 0;
23001 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23002 _v = 0;
23003 PyErr_Clear();
23004 } else {
23005 _v = (ptr != 0);
23006 }
23007 }
23008 if (_v) {
23009 return _wrap_DateTime___add____SWIG_0(self,args);
23010 }
23011 }
23012 }
23013 if (argc == 2) {
23014 int _v;
23015 {
23016 void *ptr;
23017 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23018 _v = 0;
23019 PyErr_Clear();
23020 } else {
23021 _v = 1;
23022 }
23023 }
23024 if (_v) {
23025 {
23026 void *ptr = 0;
23027 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23028 _v = 0;
23029 PyErr_Clear();
23030 } else {
23031 _v = (ptr != 0);
23032 }
23033 }
23034 if (_v) {
23035 return _wrap_DateTime___add____SWIG_1(self,args);
23036 }
23037 }
23038 }
23039
23040 Py_INCREF(Py_NotImplemented);
23041 return Py_NotImplemented;
23042 }
23043
23044
23045 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23046 PyObject *resultobj;
23047 wxDateTime *arg1 = (wxDateTime *) 0 ;
23048 wxDateTime *arg2 = 0 ;
23049 wxTimeSpan result;
23050 PyObject * obj0 = 0 ;
23051 PyObject * obj1 = 0 ;
23052
23053 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23055 if (SWIG_arg_fail(1)) SWIG_fail;
23056 {
23057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23058 if (SWIG_arg_fail(2)) SWIG_fail;
23059 if (arg2 == NULL) {
23060 SWIG_null_ref("wxDateTime");
23061 }
23062 if (SWIG_arg_fail(2)) SWIG_fail;
23063 }
23064 {
23065 PyThreadState* __tstate = wxPyBeginAllowThreads();
23066 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23067
23068 wxPyEndAllowThreads(__tstate);
23069 if (PyErr_Occurred()) SWIG_fail;
23070 }
23071 {
23072 wxTimeSpan * resultptr;
23073 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23074 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23075 }
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23083 PyObject *resultobj;
23084 wxDateTime *arg1 = (wxDateTime *) 0 ;
23085 wxTimeSpan *arg2 = 0 ;
23086 wxDateTime result;
23087 PyObject * obj0 = 0 ;
23088 PyObject * obj1 = 0 ;
23089
23090 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23092 if (SWIG_arg_fail(1)) SWIG_fail;
23093 {
23094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23095 if (SWIG_arg_fail(2)) SWIG_fail;
23096 if (arg2 == NULL) {
23097 SWIG_null_ref("wxTimeSpan");
23098 }
23099 if (SWIG_arg_fail(2)) SWIG_fail;
23100 }
23101 {
23102 PyThreadState* __tstate = wxPyBeginAllowThreads();
23103 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23104
23105 wxPyEndAllowThreads(__tstate);
23106 if (PyErr_Occurred()) SWIG_fail;
23107 }
23108 {
23109 wxDateTime * resultptr;
23110 resultptr = new wxDateTime((wxDateTime &)(result));
23111 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23112 }
23113 return resultobj;
23114 fail:
23115 return NULL;
23116 }
23117
23118
23119 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23120 PyObject *resultobj;
23121 wxDateTime *arg1 = (wxDateTime *) 0 ;
23122 wxDateSpan *arg2 = 0 ;
23123 wxDateTime result;
23124 PyObject * obj0 = 0 ;
23125 PyObject * obj1 = 0 ;
23126
23127 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23129 if (SWIG_arg_fail(1)) SWIG_fail;
23130 {
23131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23132 if (SWIG_arg_fail(2)) SWIG_fail;
23133 if (arg2 == NULL) {
23134 SWIG_null_ref("wxDateSpan");
23135 }
23136 if (SWIG_arg_fail(2)) SWIG_fail;
23137 }
23138 {
23139 PyThreadState* __tstate = wxPyBeginAllowThreads();
23140 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23141
23142 wxPyEndAllowThreads(__tstate);
23143 if (PyErr_Occurred()) SWIG_fail;
23144 }
23145 {
23146 wxDateTime * resultptr;
23147 resultptr = new wxDateTime((wxDateTime &)(result));
23148 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23149 }
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23157 int argc;
23158 PyObject *argv[3];
23159 int ii;
23160
23161 argc = PyObject_Length(args);
23162 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23163 argv[ii] = PyTuple_GetItem(args,ii);
23164 }
23165 if (argc == 2) {
23166 int _v;
23167 {
23168 void *ptr;
23169 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23170 _v = 0;
23171 PyErr_Clear();
23172 } else {
23173 _v = 1;
23174 }
23175 }
23176 if (_v) {
23177 {
23178 void *ptr = 0;
23179 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23180 _v = 0;
23181 PyErr_Clear();
23182 } else {
23183 _v = (ptr != 0);
23184 }
23185 }
23186 if (_v) {
23187 return _wrap_DateTime___sub____SWIG_0(self,args);
23188 }
23189 }
23190 }
23191 if (argc == 2) {
23192 int _v;
23193 {
23194 void *ptr;
23195 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23196 _v = 0;
23197 PyErr_Clear();
23198 } else {
23199 _v = 1;
23200 }
23201 }
23202 if (_v) {
23203 {
23204 void *ptr = 0;
23205 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23206 _v = 0;
23207 PyErr_Clear();
23208 } else {
23209 _v = (ptr != 0);
23210 }
23211 }
23212 if (_v) {
23213 return _wrap_DateTime___sub____SWIG_1(self,args);
23214 }
23215 }
23216 }
23217 if (argc == 2) {
23218 int _v;
23219 {
23220 void *ptr;
23221 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23222 _v = 0;
23223 PyErr_Clear();
23224 } else {
23225 _v = 1;
23226 }
23227 }
23228 if (_v) {
23229 {
23230 void *ptr = 0;
23231 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23232 _v = 0;
23233 PyErr_Clear();
23234 } else {
23235 _v = (ptr != 0);
23236 }
23237 }
23238 if (_v) {
23239 return _wrap_DateTime___sub____SWIG_2(self,args);
23240 }
23241 }
23242 }
23243
23244 Py_INCREF(Py_NotImplemented);
23245 return Py_NotImplemented;
23246 }
23247
23248
23249 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23250 PyObject *resultobj;
23251 wxDateTime *arg1 = (wxDateTime *) 0 ;
23252 wxDateTime *arg2 = (wxDateTime *) 0 ;
23253 bool result;
23254 PyObject * obj0 = 0 ;
23255 PyObject * obj1 = 0 ;
23256 char *kwnames[] = {
23257 (char *) "self",(char *) "other", NULL
23258 };
23259
23260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23262 if (SWIG_arg_fail(1)) SWIG_fail;
23263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(2)) SWIG_fail;
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23268
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 {
23273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23274 }
23275 return resultobj;
23276 fail:
23277 return NULL;
23278 }
23279
23280
23281 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23282 PyObject *resultobj;
23283 wxDateTime *arg1 = (wxDateTime *) 0 ;
23284 wxDateTime *arg2 = (wxDateTime *) 0 ;
23285 bool result;
23286 PyObject * obj0 = 0 ;
23287 PyObject * obj1 = 0 ;
23288 char *kwnames[] = {
23289 (char *) "self",(char *) "other", NULL
23290 };
23291
23292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23294 if (SWIG_arg_fail(1)) SWIG_fail;
23295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23296 if (SWIG_arg_fail(2)) SWIG_fail;
23297 {
23298 PyThreadState* __tstate = wxPyBeginAllowThreads();
23299 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23300
23301 wxPyEndAllowThreads(__tstate);
23302 if (PyErr_Occurred()) SWIG_fail;
23303 }
23304 {
23305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23306 }
23307 return resultobj;
23308 fail:
23309 return NULL;
23310 }
23311
23312
23313 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23314 PyObject *resultobj;
23315 wxDateTime *arg1 = (wxDateTime *) 0 ;
23316 wxDateTime *arg2 = (wxDateTime *) 0 ;
23317 bool result;
23318 PyObject * obj0 = 0 ;
23319 PyObject * obj1 = 0 ;
23320 char *kwnames[] = {
23321 (char *) "self",(char *) "other", NULL
23322 };
23323
23324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23326 if (SWIG_arg_fail(1)) SWIG_fail;
23327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23328 if (SWIG_arg_fail(2)) SWIG_fail;
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23332
23333 wxPyEndAllowThreads(__tstate);
23334 if (PyErr_Occurred()) SWIG_fail;
23335 }
23336 {
23337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23338 }
23339 return resultobj;
23340 fail:
23341 return NULL;
23342 }
23343
23344
23345 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23346 PyObject *resultobj;
23347 wxDateTime *arg1 = (wxDateTime *) 0 ;
23348 wxDateTime *arg2 = (wxDateTime *) 0 ;
23349 bool result;
23350 PyObject * obj0 = 0 ;
23351 PyObject * obj1 = 0 ;
23352 char *kwnames[] = {
23353 (char *) "self",(char *) "other", NULL
23354 };
23355
23356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23358 if (SWIG_arg_fail(1)) SWIG_fail;
23359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23360 if (SWIG_arg_fail(2)) SWIG_fail;
23361 {
23362 PyThreadState* __tstate = wxPyBeginAllowThreads();
23363 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23364
23365 wxPyEndAllowThreads(__tstate);
23366 if (PyErr_Occurred()) SWIG_fail;
23367 }
23368 {
23369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23370 }
23371 return resultobj;
23372 fail:
23373 return NULL;
23374 }
23375
23376
23377 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23378 PyObject *resultobj;
23379 wxDateTime *arg1 = (wxDateTime *) 0 ;
23380 wxDateTime *arg2 = (wxDateTime *) 0 ;
23381 bool result;
23382 PyObject * obj0 = 0 ;
23383 PyObject * obj1 = 0 ;
23384 char *kwnames[] = {
23385 (char *) "self",(char *) "other", NULL
23386 };
23387
23388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23390 if (SWIG_arg_fail(1)) SWIG_fail;
23391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23392 if (SWIG_arg_fail(2)) SWIG_fail;
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23396
23397 wxPyEndAllowThreads(__tstate);
23398 if (PyErr_Occurred()) SWIG_fail;
23399 }
23400 {
23401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23402 }
23403 return resultobj;
23404 fail:
23405 return NULL;
23406 }
23407
23408
23409 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23410 PyObject *resultobj;
23411 wxDateTime *arg1 = (wxDateTime *) 0 ;
23412 wxDateTime *arg2 = (wxDateTime *) 0 ;
23413 bool result;
23414 PyObject * obj0 = 0 ;
23415 PyObject * obj1 = 0 ;
23416 char *kwnames[] = {
23417 (char *) "self",(char *) "other", NULL
23418 };
23419
23420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23422 if (SWIG_arg_fail(1)) SWIG_fail;
23423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23424 if (SWIG_arg_fail(2)) SWIG_fail;
23425 {
23426 PyThreadState* __tstate = wxPyBeginAllowThreads();
23427 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23428
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 {
23433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23434 }
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23442 PyObject *resultobj;
23443 wxDateTime *arg1 = (wxDateTime *) 0 ;
23444 wxString *arg2 = 0 ;
23445 int result;
23446 bool temp2 = false ;
23447 PyObject * obj0 = 0 ;
23448 PyObject * obj1 = 0 ;
23449 char *kwnames[] = {
23450 (char *) "self",(char *) "date", NULL
23451 };
23452
23453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23455 if (SWIG_arg_fail(1)) SWIG_fail;
23456 {
23457 arg2 = wxString_in_helper(obj1);
23458 if (arg2 == NULL) SWIG_fail;
23459 temp2 = true;
23460 }
23461 {
23462 PyThreadState* __tstate = wxPyBeginAllowThreads();
23463 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23464
23465 wxPyEndAllowThreads(__tstate);
23466 if (PyErr_Occurred()) SWIG_fail;
23467 }
23468 {
23469 resultobj = SWIG_From_int((int)(result));
23470 }
23471 {
23472 if (temp2)
23473 delete arg2;
23474 }
23475 return resultobj;
23476 fail:
23477 {
23478 if (temp2)
23479 delete arg2;
23480 }
23481 return NULL;
23482 }
23483
23484
23485 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj;
23487 wxDateTime *arg1 = (wxDateTime *) 0 ;
23488 wxString *arg2 = 0 ;
23489 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23490 wxString *arg3 = (wxString *) &arg3_defvalue ;
23491 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23492 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23493 int result;
23494 bool temp2 = false ;
23495 bool temp3 = false ;
23496 PyObject * obj0 = 0 ;
23497 PyObject * obj1 = 0 ;
23498 PyObject * obj2 = 0 ;
23499 PyObject * obj3 = 0 ;
23500 char *kwnames[] = {
23501 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23502 };
23503
23504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23506 if (SWIG_arg_fail(1)) SWIG_fail;
23507 {
23508 arg2 = wxString_in_helper(obj1);
23509 if (arg2 == NULL) SWIG_fail;
23510 temp2 = true;
23511 }
23512 if (obj2) {
23513 {
23514 arg3 = wxString_in_helper(obj2);
23515 if (arg3 == NULL) SWIG_fail;
23516 temp3 = true;
23517 }
23518 }
23519 if (obj3) {
23520 {
23521 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23522 if (SWIG_arg_fail(4)) SWIG_fail;
23523 if (arg4 == NULL) {
23524 SWIG_null_ref("wxDateTime");
23525 }
23526 if (SWIG_arg_fail(4)) SWIG_fail;
23527 }
23528 }
23529 {
23530 PyThreadState* __tstate = wxPyBeginAllowThreads();
23531 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23532
23533 wxPyEndAllowThreads(__tstate);
23534 if (PyErr_Occurred()) SWIG_fail;
23535 }
23536 {
23537 resultobj = SWIG_From_int((int)(result));
23538 }
23539 {
23540 if (temp2)
23541 delete arg2;
23542 }
23543 {
23544 if (temp3)
23545 delete arg3;
23546 }
23547 return resultobj;
23548 fail:
23549 {
23550 if (temp2)
23551 delete arg2;
23552 }
23553 {
23554 if (temp3)
23555 delete arg3;
23556 }
23557 return NULL;
23558 }
23559
23560
23561 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23562 PyObject *resultobj;
23563 wxDateTime *arg1 = (wxDateTime *) 0 ;
23564 wxString *arg2 = 0 ;
23565 int result;
23566 bool temp2 = false ;
23567 PyObject * obj0 = 0 ;
23568 PyObject * obj1 = 0 ;
23569 char *kwnames[] = {
23570 (char *) "self",(char *) "datetime", NULL
23571 };
23572
23573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23575 if (SWIG_arg_fail(1)) SWIG_fail;
23576 {
23577 arg2 = wxString_in_helper(obj1);
23578 if (arg2 == NULL) SWIG_fail;
23579 temp2 = true;
23580 }
23581 {
23582 PyThreadState* __tstate = wxPyBeginAllowThreads();
23583 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23584
23585 wxPyEndAllowThreads(__tstate);
23586 if (PyErr_Occurred()) SWIG_fail;
23587 }
23588 {
23589 resultobj = SWIG_From_int((int)(result));
23590 }
23591 {
23592 if (temp2)
23593 delete arg2;
23594 }
23595 return resultobj;
23596 fail:
23597 {
23598 if (temp2)
23599 delete arg2;
23600 }
23601 return NULL;
23602 }
23603
23604
23605 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23606 PyObject *resultobj;
23607 wxDateTime *arg1 = (wxDateTime *) 0 ;
23608 wxString *arg2 = 0 ;
23609 int result;
23610 bool temp2 = false ;
23611 PyObject * obj0 = 0 ;
23612 PyObject * obj1 = 0 ;
23613 char *kwnames[] = {
23614 (char *) "self",(char *) "date", NULL
23615 };
23616
23617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23619 if (SWIG_arg_fail(1)) SWIG_fail;
23620 {
23621 arg2 = wxString_in_helper(obj1);
23622 if (arg2 == NULL) SWIG_fail;
23623 temp2 = true;
23624 }
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23628
23629 wxPyEndAllowThreads(__tstate);
23630 if (PyErr_Occurred()) SWIG_fail;
23631 }
23632 {
23633 resultobj = SWIG_From_int((int)(result));
23634 }
23635 {
23636 if (temp2)
23637 delete arg2;
23638 }
23639 return resultobj;
23640 fail:
23641 {
23642 if (temp2)
23643 delete arg2;
23644 }
23645 return NULL;
23646 }
23647
23648
23649 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj;
23651 wxDateTime *arg1 = (wxDateTime *) 0 ;
23652 wxString *arg2 = 0 ;
23653 int result;
23654 bool temp2 = false ;
23655 PyObject * obj0 = 0 ;
23656 PyObject * obj1 = 0 ;
23657 char *kwnames[] = {
23658 (char *) "self",(char *) "time", NULL
23659 };
23660
23661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23663 if (SWIG_arg_fail(1)) SWIG_fail;
23664 {
23665 arg2 = wxString_in_helper(obj1);
23666 if (arg2 == NULL) SWIG_fail;
23667 temp2 = true;
23668 }
23669 {
23670 PyThreadState* __tstate = wxPyBeginAllowThreads();
23671 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23672
23673 wxPyEndAllowThreads(__tstate);
23674 if (PyErr_Occurred()) SWIG_fail;
23675 }
23676 {
23677 resultobj = SWIG_From_int((int)(result));
23678 }
23679 {
23680 if (temp2)
23681 delete arg2;
23682 }
23683 return resultobj;
23684 fail:
23685 {
23686 if (temp2)
23687 delete arg2;
23688 }
23689 return NULL;
23690 }
23691
23692
23693 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23694 PyObject *resultobj;
23695 wxDateTime *arg1 = (wxDateTime *) 0 ;
23696 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23697 wxString *arg2 = (wxString *) &arg2_defvalue ;
23698 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23699 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23700 wxString result;
23701 bool temp2 = false ;
23702 bool temp3 = false ;
23703 PyObject * obj0 = 0 ;
23704 PyObject * obj1 = 0 ;
23705 PyObject * obj2 = 0 ;
23706 char *kwnames[] = {
23707 (char *) "self",(char *) "format",(char *) "tz", NULL
23708 };
23709
23710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23712 if (SWIG_arg_fail(1)) SWIG_fail;
23713 if (obj1) {
23714 {
23715 arg2 = wxString_in_helper(obj1);
23716 if (arg2 == NULL) SWIG_fail;
23717 temp2 = true;
23718 }
23719 }
23720 if (obj2) {
23721 {
23722 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23723 temp3 = true;
23724 }
23725 }
23726 {
23727 PyThreadState* __tstate = wxPyBeginAllowThreads();
23728 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23729
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 {
23734 #if wxUSE_UNICODE
23735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23736 #else
23737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23738 #endif
23739 }
23740 {
23741 if (temp2)
23742 delete arg2;
23743 }
23744 {
23745 if (temp3) delete arg3;
23746 }
23747 return resultobj;
23748 fail:
23749 {
23750 if (temp2)
23751 delete arg2;
23752 }
23753 {
23754 if (temp3) delete arg3;
23755 }
23756 return NULL;
23757 }
23758
23759
23760 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23761 PyObject *resultobj;
23762 wxDateTime *arg1 = (wxDateTime *) 0 ;
23763 wxString result;
23764 PyObject * obj0 = 0 ;
23765 char *kwnames[] = {
23766 (char *) "self", NULL
23767 };
23768
23769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23771 if (SWIG_arg_fail(1)) SWIG_fail;
23772 {
23773 PyThreadState* __tstate = wxPyBeginAllowThreads();
23774 result = ((wxDateTime const *)arg1)->FormatDate();
23775
23776 wxPyEndAllowThreads(__tstate);
23777 if (PyErr_Occurred()) SWIG_fail;
23778 }
23779 {
23780 #if wxUSE_UNICODE
23781 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23782 #else
23783 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23784 #endif
23785 }
23786 return resultobj;
23787 fail:
23788 return NULL;
23789 }
23790
23791
23792 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23793 PyObject *resultobj;
23794 wxDateTime *arg1 = (wxDateTime *) 0 ;
23795 wxString result;
23796 PyObject * obj0 = 0 ;
23797 char *kwnames[] = {
23798 (char *) "self", NULL
23799 };
23800
23801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23803 if (SWIG_arg_fail(1)) SWIG_fail;
23804 {
23805 PyThreadState* __tstate = wxPyBeginAllowThreads();
23806 result = ((wxDateTime const *)arg1)->FormatTime();
23807
23808 wxPyEndAllowThreads(__tstate);
23809 if (PyErr_Occurred()) SWIG_fail;
23810 }
23811 {
23812 #if wxUSE_UNICODE
23813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23814 #else
23815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23816 #endif
23817 }
23818 return resultobj;
23819 fail:
23820 return NULL;
23821 }
23822
23823
23824 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23825 PyObject *resultobj;
23826 wxDateTime *arg1 = (wxDateTime *) 0 ;
23827 wxString result;
23828 PyObject * obj0 = 0 ;
23829 char *kwnames[] = {
23830 (char *) "self", NULL
23831 };
23832
23833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23835 if (SWIG_arg_fail(1)) SWIG_fail;
23836 {
23837 PyThreadState* __tstate = wxPyBeginAllowThreads();
23838 result = ((wxDateTime const *)arg1)->FormatISODate();
23839
23840 wxPyEndAllowThreads(__tstate);
23841 if (PyErr_Occurred()) SWIG_fail;
23842 }
23843 {
23844 #if wxUSE_UNICODE
23845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23846 #else
23847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23848 #endif
23849 }
23850 return resultobj;
23851 fail:
23852 return NULL;
23853 }
23854
23855
23856 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj;
23858 wxDateTime *arg1 = (wxDateTime *) 0 ;
23859 wxString result;
23860 PyObject * obj0 = 0 ;
23861 char *kwnames[] = {
23862 (char *) "self", NULL
23863 };
23864
23865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23867 if (SWIG_arg_fail(1)) SWIG_fail;
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 result = ((wxDateTime const *)arg1)->FormatISOTime();
23871
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 {
23876 #if wxUSE_UNICODE
23877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23878 #else
23879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23880 #endif
23881 }
23882 return resultobj;
23883 fail:
23884 return NULL;
23885 }
23886
23887
23888 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23889 PyObject *obj;
23890 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23891 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23892 Py_INCREF(obj);
23893 return Py_BuildValue((char *)"");
23894 }
23895 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23896 PyObject *resultobj;
23897 long arg1 ;
23898 wxTimeSpan result;
23899 PyObject * obj0 = 0 ;
23900 char *kwnames[] = {
23901 (char *) "sec", NULL
23902 };
23903
23904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23905 {
23906 arg1 = (long)(SWIG_As_long(obj0));
23907 if (SWIG_arg_fail(1)) SWIG_fail;
23908 }
23909 {
23910 PyThreadState* __tstate = wxPyBeginAllowThreads();
23911 result = wxTimeSpan::Seconds(arg1);
23912
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 {
23917 wxTimeSpan * resultptr;
23918 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23920 }
23921 return resultobj;
23922 fail:
23923 return NULL;
23924 }
23925
23926
23927 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23928 PyObject *resultobj;
23929 wxTimeSpan result;
23930 char *kwnames[] = {
23931 NULL
23932 };
23933
23934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23935 {
23936 PyThreadState* __tstate = wxPyBeginAllowThreads();
23937 result = wxTimeSpan::Second();
23938
23939 wxPyEndAllowThreads(__tstate);
23940 if (PyErr_Occurred()) SWIG_fail;
23941 }
23942 {
23943 wxTimeSpan * resultptr;
23944 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23946 }
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23954 PyObject *resultobj;
23955 long arg1 ;
23956 wxTimeSpan result;
23957 PyObject * obj0 = 0 ;
23958 char *kwnames[] = {
23959 (char *) "min", NULL
23960 };
23961
23962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23963 {
23964 arg1 = (long)(SWIG_As_long(obj0));
23965 if (SWIG_arg_fail(1)) SWIG_fail;
23966 }
23967 {
23968 PyThreadState* __tstate = wxPyBeginAllowThreads();
23969 result = wxTimeSpan::Minutes(arg1);
23970
23971 wxPyEndAllowThreads(__tstate);
23972 if (PyErr_Occurred()) SWIG_fail;
23973 }
23974 {
23975 wxTimeSpan * resultptr;
23976 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23977 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23978 }
23979 return resultobj;
23980 fail:
23981 return NULL;
23982 }
23983
23984
23985 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23986 PyObject *resultobj;
23987 wxTimeSpan result;
23988 char *kwnames[] = {
23989 NULL
23990 };
23991
23992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23993 {
23994 PyThreadState* __tstate = wxPyBeginAllowThreads();
23995 result = wxTimeSpan::Minute();
23996
23997 wxPyEndAllowThreads(__tstate);
23998 if (PyErr_Occurred()) SWIG_fail;
23999 }
24000 {
24001 wxTimeSpan * resultptr;
24002 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24003 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24004 }
24005 return resultobj;
24006 fail:
24007 return NULL;
24008 }
24009
24010
24011 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24012 PyObject *resultobj;
24013 long arg1 ;
24014 wxTimeSpan result;
24015 PyObject * obj0 = 0 ;
24016 char *kwnames[] = {
24017 (char *) "hours", NULL
24018 };
24019
24020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24021 {
24022 arg1 = (long)(SWIG_As_long(obj0));
24023 if (SWIG_arg_fail(1)) SWIG_fail;
24024 }
24025 {
24026 PyThreadState* __tstate = wxPyBeginAllowThreads();
24027 result = wxTimeSpan::Hours(arg1);
24028
24029 wxPyEndAllowThreads(__tstate);
24030 if (PyErr_Occurred()) SWIG_fail;
24031 }
24032 {
24033 wxTimeSpan * resultptr;
24034 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24035 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24036 }
24037 return resultobj;
24038 fail:
24039 return NULL;
24040 }
24041
24042
24043 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24044 PyObject *resultobj;
24045 wxTimeSpan result;
24046 char *kwnames[] = {
24047 NULL
24048 };
24049
24050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24051 {
24052 PyThreadState* __tstate = wxPyBeginAllowThreads();
24053 result = wxTimeSpan::Hour();
24054
24055 wxPyEndAllowThreads(__tstate);
24056 if (PyErr_Occurred()) SWIG_fail;
24057 }
24058 {
24059 wxTimeSpan * resultptr;
24060 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24061 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24062 }
24063 return resultobj;
24064 fail:
24065 return NULL;
24066 }
24067
24068
24069 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24070 PyObject *resultobj;
24071 long arg1 ;
24072 wxTimeSpan result;
24073 PyObject * obj0 = 0 ;
24074 char *kwnames[] = {
24075 (char *) "days", NULL
24076 };
24077
24078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24079 {
24080 arg1 = (long)(SWIG_As_long(obj0));
24081 if (SWIG_arg_fail(1)) SWIG_fail;
24082 }
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 result = wxTimeSpan::Days(arg1);
24086
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 {
24091 wxTimeSpan * resultptr;
24092 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24094 }
24095 return resultobj;
24096 fail:
24097 return NULL;
24098 }
24099
24100
24101 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24102 PyObject *resultobj;
24103 wxTimeSpan result;
24104 char *kwnames[] = {
24105 NULL
24106 };
24107
24108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24109 {
24110 PyThreadState* __tstate = wxPyBeginAllowThreads();
24111 result = wxTimeSpan::Day();
24112
24113 wxPyEndAllowThreads(__tstate);
24114 if (PyErr_Occurred()) SWIG_fail;
24115 }
24116 {
24117 wxTimeSpan * resultptr;
24118 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24119 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24120 }
24121 return resultobj;
24122 fail:
24123 return NULL;
24124 }
24125
24126
24127 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24128 PyObject *resultobj;
24129 long arg1 ;
24130 wxTimeSpan result;
24131 PyObject * obj0 = 0 ;
24132 char *kwnames[] = {
24133 (char *) "days", NULL
24134 };
24135
24136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24137 {
24138 arg1 = (long)(SWIG_As_long(obj0));
24139 if (SWIG_arg_fail(1)) SWIG_fail;
24140 }
24141 {
24142 PyThreadState* __tstate = wxPyBeginAllowThreads();
24143 result = wxTimeSpan::Weeks(arg1);
24144
24145 wxPyEndAllowThreads(__tstate);
24146 if (PyErr_Occurred()) SWIG_fail;
24147 }
24148 {
24149 wxTimeSpan * resultptr;
24150 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24151 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24152 }
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24160 PyObject *resultobj;
24161 wxTimeSpan result;
24162 char *kwnames[] = {
24163 NULL
24164 };
24165
24166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24167 {
24168 PyThreadState* __tstate = wxPyBeginAllowThreads();
24169 result = wxTimeSpan::Week();
24170
24171 wxPyEndAllowThreads(__tstate);
24172 if (PyErr_Occurred()) SWIG_fail;
24173 }
24174 {
24175 wxTimeSpan * resultptr;
24176 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24177 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24178 }
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24186 PyObject *resultobj;
24187 long arg1 = (long) 0 ;
24188 long arg2 = (long) 0 ;
24189 long arg3 = (long) 0 ;
24190 long arg4 = (long) 0 ;
24191 wxTimeSpan *result;
24192 PyObject * obj0 = 0 ;
24193 PyObject * obj1 = 0 ;
24194 PyObject * obj2 = 0 ;
24195 PyObject * obj3 = 0 ;
24196 char *kwnames[] = {
24197 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24198 };
24199
24200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24201 if (obj0) {
24202 {
24203 arg1 = (long)(SWIG_As_long(obj0));
24204 if (SWIG_arg_fail(1)) SWIG_fail;
24205 }
24206 }
24207 if (obj1) {
24208 {
24209 arg2 = (long)(SWIG_As_long(obj1));
24210 if (SWIG_arg_fail(2)) SWIG_fail;
24211 }
24212 }
24213 if (obj2) {
24214 {
24215 arg3 = (long)(SWIG_As_long(obj2));
24216 if (SWIG_arg_fail(3)) SWIG_fail;
24217 }
24218 }
24219 if (obj3) {
24220 {
24221 arg4 = (long)(SWIG_As_long(obj3));
24222 if (SWIG_arg_fail(4)) SWIG_fail;
24223 }
24224 }
24225 {
24226 PyThreadState* __tstate = wxPyBeginAllowThreads();
24227 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24228
24229 wxPyEndAllowThreads(__tstate);
24230 if (PyErr_Occurred()) SWIG_fail;
24231 }
24232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24240 PyObject *resultobj;
24241 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24242 PyObject * obj0 = 0 ;
24243 char *kwnames[] = {
24244 (char *) "self", NULL
24245 };
24246
24247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24249 if (SWIG_arg_fail(1)) SWIG_fail;
24250 {
24251 PyThreadState* __tstate = wxPyBeginAllowThreads();
24252 delete arg1;
24253
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 Py_INCREF(Py_None); resultobj = Py_None;
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24265 PyObject *resultobj;
24266 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24267 wxTimeSpan *arg2 = 0 ;
24268 wxTimeSpan *result;
24269 PyObject * obj0 = 0 ;
24270 PyObject * obj1 = 0 ;
24271 char *kwnames[] = {
24272 (char *) "self",(char *) "diff", NULL
24273 };
24274
24275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24277 if (SWIG_arg_fail(1)) SWIG_fail;
24278 {
24279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24280 if (SWIG_arg_fail(2)) SWIG_fail;
24281 if (arg2 == NULL) {
24282 SWIG_null_ref("wxTimeSpan");
24283 }
24284 if (SWIG_arg_fail(2)) SWIG_fail;
24285 }
24286 {
24287 PyThreadState* __tstate = wxPyBeginAllowThreads();
24288 {
24289 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24290 result = (wxTimeSpan *) &_result_ref;
24291 }
24292
24293 wxPyEndAllowThreads(__tstate);
24294 if (PyErr_Occurred()) SWIG_fail;
24295 }
24296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24297 return resultobj;
24298 fail:
24299 return NULL;
24300 }
24301
24302
24303 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24304 PyObject *resultobj;
24305 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24306 wxTimeSpan *arg2 = 0 ;
24307 wxTimeSpan *result;
24308 PyObject * obj0 = 0 ;
24309 PyObject * obj1 = 0 ;
24310 char *kwnames[] = {
24311 (char *) "self",(char *) "diff", NULL
24312 };
24313
24314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24316 if (SWIG_arg_fail(1)) SWIG_fail;
24317 {
24318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24319 if (SWIG_arg_fail(2)) SWIG_fail;
24320 if (arg2 == NULL) {
24321 SWIG_null_ref("wxTimeSpan");
24322 }
24323 if (SWIG_arg_fail(2)) SWIG_fail;
24324 }
24325 {
24326 PyThreadState* __tstate = wxPyBeginAllowThreads();
24327 {
24328 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24329 result = (wxTimeSpan *) &_result_ref;
24330 }
24331
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24336 return resultobj;
24337 fail:
24338 return NULL;
24339 }
24340
24341
24342 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24343 PyObject *resultobj;
24344 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24345 int arg2 ;
24346 wxTimeSpan *result;
24347 PyObject * obj0 = 0 ;
24348 PyObject * obj1 = 0 ;
24349 char *kwnames[] = {
24350 (char *) "self",(char *) "n", NULL
24351 };
24352
24353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24355 if (SWIG_arg_fail(1)) SWIG_fail;
24356 {
24357 arg2 = (int)(SWIG_As_int(obj1));
24358 if (SWIG_arg_fail(2)) SWIG_fail;
24359 }
24360 {
24361 PyThreadState* __tstate = wxPyBeginAllowThreads();
24362 {
24363 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24364 result = (wxTimeSpan *) &_result_ref;
24365 }
24366
24367 wxPyEndAllowThreads(__tstate);
24368 if (PyErr_Occurred()) SWIG_fail;
24369 }
24370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24371 return resultobj;
24372 fail:
24373 return NULL;
24374 }
24375
24376
24377 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24378 PyObject *resultobj;
24379 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24380 wxTimeSpan *result;
24381 PyObject * obj0 = 0 ;
24382 char *kwnames[] = {
24383 (char *) "self", NULL
24384 };
24385
24386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24388 if (SWIG_arg_fail(1)) SWIG_fail;
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 {
24392 wxTimeSpan &_result_ref = (arg1)->Neg();
24393 result = (wxTimeSpan *) &_result_ref;
24394 }
24395
24396 wxPyEndAllowThreads(__tstate);
24397 if (PyErr_Occurred()) SWIG_fail;
24398 }
24399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24400 return resultobj;
24401 fail:
24402 return NULL;
24403 }
24404
24405
24406 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj;
24408 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24409 wxTimeSpan result;
24410 PyObject * obj0 = 0 ;
24411 char *kwnames[] = {
24412 (char *) "self", NULL
24413 };
24414
24415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24417 if (SWIG_arg_fail(1)) SWIG_fail;
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 result = ((wxTimeSpan const *)arg1)->Abs();
24421
24422 wxPyEndAllowThreads(__tstate);
24423 if (PyErr_Occurred()) SWIG_fail;
24424 }
24425 {
24426 wxTimeSpan * resultptr;
24427 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24429 }
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24437 PyObject *resultobj;
24438 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24439 wxTimeSpan *arg2 = 0 ;
24440 wxTimeSpan *result;
24441 PyObject * obj0 = 0 ;
24442 PyObject * obj1 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "self",(char *) "diff", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24449 if (SWIG_arg_fail(1)) SWIG_fail;
24450 {
24451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24452 if (SWIG_arg_fail(2)) SWIG_fail;
24453 if (arg2 == NULL) {
24454 SWIG_null_ref("wxTimeSpan");
24455 }
24456 if (SWIG_arg_fail(2)) SWIG_fail;
24457 }
24458 {
24459 PyThreadState* __tstate = wxPyBeginAllowThreads();
24460 {
24461 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24462 result = (wxTimeSpan *) &_result_ref;
24463 }
24464
24465 wxPyEndAllowThreads(__tstate);
24466 if (PyErr_Occurred()) SWIG_fail;
24467 }
24468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24476 PyObject *resultobj;
24477 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24478 wxTimeSpan *arg2 = 0 ;
24479 wxTimeSpan *result;
24480 PyObject * obj0 = 0 ;
24481 PyObject * obj1 = 0 ;
24482 char *kwnames[] = {
24483 (char *) "self",(char *) "diff", NULL
24484 };
24485
24486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24488 if (SWIG_arg_fail(1)) SWIG_fail;
24489 {
24490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24491 if (SWIG_arg_fail(2)) SWIG_fail;
24492 if (arg2 == NULL) {
24493 SWIG_null_ref("wxTimeSpan");
24494 }
24495 if (SWIG_arg_fail(2)) SWIG_fail;
24496 }
24497 {
24498 PyThreadState* __tstate = wxPyBeginAllowThreads();
24499 {
24500 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24501 result = (wxTimeSpan *) &_result_ref;
24502 }
24503
24504 wxPyEndAllowThreads(__tstate);
24505 if (PyErr_Occurred()) SWIG_fail;
24506 }
24507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24508 return resultobj;
24509 fail:
24510 return NULL;
24511 }
24512
24513
24514 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24515 PyObject *resultobj;
24516 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24517 int arg2 ;
24518 wxTimeSpan *result;
24519 PyObject * obj0 = 0 ;
24520 PyObject * obj1 = 0 ;
24521 char *kwnames[] = {
24522 (char *) "self",(char *) "n", NULL
24523 };
24524
24525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24527 if (SWIG_arg_fail(1)) SWIG_fail;
24528 {
24529 arg2 = (int)(SWIG_As_int(obj1));
24530 if (SWIG_arg_fail(2)) SWIG_fail;
24531 }
24532 {
24533 PyThreadState* __tstate = wxPyBeginAllowThreads();
24534 {
24535 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24536 result = (wxTimeSpan *) &_result_ref;
24537 }
24538
24539 wxPyEndAllowThreads(__tstate);
24540 if (PyErr_Occurred()) SWIG_fail;
24541 }
24542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24543 return resultobj;
24544 fail:
24545 return NULL;
24546 }
24547
24548
24549 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24550 PyObject *resultobj;
24551 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24552 wxTimeSpan *result;
24553 PyObject * obj0 = 0 ;
24554 char *kwnames[] = {
24555 (char *) "self", NULL
24556 };
24557
24558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24560 if (SWIG_arg_fail(1)) SWIG_fail;
24561 {
24562 PyThreadState* __tstate = wxPyBeginAllowThreads();
24563 {
24564 wxTimeSpan &_result_ref = (arg1)->operator -();
24565 result = (wxTimeSpan *) &_result_ref;
24566 }
24567
24568 wxPyEndAllowThreads(__tstate);
24569 if (PyErr_Occurred()) SWIG_fail;
24570 }
24571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24572 return resultobj;
24573 fail:
24574 return NULL;
24575 }
24576
24577
24578 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24579 PyObject *resultobj;
24580 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24581 wxTimeSpan *arg2 = 0 ;
24582 wxTimeSpan result;
24583 PyObject * obj0 = 0 ;
24584 PyObject * obj1 = 0 ;
24585 char *kwnames[] = {
24586 (char *) "self",(char *) "other", NULL
24587 };
24588
24589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24591 if (SWIG_arg_fail(1)) SWIG_fail;
24592 {
24593 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24594 if (SWIG_arg_fail(2)) SWIG_fail;
24595 if (arg2 == NULL) {
24596 SWIG_null_ref("wxTimeSpan");
24597 }
24598 if (SWIG_arg_fail(2)) SWIG_fail;
24599 }
24600 {
24601 PyThreadState* __tstate = wxPyBeginAllowThreads();
24602 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24603
24604 wxPyEndAllowThreads(__tstate);
24605 if (PyErr_Occurred()) SWIG_fail;
24606 }
24607 {
24608 wxTimeSpan * resultptr;
24609 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24610 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24611 }
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24619 PyObject *resultobj;
24620 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24621 wxTimeSpan *arg2 = 0 ;
24622 wxTimeSpan result;
24623 PyObject * obj0 = 0 ;
24624 PyObject * obj1 = 0 ;
24625 char *kwnames[] = {
24626 (char *) "self",(char *) "other", NULL
24627 };
24628
24629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24631 if (SWIG_arg_fail(1)) SWIG_fail;
24632 {
24633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24634 if (SWIG_arg_fail(2)) SWIG_fail;
24635 if (arg2 == NULL) {
24636 SWIG_null_ref("wxTimeSpan");
24637 }
24638 if (SWIG_arg_fail(2)) SWIG_fail;
24639 }
24640 {
24641 PyThreadState* __tstate = wxPyBeginAllowThreads();
24642 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24643
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 {
24648 wxTimeSpan * resultptr;
24649 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24650 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24651 }
24652 return resultobj;
24653 fail:
24654 return NULL;
24655 }
24656
24657
24658 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24659 PyObject *resultobj;
24660 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24661 int arg2 ;
24662 wxTimeSpan result;
24663 PyObject * obj0 = 0 ;
24664 PyObject * obj1 = 0 ;
24665 char *kwnames[] = {
24666 (char *) "self",(char *) "n", NULL
24667 };
24668
24669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24671 if (SWIG_arg_fail(1)) SWIG_fail;
24672 {
24673 arg2 = (int)(SWIG_As_int(obj1));
24674 if (SWIG_arg_fail(2)) SWIG_fail;
24675 }
24676 {
24677 PyThreadState* __tstate = wxPyBeginAllowThreads();
24678 result = wxTimeSpan___mul__(arg1,arg2);
24679
24680 wxPyEndAllowThreads(__tstate);
24681 if (PyErr_Occurred()) SWIG_fail;
24682 }
24683 {
24684 wxTimeSpan * resultptr;
24685 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24686 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24687 }
24688 return resultobj;
24689 fail:
24690 return NULL;
24691 }
24692
24693
24694 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24695 PyObject *resultobj;
24696 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24697 int arg2 ;
24698 wxTimeSpan result;
24699 PyObject * obj0 = 0 ;
24700 PyObject * obj1 = 0 ;
24701 char *kwnames[] = {
24702 (char *) "self",(char *) "n", NULL
24703 };
24704
24705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24707 if (SWIG_arg_fail(1)) SWIG_fail;
24708 {
24709 arg2 = (int)(SWIG_As_int(obj1));
24710 if (SWIG_arg_fail(2)) SWIG_fail;
24711 }
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = wxTimeSpan___rmul__(arg1,arg2);
24715
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 {
24720 wxTimeSpan * resultptr;
24721 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24722 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24723 }
24724 return resultobj;
24725 fail:
24726 return NULL;
24727 }
24728
24729
24730 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24731 PyObject *resultobj;
24732 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24733 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24734 bool result;
24735 PyObject * obj0 = 0 ;
24736 PyObject * obj1 = 0 ;
24737 char *kwnames[] = {
24738 (char *) "self",(char *) "other", NULL
24739 };
24740
24741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24743 if (SWIG_arg_fail(1)) SWIG_fail;
24744 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24745 if (SWIG_arg_fail(2)) SWIG_fail;
24746 {
24747 PyThreadState* __tstate = wxPyBeginAllowThreads();
24748 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24749
24750 wxPyEndAllowThreads(__tstate);
24751 if (PyErr_Occurred()) SWIG_fail;
24752 }
24753 {
24754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24755 }
24756 return resultobj;
24757 fail:
24758 return NULL;
24759 }
24760
24761
24762 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24763 PyObject *resultobj;
24764 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24765 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24766 bool result;
24767 PyObject * obj0 = 0 ;
24768 PyObject * obj1 = 0 ;
24769 char *kwnames[] = {
24770 (char *) "self",(char *) "other", NULL
24771 };
24772
24773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24775 if (SWIG_arg_fail(1)) SWIG_fail;
24776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24777 if (SWIG_arg_fail(2)) SWIG_fail;
24778 {
24779 PyThreadState* __tstate = wxPyBeginAllowThreads();
24780 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24781
24782 wxPyEndAllowThreads(__tstate);
24783 if (PyErr_Occurred()) SWIG_fail;
24784 }
24785 {
24786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24787 }
24788 return resultobj;
24789 fail:
24790 return NULL;
24791 }
24792
24793
24794 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj;
24796 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24797 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24798 bool result;
24799 PyObject * obj0 = 0 ;
24800 PyObject * obj1 = 0 ;
24801 char *kwnames[] = {
24802 (char *) "self",(char *) "other", NULL
24803 };
24804
24805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24807 if (SWIG_arg_fail(1)) SWIG_fail;
24808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24809 if (SWIG_arg_fail(2)) SWIG_fail;
24810 {
24811 PyThreadState* __tstate = wxPyBeginAllowThreads();
24812 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24813
24814 wxPyEndAllowThreads(__tstate);
24815 if (PyErr_Occurred()) SWIG_fail;
24816 }
24817 {
24818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24819 }
24820 return resultobj;
24821 fail:
24822 return NULL;
24823 }
24824
24825
24826 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24827 PyObject *resultobj;
24828 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24829 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24830 bool result;
24831 PyObject * obj0 = 0 ;
24832 PyObject * obj1 = 0 ;
24833 char *kwnames[] = {
24834 (char *) "self",(char *) "other", NULL
24835 };
24836
24837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24839 if (SWIG_arg_fail(1)) SWIG_fail;
24840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24841 if (SWIG_arg_fail(2)) SWIG_fail;
24842 {
24843 PyThreadState* __tstate = wxPyBeginAllowThreads();
24844 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24845
24846 wxPyEndAllowThreads(__tstate);
24847 if (PyErr_Occurred()) SWIG_fail;
24848 }
24849 {
24850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24851 }
24852 return resultobj;
24853 fail:
24854 return NULL;
24855 }
24856
24857
24858 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24859 PyObject *resultobj;
24860 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24861 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24862 bool result;
24863 PyObject * obj0 = 0 ;
24864 PyObject * obj1 = 0 ;
24865 char *kwnames[] = {
24866 (char *) "self",(char *) "other", NULL
24867 };
24868
24869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24871 if (SWIG_arg_fail(1)) SWIG_fail;
24872 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24873 if (SWIG_arg_fail(2)) SWIG_fail;
24874 {
24875 PyThreadState* __tstate = wxPyBeginAllowThreads();
24876 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24877
24878 wxPyEndAllowThreads(__tstate);
24879 if (PyErr_Occurred()) SWIG_fail;
24880 }
24881 {
24882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24883 }
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24891 PyObject *resultobj;
24892 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24893 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24894 bool result;
24895 PyObject * obj0 = 0 ;
24896 PyObject * obj1 = 0 ;
24897 char *kwnames[] = {
24898 (char *) "self",(char *) "other", NULL
24899 };
24900
24901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24903 if (SWIG_arg_fail(1)) SWIG_fail;
24904 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24905 if (SWIG_arg_fail(2)) SWIG_fail;
24906 {
24907 PyThreadState* __tstate = wxPyBeginAllowThreads();
24908 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24909
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 {
24914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24915 }
24916 return resultobj;
24917 fail:
24918 return NULL;
24919 }
24920
24921
24922 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24923 PyObject *resultobj;
24924 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24925 bool result;
24926 PyObject * obj0 = 0 ;
24927 char *kwnames[] = {
24928 (char *) "self", NULL
24929 };
24930
24931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24933 if (SWIG_arg_fail(1)) SWIG_fail;
24934 {
24935 PyThreadState* __tstate = wxPyBeginAllowThreads();
24936 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24937
24938 wxPyEndAllowThreads(__tstate);
24939 if (PyErr_Occurred()) SWIG_fail;
24940 }
24941 {
24942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24943 }
24944 return resultobj;
24945 fail:
24946 return NULL;
24947 }
24948
24949
24950 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24951 PyObject *resultobj;
24952 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24953 bool result;
24954 PyObject * obj0 = 0 ;
24955 char *kwnames[] = {
24956 (char *) "self", NULL
24957 };
24958
24959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24961 if (SWIG_arg_fail(1)) SWIG_fail;
24962 {
24963 PyThreadState* __tstate = wxPyBeginAllowThreads();
24964 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24965
24966 wxPyEndAllowThreads(__tstate);
24967 if (PyErr_Occurred()) SWIG_fail;
24968 }
24969 {
24970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24971 }
24972 return resultobj;
24973 fail:
24974 return NULL;
24975 }
24976
24977
24978 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24979 PyObject *resultobj;
24980 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24981 bool result;
24982 PyObject * obj0 = 0 ;
24983 char *kwnames[] = {
24984 (char *) "self", NULL
24985 };
24986
24987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24989 if (SWIG_arg_fail(1)) SWIG_fail;
24990 {
24991 PyThreadState* __tstate = wxPyBeginAllowThreads();
24992 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24993
24994 wxPyEndAllowThreads(__tstate);
24995 if (PyErr_Occurred()) SWIG_fail;
24996 }
24997 {
24998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24999 }
25000 return resultobj;
25001 fail:
25002 return NULL;
25003 }
25004
25005
25006 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
25007 PyObject *resultobj;
25008 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25009 wxTimeSpan *arg2 = 0 ;
25010 bool result;
25011 PyObject * obj0 = 0 ;
25012 PyObject * obj1 = 0 ;
25013 char *kwnames[] = {
25014 (char *) "self",(char *) "ts", NULL
25015 };
25016
25017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25019 if (SWIG_arg_fail(1)) SWIG_fail;
25020 {
25021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25022 if (SWIG_arg_fail(2)) SWIG_fail;
25023 if (arg2 == NULL) {
25024 SWIG_null_ref("wxTimeSpan");
25025 }
25026 if (SWIG_arg_fail(2)) SWIG_fail;
25027 }
25028 {
25029 PyThreadState* __tstate = wxPyBeginAllowThreads();
25030 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25031
25032 wxPyEndAllowThreads(__tstate);
25033 if (PyErr_Occurred()) SWIG_fail;
25034 }
25035 {
25036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25037 }
25038 return resultobj;
25039 fail:
25040 return NULL;
25041 }
25042
25043
25044 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25045 PyObject *resultobj;
25046 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25047 wxTimeSpan *arg2 = 0 ;
25048 bool result;
25049 PyObject * obj0 = 0 ;
25050 PyObject * obj1 = 0 ;
25051 char *kwnames[] = {
25052 (char *) "self",(char *) "ts", NULL
25053 };
25054
25055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25057 if (SWIG_arg_fail(1)) SWIG_fail;
25058 {
25059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25060 if (SWIG_arg_fail(2)) SWIG_fail;
25061 if (arg2 == NULL) {
25062 SWIG_null_ref("wxTimeSpan");
25063 }
25064 if (SWIG_arg_fail(2)) SWIG_fail;
25065 }
25066 {
25067 PyThreadState* __tstate = wxPyBeginAllowThreads();
25068 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25069
25070 wxPyEndAllowThreads(__tstate);
25071 if (PyErr_Occurred()) SWIG_fail;
25072 }
25073 {
25074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25075 }
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25083 PyObject *resultobj;
25084 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25085 wxTimeSpan *arg2 = 0 ;
25086 bool result;
25087 PyObject * obj0 = 0 ;
25088 PyObject * obj1 = 0 ;
25089 char *kwnames[] = {
25090 (char *) "self",(char *) "t", NULL
25091 };
25092
25093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25095 if (SWIG_arg_fail(1)) SWIG_fail;
25096 {
25097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25098 if (SWIG_arg_fail(2)) SWIG_fail;
25099 if (arg2 == NULL) {
25100 SWIG_null_ref("wxTimeSpan");
25101 }
25102 if (SWIG_arg_fail(2)) SWIG_fail;
25103 }
25104 {
25105 PyThreadState* __tstate = wxPyBeginAllowThreads();
25106 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25107
25108 wxPyEndAllowThreads(__tstate);
25109 if (PyErr_Occurred()) SWIG_fail;
25110 }
25111 {
25112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25113 }
25114 return resultobj;
25115 fail:
25116 return NULL;
25117 }
25118
25119
25120 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25121 PyObject *resultobj;
25122 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25123 int result;
25124 PyObject * obj0 = 0 ;
25125 char *kwnames[] = {
25126 (char *) "self", NULL
25127 };
25128
25129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25131 if (SWIG_arg_fail(1)) SWIG_fail;
25132 {
25133 PyThreadState* __tstate = wxPyBeginAllowThreads();
25134 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25135
25136 wxPyEndAllowThreads(__tstate);
25137 if (PyErr_Occurred()) SWIG_fail;
25138 }
25139 {
25140 resultobj = SWIG_From_int((int)(result));
25141 }
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25149 PyObject *resultobj;
25150 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25151 int result;
25152 PyObject * obj0 = 0 ;
25153 char *kwnames[] = {
25154 (char *) "self", NULL
25155 };
25156
25157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25159 if (SWIG_arg_fail(1)) SWIG_fail;
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25163
25164 wxPyEndAllowThreads(__tstate);
25165 if (PyErr_Occurred()) SWIG_fail;
25166 }
25167 {
25168 resultobj = SWIG_From_int((int)(result));
25169 }
25170 return resultobj;
25171 fail:
25172 return NULL;
25173 }
25174
25175
25176 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25177 PyObject *resultobj;
25178 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25179 int result;
25180 PyObject * obj0 = 0 ;
25181 char *kwnames[] = {
25182 (char *) "self", NULL
25183 };
25184
25185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25187 if (SWIG_arg_fail(1)) SWIG_fail;
25188 {
25189 PyThreadState* __tstate = wxPyBeginAllowThreads();
25190 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25191
25192 wxPyEndAllowThreads(__tstate);
25193 if (PyErr_Occurred()) SWIG_fail;
25194 }
25195 {
25196 resultobj = SWIG_From_int((int)(result));
25197 }
25198 return resultobj;
25199 fail:
25200 return NULL;
25201 }
25202
25203
25204 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25205 PyObject *resultobj;
25206 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25207 int result;
25208 PyObject * obj0 = 0 ;
25209 char *kwnames[] = {
25210 (char *) "self", NULL
25211 };
25212
25213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25215 if (SWIG_arg_fail(1)) SWIG_fail;
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25219
25220 wxPyEndAllowThreads(__tstate);
25221 if (PyErr_Occurred()) SWIG_fail;
25222 }
25223 {
25224 resultobj = SWIG_From_int((int)(result));
25225 }
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25233 PyObject *resultobj;
25234 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25235 wxLongLong result;
25236 PyObject * obj0 = 0 ;
25237 char *kwnames[] = {
25238 (char *) "self", NULL
25239 };
25240
25241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25243 if (SWIG_arg_fail(1)) SWIG_fail;
25244 {
25245 PyThreadState* __tstate = wxPyBeginAllowThreads();
25246 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25247
25248 wxPyEndAllowThreads(__tstate);
25249 if (PyErr_Occurred()) SWIG_fail;
25250 }
25251 {
25252 PyObject *hi, *lo, *shifter, *shifted;
25253 hi = PyLong_FromLong( (&result)->GetHi() );
25254 lo = PyLong_FromLong( (&result)->GetLo() );
25255 shifter = PyLong_FromLong(32);
25256 shifted = PyNumber_Lshift(hi, shifter);
25257 resultobj = PyNumber_Or(shifted, lo);
25258 Py_DECREF(hi);
25259 Py_DECREF(lo);
25260 Py_DECREF(shifter);
25261 Py_DECREF(shifted);
25262 }
25263 return resultobj;
25264 fail:
25265 return NULL;
25266 }
25267
25268
25269 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25270 PyObject *resultobj;
25271 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25272 wxLongLong result;
25273 PyObject * obj0 = 0 ;
25274 char *kwnames[] = {
25275 (char *) "self", NULL
25276 };
25277
25278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25280 if (SWIG_arg_fail(1)) SWIG_fail;
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25284
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 {
25289 PyObject *hi, *lo, *shifter, *shifted;
25290 hi = PyLong_FromLong( (&result)->GetHi() );
25291 lo = PyLong_FromLong( (&result)->GetLo() );
25292 shifter = PyLong_FromLong(32);
25293 shifted = PyNumber_Lshift(hi, shifter);
25294 resultobj = PyNumber_Or(shifted, lo);
25295 Py_DECREF(hi);
25296 Py_DECREF(lo);
25297 Py_DECREF(shifter);
25298 Py_DECREF(shifted);
25299 }
25300 return resultobj;
25301 fail:
25302 return NULL;
25303 }
25304
25305
25306 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25307 PyObject *resultobj;
25308 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25309 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25310 wxString *arg2 = (wxString *) &arg2_defvalue ;
25311 wxString result;
25312 bool temp2 = false ;
25313 PyObject * obj0 = 0 ;
25314 PyObject * obj1 = 0 ;
25315 char *kwnames[] = {
25316 (char *) "self",(char *) "format", NULL
25317 };
25318
25319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25321 if (SWIG_arg_fail(1)) SWIG_fail;
25322 if (obj1) {
25323 {
25324 arg2 = wxString_in_helper(obj1);
25325 if (arg2 == NULL) SWIG_fail;
25326 temp2 = true;
25327 }
25328 }
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25332
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 {
25337 #if wxUSE_UNICODE
25338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25339 #else
25340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25341 #endif
25342 }
25343 {
25344 if (temp2)
25345 delete arg2;
25346 }
25347 return resultobj;
25348 fail:
25349 {
25350 if (temp2)
25351 delete arg2;
25352 }
25353 return NULL;
25354 }
25355
25356
25357 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25358 PyObject *obj;
25359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25360 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25361 Py_INCREF(obj);
25362 return Py_BuildValue((char *)"");
25363 }
25364 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj;
25366 int arg1 = (int) 0 ;
25367 int arg2 = (int) 0 ;
25368 int arg3 = (int) 0 ;
25369 int arg4 = (int) 0 ;
25370 wxDateSpan *result;
25371 PyObject * obj0 = 0 ;
25372 PyObject * obj1 = 0 ;
25373 PyObject * obj2 = 0 ;
25374 PyObject * obj3 = 0 ;
25375 char *kwnames[] = {
25376 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25377 };
25378
25379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25380 if (obj0) {
25381 {
25382 arg1 = (int)(SWIG_As_int(obj0));
25383 if (SWIG_arg_fail(1)) SWIG_fail;
25384 }
25385 }
25386 if (obj1) {
25387 {
25388 arg2 = (int)(SWIG_As_int(obj1));
25389 if (SWIG_arg_fail(2)) SWIG_fail;
25390 }
25391 }
25392 if (obj2) {
25393 {
25394 arg3 = (int)(SWIG_As_int(obj2));
25395 if (SWIG_arg_fail(3)) SWIG_fail;
25396 }
25397 }
25398 if (obj3) {
25399 {
25400 arg4 = (int)(SWIG_As_int(obj3));
25401 if (SWIG_arg_fail(4)) SWIG_fail;
25402 }
25403 }
25404 {
25405 PyThreadState* __tstate = wxPyBeginAllowThreads();
25406 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25407
25408 wxPyEndAllowThreads(__tstate);
25409 if (PyErr_Occurred()) SWIG_fail;
25410 }
25411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25419 PyObject *resultobj;
25420 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25421 PyObject * obj0 = 0 ;
25422 char *kwnames[] = {
25423 (char *) "self", NULL
25424 };
25425
25426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25428 if (SWIG_arg_fail(1)) SWIG_fail;
25429 {
25430 PyThreadState* __tstate = wxPyBeginAllowThreads();
25431 delete arg1;
25432
25433 wxPyEndAllowThreads(__tstate);
25434 if (PyErr_Occurred()) SWIG_fail;
25435 }
25436 Py_INCREF(Py_None); resultobj = Py_None;
25437 return resultobj;
25438 fail:
25439 return NULL;
25440 }
25441
25442
25443 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25444 PyObject *resultobj;
25445 int arg1 ;
25446 wxDateSpan result;
25447 PyObject * obj0 = 0 ;
25448 char *kwnames[] = {
25449 (char *) "days", NULL
25450 };
25451
25452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25453 {
25454 arg1 = (int)(SWIG_As_int(obj0));
25455 if (SWIG_arg_fail(1)) SWIG_fail;
25456 }
25457 {
25458 PyThreadState* __tstate = wxPyBeginAllowThreads();
25459 result = wxDateSpan::Days(arg1);
25460
25461 wxPyEndAllowThreads(__tstate);
25462 if (PyErr_Occurred()) SWIG_fail;
25463 }
25464 {
25465 wxDateSpan * resultptr;
25466 resultptr = new wxDateSpan((wxDateSpan &)(result));
25467 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25468 }
25469 return resultobj;
25470 fail:
25471 return NULL;
25472 }
25473
25474
25475 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25476 PyObject *resultobj;
25477 wxDateSpan result;
25478 char *kwnames[] = {
25479 NULL
25480 };
25481
25482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25483 {
25484 PyThreadState* __tstate = wxPyBeginAllowThreads();
25485 result = wxDateSpan::Day();
25486
25487 wxPyEndAllowThreads(__tstate);
25488 if (PyErr_Occurred()) SWIG_fail;
25489 }
25490 {
25491 wxDateSpan * resultptr;
25492 resultptr = new wxDateSpan((wxDateSpan &)(result));
25493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25494 }
25495 return resultobj;
25496 fail:
25497 return NULL;
25498 }
25499
25500
25501 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25502 PyObject *resultobj;
25503 int arg1 ;
25504 wxDateSpan result;
25505 PyObject * obj0 = 0 ;
25506 char *kwnames[] = {
25507 (char *) "weeks", NULL
25508 };
25509
25510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25511 {
25512 arg1 = (int)(SWIG_As_int(obj0));
25513 if (SWIG_arg_fail(1)) SWIG_fail;
25514 }
25515 {
25516 PyThreadState* __tstate = wxPyBeginAllowThreads();
25517 result = wxDateSpan::Weeks(arg1);
25518
25519 wxPyEndAllowThreads(__tstate);
25520 if (PyErr_Occurred()) SWIG_fail;
25521 }
25522 {
25523 wxDateSpan * resultptr;
25524 resultptr = new wxDateSpan((wxDateSpan &)(result));
25525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25526 }
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25534 PyObject *resultobj;
25535 wxDateSpan result;
25536 char *kwnames[] = {
25537 NULL
25538 };
25539
25540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25541 {
25542 PyThreadState* __tstate = wxPyBeginAllowThreads();
25543 result = wxDateSpan::Week();
25544
25545 wxPyEndAllowThreads(__tstate);
25546 if (PyErr_Occurred()) SWIG_fail;
25547 }
25548 {
25549 wxDateSpan * resultptr;
25550 resultptr = new wxDateSpan((wxDateSpan &)(result));
25551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25552 }
25553 return resultobj;
25554 fail:
25555 return NULL;
25556 }
25557
25558
25559 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25560 PyObject *resultobj;
25561 int arg1 ;
25562 wxDateSpan result;
25563 PyObject * obj0 = 0 ;
25564 char *kwnames[] = {
25565 (char *) "mon", NULL
25566 };
25567
25568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25569 {
25570 arg1 = (int)(SWIG_As_int(obj0));
25571 if (SWIG_arg_fail(1)) SWIG_fail;
25572 }
25573 {
25574 PyThreadState* __tstate = wxPyBeginAllowThreads();
25575 result = wxDateSpan::Months(arg1);
25576
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 {
25581 wxDateSpan * resultptr;
25582 resultptr = new wxDateSpan((wxDateSpan &)(result));
25583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25584 }
25585 return resultobj;
25586 fail:
25587 return NULL;
25588 }
25589
25590
25591 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25592 PyObject *resultobj;
25593 wxDateSpan result;
25594 char *kwnames[] = {
25595 NULL
25596 };
25597
25598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25599 {
25600 PyThreadState* __tstate = wxPyBeginAllowThreads();
25601 result = wxDateSpan::Month();
25602
25603 wxPyEndAllowThreads(__tstate);
25604 if (PyErr_Occurred()) SWIG_fail;
25605 }
25606 {
25607 wxDateSpan * resultptr;
25608 resultptr = new wxDateSpan((wxDateSpan &)(result));
25609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25610 }
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25618 PyObject *resultobj;
25619 int arg1 ;
25620 wxDateSpan result;
25621 PyObject * obj0 = 0 ;
25622 char *kwnames[] = {
25623 (char *) "years", NULL
25624 };
25625
25626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25627 {
25628 arg1 = (int)(SWIG_As_int(obj0));
25629 if (SWIG_arg_fail(1)) SWIG_fail;
25630 }
25631 {
25632 PyThreadState* __tstate = wxPyBeginAllowThreads();
25633 result = wxDateSpan::Years(arg1);
25634
25635 wxPyEndAllowThreads(__tstate);
25636 if (PyErr_Occurred()) SWIG_fail;
25637 }
25638 {
25639 wxDateSpan * resultptr;
25640 resultptr = new wxDateSpan((wxDateSpan &)(result));
25641 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25642 }
25643 return resultobj;
25644 fail:
25645 return NULL;
25646 }
25647
25648
25649 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25650 PyObject *resultobj;
25651 wxDateSpan result;
25652 char *kwnames[] = {
25653 NULL
25654 };
25655
25656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25657 {
25658 PyThreadState* __tstate = wxPyBeginAllowThreads();
25659 result = wxDateSpan::Year();
25660
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 {
25665 wxDateSpan * resultptr;
25666 resultptr = new wxDateSpan((wxDateSpan &)(result));
25667 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25668 }
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25676 PyObject *resultobj;
25677 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25678 int arg2 ;
25679 wxDateSpan *result;
25680 PyObject * obj0 = 0 ;
25681 PyObject * obj1 = 0 ;
25682 char *kwnames[] = {
25683 (char *) "self",(char *) "n", NULL
25684 };
25685
25686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25688 if (SWIG_arg_fail(1)) SWIG_fail;
25689 {
25690 arg2 = (int)(SWIG_As_int(obj1));
25691 if (SWIG_arg_fail(2)) SWIG_fail;
25692 }
25693 {
25694 PyThreadState* __tstate = wxPyBeginAllowThreads();
25695 {
25696 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25697 result = (wxDateSpan *) &_result_ref;
25698 }
25699
25700 wxPyEndAllowThreads(__tstate);
25701 if (PyErr_Occurred()) SWIG_fail;
25702 }
25703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25704 return resultobj;
25705 fail:
25706 return NULL;
25707 }
25708
25709
25710 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj;
25712 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25713 int arg2 ;
25714 wxDateSpan *result;
25715 PyObject * obj0 = 0 ;
25716 PyObject * obj1 = 0 ;
25717 char *kwnames[] = {
25718 (char *) "self",(char *) "n", NULL
25719 };
25720
25721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25723 if (SWIG_arg_fail(1)) SWIG_fail;
25724 {
25725 arg2 = (int)(SWIG_As_int(obj1));
25726 if (SWIG_arg_fail(2)) SWIG_fail;
25727 }
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 {
25731 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25732 result = (wxDateSpan *) &_result_ref;
25733 }
25734
25735 wxPyEndAllowThreads(__tstate);
25736 if (PyErr_Occurred()) SWIG_fail;
25737 }
25738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25739 return resultobj;
25740 fail:
25741 return NULL;
25742 }
25743
25744
25745 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25746 PyObject *resultobj;
25747 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25748 int arg2 ;
25749 wxDateSpan *result;
25750 PyObject * obj0 = 0 ;
25751 PyObject * obj1 = 0 ;
25752 char *kwnames[] = {
25753 (char *) "self",(char *) "n", NULL
25754 };
25755
25756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25758 if (SWIG_arg_fail(1)) SWIG_fail;
25759 {
25760 arg2 = (int)(SWIG_As_int(obj1));
25761 if (SWIG_arg_fail(2)) SWIG_fail;
25762 }
25763 {
25764 PyThreadState* __tstate = wxPyBeginAllowThreads();
25765 {
25766 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25767 result = (wxDateSpan *) &_result_ref;
25768 }
25769
25770 wxPyEndAllowThreads(__tstate);
25771 if (PyErr_Occurred()) SWIG_fail;
25772 }
25773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25774 return resultobj;
25775 fail:
25776 return NULL;
25777 }
25778
25779
25780 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25781 PyObject *resultobj;
25782 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25783 int arg2 ;
25784 wxDateSpan *result;
25785 PyObject * obj0 = 0 ;
25786 PyObject * obj1 = 0 ;
25787 char *kwnames[] = {
25788 (char *) "self",(char *) "n", NULL
25789 };
25790
25791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25793 if (SWIG_arg_fail(1)) SWIG_fail;
25794 {
25795 arg2 = (int)(SWIG_As_int(obj1));
25796 if (SWIG_arg_fail(2)) SWIG_fail;
25797 }
25798 {
25799 PyThreadState* __tstate = wxPyBeginAllowThreads();
25800 {
25801 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25802 result = (wxDateSpan *) &_result_ref;
25803 }
25804
25805 wxPyEndAllowThreads(__tstate);
25806 if (PyErr_Occurred()) SWIG_fail;
25807 }
25808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25809 return resultobj;
25810 fail:
25811 return NULL;
25812 }
25813
25814
25815 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25816 PyObject *resultobj;
25817 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25818 int result;
25819 PyObject * obj0 = 0 ;
25820 char *kwnames[] = {
25821 (char *) "self", NULL
25822 };
25823
25824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25826 if (SWIG_arg_fail(1)) SWIG_fail;
25827 {
25828 PyThreadState* __tstate = wxPyBeginAllowThreads();
25829 result = (int)((wxDateSpan const *)arg1)->GetYears();
25830
25831 wxPyEndAllowThreads(__tstate);
25832 if (PyErr_Occurred()) SWIG_fail;
25833 }
25834 {
25835 resultobj = SWIG_From_int((int)(result));
25836 }
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25844 PyObject *resultobj;
25845 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25846 int result;
25847 PyObject * obj0 = 0 ;
25848 char *kwnames[] = {
25849 (char *) "self", NULL
25850 };
25851
25852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25854 if (SWIG_arg_fail(1)) SWIG_fail;
25855 {
25856 PyThreadState* __tstate = wxPyBeginAllowThreads();
25857 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25858
25859 wxPyEndAllowThreads(__tstate);
25860 if (PyErr_Occurred()) SWIG_fail;
25861 }
25862 {
25863 resultobj = SWIG_From_int((int)(result));
25864 }
25865 return resultobj;
25866 fail:
25867 return NULL;
25868 }
25869
25870
25871 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25872 PyObject *resultobj;
25873 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25874 int result;
25875 PyObject * obj0 = 0 ;
25876 char *kwnames[] = {
25877 (char *) "self", NULL
25878 };
25879
25880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25882 if (SWIG_arg_fail(1)) SWIG_fail;
25883 {
25884 PyThreadState* __tstate = wxPyBeginAllowThreads();
25885 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25886
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 {
25891 resultobj = SWIG_From_int((int)(result));
25892 }
25893 return resultobj;
25894 fail:
25895 return NULL;
25896 }
25897
25898
25899 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25900 PyObject *resultobj;
25901 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25902 int result;
25903 PyObject * obj0 = 0 ;
25904 char *kwnames[] = {
25905 (char *) "self", NULL
25906 };
25907
25908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25910 if (SWIG_arg_fail(1)) SWIG_fail;
25911 {
25912 PyThreadState* __tstate = wxPyBeginAllowThreads();
25913 result = (int)((wxDateSpan const *)arg1)->GetDays();
25914
25915 wxPyEndAllowThreads(__tstate);
25916 if (PyErr_Occurred()) SWIG_fail;
25917 }
25918 {
25919 resultobj = SWIG_From_int((int)(result));
25920 }
25921 return resultobj;
25922 fail:
25923 return NULL;
25924 }
25925
25926
25927 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25928 PyObject *resultobj;
25929 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25930 int result;
25931 PyObject * obj0 = 0 ;
25932 char *kwnames[] = {
25933 (char *) "self", NULL
25934 };
25935
25936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25938 if (SWIG_arg_fail(1)) SWIG_fail;
25939 {
25940 PyThreadState* __tstate = wxPyBeginAllowThreads();
25941 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25942
25943 wxPyEndAllowThreads(__tstate);
25944 if (PyErr_Occurred()) SWIG_fail;
25945 }
25946 {
25947 resultobj = SWIG_From_int((int)(result));
25948 }
25949 return resultobj;
25950 fail:
25951 return NULL;
25952 }
25953
25954
25955 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25956 PyObject *resultobj;
25957 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25958 wxDateSpan *arg2 = 0 ;
25959 wxDateSpan *result;
25960 PyObject * obj0 = 0 ;
25961 PyObject * obj1 = 0 ;
25962 char *kwnames[] = {
25963 (char *) "self",(char *) "other", NULL
25964 };
25965
25966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25968 if (SWIG_arg_fail(1)) SWIG_fail;
25969 {
25970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25971 if (SWIG_arg_fail(2)) SWIG_fail;
25972 if (arg2 == NULL) {
25973 SWIG_null_ref("wxDateSpan");
25974 }
25975 if (SWIG_arg_fail(2)) SWIG_fail;
25976 }
25977 {
25978 PyThreadState* __tstate = wxPyBeginAllowThreads();
25979 {
25980 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25981 result = (wxDateSpan *) &_result_ref;
25982 }
25983
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25988 return resultobj;
25989 fail:
25990 return NULL;
25991 }
25992
25993
25994 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25995 PyObject *resultobj;
25996 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25997 wxDateSpan *arg2 = 0 ;
25998 wxDateSpan *result;
25999 PyObject * obj0 = 0 ;
26000 PyObject * obj1 = 0 ;
26001 char *kwnames[] = {
26002 (char *) "self",(char *) "other", NULL
26003 };
26004
26005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
26006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26007 if (SWIG_arg_fail(1)) SWIG_fail;
26008 {
26009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26010 if (SWIG_arg_fail(2)) SWIG_fail;
26011 if (arg2 == NULL) {
26012 SWIG_null_ref("wxDateSpan");
26013 }
26014 if (SWIG_arg_fail(2)) SWIG_fail;
26015 }
26016 {
26017 PyThreadState* __tstate = wxPyBeginAllowThreads();
26018 {
26019 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26020 result = (wxDateSpan *) &_result_ref;
26021 }
26022
26023 wxPyEndAllowThreads(__tstate);
26024 if (PyErr_Occurred()) SWIG_fail;
26025 }
26026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26027 return resultobj;
26028 fail:
26029 return NULL;
26030 }
26031
26032
26033 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26034 PyObject *resultobj;
26035 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26036 wxDateSpan *result;
26037 PyObject * obj0 = 0 ;
26038 char *kwnames[] = {
26039 (char *) "self", NULL
26040 };
26041
26042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26044 if (SWIG_arg_fail(1)) SWIG_fail;
26045 {
26046 PyThreadState* __tstate = wxPyBeginAllowThreads();
26047 {
26048 wxDateSpan &_result_ref = (arg1)->Neg();
26049 result = (wxDateSpan *) &_result_ref;
26050 }
26051
26052 wxPyEndAllowThreads(__tstate);
26053 if (PyErr_Occurred()) SWIG_fail;
26054 }
26055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26063 PyObject *resultobj;
26064 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26065 int arg2 ;
26066 wxDateSpan *result;
26067 PyObject * obj0 = 0 ;
26068 PyObject * obj1 = 0 ;
26069 char *kwnames[] = {
26070 (char *) "self",(char *) "factor", NULL
26071 };
26072
26073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26075 if (SWIG_arg_fail(1)) SWIG_fail;
26076 {
26077 arg2 = (int)(SWIG_As_int(obj1));
26078 if (SWIG_arg_fail(2)) SWIG_fail;
26079 }
26080 {
26081 PyThreadState* __tstate = wxPyBeginAllowThreads();
26082 {
26083 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26084 result = (wxDateSpan *) &_result_ref;
26085 }
26086
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj;
26099 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26100 wxDateSpan *arg2 = 0 ;
26101 wxDateSpan *result;
26102 PyObject * obj0 = 0 ;
26103 PyObject * obj1 = 0 ;
26104 char *kwnames[] = {
26105 (char *) "self",(char *) "other", NULL
26106 };
26107
26108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26110 if (SWIG_arg_fail(1)) SWIG_fail;
26111 {
26112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26113 if (SWIG_arg_fail(2)) SWIG_fail;
26114 if (arg2 == NULL) {
26115 SWIG_null_ref("wxDateSpan");
26116 }
26117 if (SWIG_arg_fail(2)) SWIG_fail;
26118 }
26119 {
26120 PyThreadState* __tstate = wxPyBeginAllowThreads();
26121 {
26122 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26123 result = (wxDateSpan *) &_result_ref;
26124 }
26125
26126 wxPyEndAllowThreads(__tstate);
26127 if (PyErr_Occurred()) SWIG_fail;
26128 }
26129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj;
26138 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26139 wxDateSpan *arg2 = 0 ;
26140 wxDateSpan *result;
26141 PyObject * obj0 = 0 ;
26142 PyObject * obj1 = 0 ;
26143 char *kwnames[] = {
26144 (char *) "self",(char *) "other", NULL
26145 };
26146
26147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26149 if (SWIG_arg_fail(1)) SWIG_fail;
26150 {
26151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26152 if (SWIG_arg_fail(2)) SWIG_fail;
26153 if (arg2 == NULL) {
26154 SWIG_null_ref("wxDateSpan");
26155 }
26156 if (SWIG_arg_fail(2)) SWIG_fail;
26157 }
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 {
26161 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26162 result = (wxDateSpan *) &_result_ref;
26163 }
26164
26165 wxPyEndAllowThreads(__tstate);
26166 if (PyErr_Occurred()) SWIG_fail;
26167 }
26168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26176 PyObject *resultobj;
26177 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26178 wxDateSpan *result;
26179 PyObject * obj0 = 0 ;
26180 char *kwnames[] = {
26181 (char *) "self", NULL
26182 };
26183
26184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26186 if (SWIG_arg_fail(1)) SWIG_fail;
26187 {
26188 PyThreadState* __tstate = wxPyBeginAllowThreads();
26189 {
26190 wxDateSpan &_result_ref = (arg1)->operator -();
26191 result = (wxDateSpan *) &_result_ref;
26192 }
26193
26194 wxPyEndAllowThreads(__tstate);
26195 if (PyErr_Occurred()) SWIG_fail;
26196 }
26197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26198 return resultobj;
26199 fail:
26200 return NULL;
26201 }
26202
26203
26204 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26205 PyObject *resultobj;
26206 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26207 int arg2 ;
26208 wxDateSpan *result;
26209 PyObject * obj0 = 0 ;
26210 PyObject * obj1 = 0 ;
26211 char *kwnames[] = {
26212 (char *) "self",(char *) "factor", NULL
26213 };
26214
26215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26217 if (SWIG_arg_fail(1)) SWIG_fail;
26218 {
26219 arg2 = (int)(SWIG_As_int(obj1));
26220 if (SWIG_arg_fail(2)) SWIG_fail;
26221 }
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 {
26225 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26226 result = (wxDateSpan *) &_result_ref;
26227 }
26228
26229 wxPyEndAllowThreads(__tstate);
26230 if (PyErr_Occurred()) SWIG_fail;
26231 }
26232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26233 return resultobj;
26234 fail:
26235 return NULL;
26236 }
26237
26238
26239 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26240 PyObject *resultobj;
26241 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26242 wxDateSpan *arg2 = 0 ;
26243 wxDateSpan result;
26244 PyObject * obj0 = 0 ;
26245 PyObject * obj1 = 0 ;
26246 char *kwnames[] = {
26247 (char *) "self",(char *) "other", NULL
26248 };
26249
26250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26252 if (SWIG_arg_fail(1)) SWIG_fail;
26253 {
26254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26255 if (SWIG_arg_fail(2)) SWIG_fail;
26256 if (arg2 == NULL) {
26257 SWIG_null_ref("wxDateSpan");
26258 }
26259 if (SWIG_arg_fail(2)) SWIG_fail;
26260 }
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26264
26265 wxPyEndAllowThreads(__tstate);
26266 if (PyErr_Occurred()) SWIG_fail;
26267 }
26268 {
26269 wxDateSpan * resultptr;
26270 resultptr = new wxDateSpan((wxDateSpan &)(result));
26271 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26272 }
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26280 PyObject *resultobj;
26281 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26282 wxDateSpan *arg2 = 0 ;
26283 wxDateSpan result;
26284 PyObject * obj0 = 0 ;
26285 PyObject * obj1 = 0 ;
26286 char *kwnames[] = {
26287 (char *) "self",(char *) "other", NULL
26288 };
26289
26290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26292 if (SWIG_arg_fail(1)) SWIG_fail;
26293 {
26294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26295 if (SWIG_arg_fail(2)) SWIG_fail;
26296 if (arg2 == NULL) {
26297 SWIG_null_ref("wxDateSpan");
26298 }
26299 if (SWIG_arg_fail(2)) SWIG_fail;
26300 }
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26304
26305 wxPyEndAllowThreads(__tstate);
26306 if (PyErr_Occurred()) SWIG_fail;
26307 }
26308 {
26309 wxDateSpan * resultptr;
26310 resultptr = new wxDateSpan((wxDateSpan &)(result));
26311 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26312 }
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj;
26321 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26322 int arg2 ;
26323 wxDateSpan result;
26324 PyObject * obj0 = 0 ;
26325 PyObject * obj1 = 0 ;
26326 char *kwnames[] = {
26327 (char *) "self",(char *) "n", NULL
26328 };
26329
26330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26332 if (SWIG_arg_fail(1)) SWIG_fail;
26333 {
26334 arg2 = (int)(SWIG_As_int(obj1));
26335 if (SWIG_arg_fail(2)) SWIG_fail;
26336 }
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 result = wxDateSpan___mul__(arg1,arg2);
26340
26341 wxPyEndAllowThreads(__tstate);
26342 if (PyErr_Occurred()) SWIG_fail;
26343 }
26344 {
26345 wxDateSpan * resultptr;
26346 resultptr = new wxDateSpan((wxDateSpan &)(result));
26347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26348 }
26349 return resultobj;
26350 fail:
26351 return NULL;
26352 }
26353
26354
26355 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26356 PyObject *resultobj;
26357 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26358 int arg2 ;
26359 wxDateSpan result;
26360 PyObject * obj0 = 0 ;
26361 PyObject * obj1 = 0 ;
26362 char *kwnames[] = {
26363 (char *) "self",(char *) "n", NULL
26364 };
26365
26366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26368 if (SWIG_arg_fail(1)) SWIG_fail;
26369 {
26370 arg2 = (int)(SWIG_As_int(obj1));
26371 if (SWIG_arg_fail(2)) SWIG_fail;
26372 }
26373 {
26374 PyThreadState* __tstate = wxPyBeginAllowThreads();
26375 result = wxDateSpan___rmul__(arg1,arg2);
26376
26377 wxPyEndAllowThreads(__tstate);
26378 if (PyErr_Occurred()) SWIG_fail;
26379 }
26380 {
26381 wxDateSpan * resultptr;
26382 resultptr = new wxDateSpan((wxDateSpan &)(result));
26383 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26384 }
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26392 PyObject *resultobj;
26393 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26394 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26395 bool result;
26396 PyObject * obj0 = 0 ;
26397 PyObject * obj1 = 0 ;
26398 char *kwnames[] = {
26399 (char *) "self",(char *) "other", NULL
26400 };
26401
26402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26404 if (SWIG_arg_fail(1)) SWIG_fail;
26405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26406 if (SWIG_arg_fail(2)) SWIG_fail;
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26410
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 {
26415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26416 }
26417 return resultobj;
26418 fail:
26419 return NULL;
26420 }
26421
26422
26423 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26424 PyObject *resultobj;
26425 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26426 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26427 bool result;
26428 PyObject * obj0 = 0 ;
26429 PyObject * obj1 = 0 ;
26430 char *kwnames[] = {
26431 (char *) "self",(char *) "other", NULL
26432 };
26433
26434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26436 if (SWIG_arg_fail(1)) SWIG_fail;
26437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26438 if (SWIG_arg_fail(2)) SWIG_fail;
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26442
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 {
26447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26448 }
26449 return resultobj;
26450 fail:
26451 return NULL;
26452 }
26453
26454
26455 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26456 PyObject *obj;
26457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26458 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26459 Py_INCREF(obj);
26460 return Py_BuildValue((char *)"");
26461 }
26462 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26463 PyObject *resultobj;
26464 long result;
26465 char *kwnames[] = {
26466 NULL
26467 };
26468
26469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26470 {
26471 PyThreadState* __tstate = wxPyBeginAllowThreads();
26472 result = (long)wxGetLocalTime();
26473
26474 wxPyEndAllowThreads(__tstate);
26475 if (PyErr_Occurred()) SWIG_fail;
26476 }
26477 {
26478 resultobj = SWIG_From_long((long)(result));
26479 }
26480 return resultobj;
26481 fail:
26482 return NULL;
26483 }
26484
26485
26486 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26487 PyObject *resultobj;
26488 long result;
26489 char *kwnames[] = {
26490 NULL
26491 };
26492
26493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26494 {
26495 PyThreadState* __tstate = wxPyBeginAllowThreads();
26496 result = (long)wxGetUTCTime();
26497
26498 wxPyEndAllowThreads(__tstate);
26499 if (PyErr_Occurred()) SWIG_fail;
26500 }
26501 {
26502 resultobj = SWIG_From_long((long)(result));
26503 }
26504 return resultobj;
26505 fail:
26506 return NULL;
26507 }
26508
26509
26510 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26511 PyObject *resultobj;
26512 long result;
26513 char *kwnames[] = {
26514 NULL
26515 };
26516
26517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (long)wxGetCurrentTime();
26521
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 {
26526 resultobj = SWIG_From_long((long)(result));
26527 }
26528 return resultobj;
26529 fail:
26530 return NULL;
26531 }
26532
26533
26534 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26535 PyObject *resultobj;
26536 wxLongLong result;
26537 char *kwnames[] = {
26538 NULL
26539 };
26540
26541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26542 {
26543 PyThreadState* __tstate = wxPyBeginAllowThreads();
26544 result = wxGetLocalTimeMillis();
26545
26546 wxPyEndAllowThreads(__tstate);
26547 if (PyErr_Occurred()) SWIG_fail;
26548 }
26549 {
26550 PyObject *hi, *lo, *shifter, *shifted;
26551 hi = PyLong_FromLong( (&result)->GetHi() );
26552 lo = PyLong_FromLong( (&result)->GetLo() );
26553 shifter = PyLong_FromLong(32);
26554 shifted = PyNumber_Lshift(hi, shifter);
26555 resultobj = PyNumber_Or(shifted, lo);
26556 Py_DECREF(hi);
26557 Py_DECREF(lo);
26558 Py_DECREF(shifter);
26559 Py_DECREF(shifted);
26560 }
26561 return resultobj;
26562 fail:
26563 return NULL;
26564 }
26565
26566
26567 static int _wrap_DefaultDateTime_set(PyObject *) {
26568 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26569 return 1;
26570 }
26571
26572
26573 static PyObject *_wrap_DefaultDateTime_get(void) {
26574 PyObject *pyobj;
26575
26576 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26577 return pyobj;
26578 }
26579
26580
26581 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26582 PyObject *resultobj;
26583 wxDataFormatId arg1 ;
26584 wxDataFormat *result;
26585 PyObject * obj0 = 0 ;
26586 char *kwnames[] = {
26587 (char *) "type", NULL
26588 };
26589
26590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26591 {
26592 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26593 if (SWIG_arg_fail(1)) SWIG_fail;
26594 }
26595 {
26596 PyThreadState* __tstate = wxPyBeginAllowThreads();
26597 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26598
26599 wxPyEndAllowThreads(__tstate);
26600 if (PyErr_Occurred()) SWIG_fail;
26601 }
26602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26603 return resultobj;
26604 fail:
26605 return NULL;
26606 }
26607
26608
26609 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj;
26611 wxString *arg1 = 0 ;
26612 wxDataFormat *result;
26613 bool temp1 = false ;
26614 PyObject * obj0 = 0 ;
26615 char *kwnames[] = {
26616 (char *) "format", NULL
26617 };
26618
26619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26620 {
26621 arg1 = wxString_in_helper(obj0);
26622 if (arg1 == NULL) SWIG_fail;
26623 temp1 = true;
26624 }
26625 {
26626 PyThreadState* __tstate = wxPyBeginAllowThreads();
26627 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26628
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26633 {
26634 if (temp1)
26635 delete arg1;
26636 }
26637 return resultobj;
26638 fail:
26639 {
26640 if (temp1)
26641 delete arg1;
26642 }
26643 return NULL;
26644 }
26645
26646
26647 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26648 PyObject *resultobj;
26649 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26650 PyObject * obj0 = 0 ;
26651 char *kwnames[] = {
26652 (char *) "self", NULL
26653 };
26654
26655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26657 if (SWIG_arg_fail(1)) SWIG_fail;
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 delete arg1;
26661
26662 wxPyEndAllowThreads(__tstate);
26663 if (PyErr_Occurred()) SWIG_fail;
26664 }
26665 Py_INCREF(Py_None); resultobj = Py_None;
26666 return resultobj;
26667 fail:
26668 return NULL;
26669 }
26670
26671
26672 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26673 PyObject *resultobj;
26674 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26675 wxDataFormatId arg2 ;
26676 bool result;
26677 PyObject * obj0 = 0 ;
26678 PyObject * obj1 = 0 ;
26679
26680 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26682 if (SWIG_arg_fail(1)) SWIG_fail;
26683 {
26684 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26685 if (SWIG_arg_fail(2)) SWIG_fail;
26686 }
26687 {
26688 PyThreadState* __tstate = wxPyBeginAllowThreads();
26689 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26690
26691 wxPyEndAllowThreads(__tstate);
26692 if (PyErr_Occurred()) SWIG_fail;
26693 }
26694 {
26695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26696 }
26697 return resultobj;
26698 fail:
26699 return NULL;
26700 }
26701
26702
26703 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26704 PyObject *resultobj;
26705 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26706 wxDataFormatId arg2 ;
26707 bool result;
26708 PyObject * obj0 = 0 ;
26709 PyObject * obj1 = 0 ;
26710
26711 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26713 if (SWIG_arg_fail(1)) SWIG_fail;
26714 {
26715 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26716 if (SWIG_arg_fail(2)) SWIG_fail;
26717 }
26718 {
26719 PyThreadState* __tstate = wxPyBeginAllowThreads();
26720 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26721
26722 wxPyEndAllowThreads(__tstate);
26723 if (PyErr_Occurred()) SWIG_fail;
26724 }
26725 {
26726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26727 }
26728 return resultobj;
26729 fail:
26730 return NULL;
26731 }
26732
26733
26734 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26735 PyObject *resultobj;
26736 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26737 wxDataFormat *arg2 = 0 ;
26738 bool result;
26739 PyObject * obj0 = 0 ;
26740 PyObject * obj1 = 0 ;
26741
26742 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26744 if (SWIG_arg_fail(1)) SWIG_fail;
26745 {
26746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26747 if (SWIG_arg_fail(2)) SWIG_fail;
26748 if (arg2 == NULL) {
26749 SWIG_null_ref("wxDataFormat");
26750 }
26751 if (SWIG_arg_fail(2)) SWIG_fail;
26752 }
26753 {
26754 PyThreadState* __tstate = wxPyBeginAllowThreads();
26755 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26756
26757 wxPyEndAllowThreads(__tstate);
26758 if (PyErr_Occurred()) SWIG_fail;
26759 }
26760 {
26761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26762 }
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26770 int argc;
26771 PyObject *argv[3];
26772 int ii;
26773
26774 argc = PyObject_Length(args);
26775 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26776 argv[ii] = PyTuple_GetItem(args,ii);
26777 }
26778 if (argc == 2) {
26779 int _v;
26780 {
26781 void *ptr;
26782 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26783 _v = 0;
26784 PyErr_Clear();
26785 } else {
26786 _v = 1;
26787 }
26788 }
26789 if (_v) {
26790 {
26791 void *ptr = 0;
26792 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26793 _v = 0;
26794 PyErr_Clear();
26795 } else {
26796 _v = (ptr != 0);
26797 }
26798 }
26799 if (_v) {
26800 return _wrap_DataFormat___eq____SWIG_1(self,args);
26801 }
26802 }
26803 }
26804 if (argc == 2) {
26805 int _v;
26806 {
26807 void *ptr;
26808 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26809 _v = 0;
26810 PyErr_Clear();
26811 } else {
26812 _v = 1;
26813 }
26814 }
26815 if (_v) {
26816 _v = SWIG_Check_int(argv[1]);
26817 if (_v) {
26818 return _wrap_DataFormat___eq____SWIG_0(self,args);
26819 }
26820 }
26821 }
26822
26823 Py_INCREF(Py_NotImplemented);
26824 return Py_NotImplemented;
26825 }
26826
26827
26828 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26829 PyObject *resultobj;
26830 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26831 wxDataFormat *arg2 = 0 ;
26832 bool result;
26833 PyObject * obj0 = 0 ;
26834 PyObject * obj1 = 0 ;
26835
26836 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26838 if (SWIG_arg_fail(1)) SWIG_fail;
26839 {
26840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26841 if (SWIG_arg_fail(2)) SWIG_fail;
26842 if (arg2 == NULL) {
26843 SWIG_null_ref("wxDataFormat");
26844 }
26845 if (SWIG_arg_fail(2)) SWIG_fail;
26846 }
26847 {
26848 PyThreadState* __tstate = wxPyBeginAllowThreads();
26849 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26850
26851 wxPyEndAllowThreads(__tstate);
26852 if (PyErr_Occurred()) SWIG_fail;
26853 }
26854 {
26855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26856 }
26857 return resultobj;
26858 fail:
26859 return NULL;
26860 }
26861
26862
26863 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26864 int argc;
26865 PyObject *argv[3];
26866 int ii;
26867
26868 argc = PyObject_Length(args);
26869 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26870 argv[ii] = PyTuple_GetItem(args,ii);
26871 }
26872 if (argc == 2) {
26873 int _v;
26874 {
26875 void *ptr;
26876 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26877 _v = 0;
26878 PyErr_Clear();
26879 } else {
26880 _v = 1;
26881 }
26882 }
26883 if (_v) {
26884 {
26885 void *ptr = 0;
26886 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26887 _v = 0;
26888 PyErr_Clear();
26889 } else {
26890 _v = (ptr != 0);
26891 }
26892 }
26893 if (_v) {
26894 return _wrap_DataFormat___ne____SWIG_1(self,args);
26895 }
26896 }
26897 }
26898 if (argc == 2) {
26899 int _v;
26900 {
26901 void *ptr;
26902 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26903 _v = 0;
26904 PyErr_Clear();
26905 } else {
26906 _v = 1;
26907 }
26908 }
26909 if (_v) {
26910 _v = SWIG_Check_int(argv[1]);
26911 if (_v) {
26912 return _wrap_DataFormat___ne____SWIG_0(self,args);
26913 }
26914 }
26915 }
26916
26917 Py_INCREF(Py_NotImplemented);
26918 return Py_NotImplemented;
26919 }
26920
26921
26922 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26923 PyObject *resultobj;
26924 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26925 wxDataFormatId arg2 ;
26926 PyObject * obj0 = 0 ;
26927 PyObject * obj1 = 0 ;
26928 char *kwnames[] = {
26929 (char *) "self",(char *) "format", NULL
26930 };
26931
26932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26934 if (SWIG_arg_fail(1)) SWIG_fail;
26935 {
26936 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26937 if (SWIG_arg_fail(2)) SWIG_fail;
26938 }
26939 {
26940 PyThreadState* __tstate = wxPyBeginAllowThreads();
26941 (arg1)->SetType((wxDataFormatId )arg2);
26942
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 Py_INCREF(Py_None); resultobj = Py_None;
26947 return resultobj;
26948 fail:
26949 return NULL;
26950 }
26951
26952
26953 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26954 PyObject *resultobj;
26955 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26956 wxDataFormatId result;
26957 PyObject * obj0 = 0 ;
26958 char *kwnames[] = {
26959 (char *) "self", NULL
26960 };
26961
26962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26964 if (SWIG_arg_fail(1)) SWIG_fail;
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26968
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 resultobj = SWIG_From_int((result));
26973 return resultobj;
26974 fail:
26975 return NULL;
26976 }
26977
26978
26979 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26980 PyObject *resultobj;
26981 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26982 wxString result;
26983 PyObject * obj0 = 0 ;
26984 char *kwnames[] = {
26985 (char *) "self", NULL
26986 };
26987
26988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26990 if (SWIG_arg_fail(1)) SWIG_fail;
26991 {
26992 PyThreadState* __tstate = wxPyBeginAllowThreads();
26993 result = ((wxDataFormat const *)arg1)->GetId();
26994
26995 wxPyEndAllowThreads(__tstate);
26996 if (PyErr_Occurred()) SWIG_fail;
26997 }
26998 {
26999 #if wxUSE_UNICODE
27000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27001 #else
27002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27003 #endif
27004 }
27005 return resultobj;
27006 fail:
27007 return NULL;
27008 }
27009
27010
27011 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27012 PyObject *resultobj;
27013 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27014 wxString *arg2 = 0 ;
27015 bool temp2 = false ;
27016 PyObject * obj0 = 0 ;
27017 PyObject * obj1 = 0 ;
27018 char *kwnames[] = {
27019 (char *) "self",(char *) "format", NULL
27020 };
27021
27022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27024 if (SWIG_arg_fail(1)) SWIG_fail;
27025 {
27026 arg2 = wxString_in_helper(obj1);
27027 if (arg2 == NULL) SWIG_fail;
27028 temp2 = true;
27029 }
27030 {
27031 PyThreadState* __tstate = wxPyBeginAllowThreads();
27032 (arg1)->SetId((wxString const &)*arg2);
27033
27034 wxPyEndAllowThreads(__tstate);
27035 if (PyErr_Occurred()) SWIG_fail;
27036 }
27037 Py_INCREF(Py_None); resultobj = Py_None;
27038 {
27039 if (temp2)
27040 delete arg2;
27041 }
27042 return resultobj;
27043 fail:
27044 {
27045 if (temp2)
27046 delete arg2;
27047 }
27048 return NULL;
27049 }
27050
27051
27052 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27053 PyObject *obj;
27054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27055 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27056 Py_INCREF(obj);
27057 return Py_BuildValue((char *)"");
27058 }
27059 static int _wrap_FormatInvalid_set(PyObject *) {
27060 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27061 return 1;
27062 }
27063
27064
27065 static PyObject *_wrap_FormatInvalid_get(void) {
27066 PyObject *pyobj;
27067
27068 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27069 return pyobj;
27070 }
27071
27072
27073 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27074 PyObject *resultobj;
27075 wxDataObject *arg1 = (wxDataObject *) 0 ;
27076 PyObject * obj0 = 0 ;
27077 char *kwnames[] = {
27078 (char *) "self", NULL
27079 };
27080
27081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27083 if (SWIG_arg_fail(1)) SWIG_fail;
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 delete arg1;
27087
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 Py_INCREF(Py_None); resultobj = Py_None;
27092 return resultobj;
27093 fail:
27094 return NULL;
27095 }
27096
27097
27098 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27099 PyObject *resultobj;
27100 wxDataObject *arg1 = (wxDataObject *) 0 ;
27101 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27102 SwigValueWrapper<wxDataFormat > result;
27103 PyObject * obj0 = 0 ;
27104 PyObject * obj1 = 0 ;
27105 char *kwnames[] = {
27106 (char *) "self",(char *) "dir", NULL
27107 };
27108
27109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27111 if (SWIG_arg_fail(1)) SWIG_fail;
27112 if (obj1) {
27113 {
27114 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27115 if (SWIG_arg_fail(2)) SWIG_fail;
27116 }
27117 }
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27121
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 {
27126 wxDataFormat * resultptr;
27127 resultptr = new wxDataFormat((wxDataFormat &)(result));
27128 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27129 }
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27137 PyObject *resultobj;
27138 wxDataObject *arg1 = (wxDataObject *) 0 ;
27139 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27140 size_t result;
27141 PyObject * obj0 = 0 ;
27142 PyObject * obj1 = 0 ;
27143 char *kwnames[] = {
27144 (char *) "self",(char *) "dir", NULL
27145 };
27146
27147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27149 if (SWIG_arg_fail(1)) SWIG_fail;
27150 if (obj1) {
27151 {
27152 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27153 if (SWIG_arg_fail(2)) SWIG_fail;
27154 }
27155 }
27156 {
27157 PyThreadState* __tstate = wxPyBeginAllowThreads();
27158 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27159
27160 wxPyEndAllowThreads(__tstate);
27161 if (PyErr_Occurred()) SWIG_fail;
27162 }
27163 {
27164 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27165 }
27166 return resultobj;
27167 fail:
27168 return NULL;
27169 }
27170
27171
27172 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27173 PyObject *resultobj;
27174 wxDataObject *arg1 = (wxDataObject *) 0 ;
27175 wxDataFormat *arg2 = 0 ;
27176 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27177 bool result;
27178 PyObject * obj0 = 0 ;
27179 PyObject * obj1 = 0 ;
27180 PyObject * obj2 = 0 ;
27181 char *kwnames[] = {
27182 (char *) "self",(char *) "format",(char *) "dir", NULL
27183 };
27184
27185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27187 if (SWIG_arg_fail(1)) SWIG_fail;
27188 {
27189 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27190 if (SWIG_arg_fail(2)) SWIG_fail;
27191 if (arg2 == NULL) {
27192 SWIG_null_ref("wxDataFormat");
27193 }
27194 if (SWIG_arg_fail(2)) SWIG_fail;
27195 }
27196 if (obj2) {
27197 {
27198 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27199 if (SWIG_arg_fail(3)) SWIG_fail;
27200 }
27201 }
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27205
27206 wxPyEndAllowThreads(__tstate);
27207 if (PyErr_Occurred()) SWIG_fail;
27208 }
27209 {
27210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27211 }
27212 return resultobj;
27213 fail:
27214 return NULL;
27215 }
27216
27217
27218 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27219 PyObject *resultobj;
27220 wxDataObject *arg1 = (wxDataObject *) 0 ;
27221 wxDataFormat *arg2 = 0 ;
27222 size_t result;
27223 PyObject * obj0 = 0 ;
27224 PyObject * obj1 = 0 ;
27225 char *kwnames[] = {
27226 (char *) "self",(char *) "format", NULL
27227 };
27228
27229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27231 if (SWIG_arg_fail(1)) SWIG_fail;
27232 {
27233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27234 if (SWIG_arg_fail(2)) SWIG_fail;
27235 if (arg2 == NULL) {
27236 SWIG_null_ref("wxDataFormat");
27237 }
27238 if (SWIG_arg_fail(2)) SWIG_fail;
27239 }
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27243
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 {
27248 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj;
27258 wxDataObject *arg1 = (wxDataObject *) 0 ;
27259 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27260 PyObject *result;
27261 PyObject * obj0 = 0 ;
27262 PyObject * obj1 = 0 ;
27263 char *kwnames[] = {
27264 (char *) "self",(char *) "dir", NULL
27265 };
27266
27267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27269 if (SWIG_arg_fail(1)) SWIG_fail;
27270 if (obj1) {
27271 {
27272 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27273 if (SWIG_arg_fail(2)) SWIG_fail;
27274 }
27275 }
27276 {
27277 PyThreadState* __tstate = wxPyBeginAllowThreads();
27278 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27279
27280 wxPyEndAllowThreads(__tstate);
27281 if (PyErr_Occurred()) SWIG_fail;
27282 }
27283 resultobj = result;
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj;
27292 wxDataObject *arg1 = (wxDataObject *) 0 ;
27293 wxDataFormat *arg2 = 0 ;
27294 PyObject *result;
27295 PyObject * obj0 = 0 ;
27296 PyObject * obj1 = 0 ;
27297 char *kwnames[] = {
27298 (char *) "self",(char *) "format", NULL
27299 };
27300
27301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27303 if (SWIG_arg_fail(1)) SWIG_fail;
27304 {
27305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27306 if (SWIG_arg_fail(2)) SWIG_fail;
27307 if (arg2 == NULL) {
27308 SWIG_null_ref("wxDataFormat");
27309 }
27310 if (SWIG_arg_fail(2)) SWIG_fail;
27311 }
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27315
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 resultobj = result;
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj;
27328 wxDataObject *arg1 = (wxDataObject *) 0 ;
27329 wxDataFormat *arg2 = 0 ;
27330 PyObject *arg3 = (PyObject *) 0 ;
27331 bool result;
27332 PyObject * obj0 = 0 ;
27333 PyObject * obj1 = 0 ;
27334 PyObject * obj2 = 0 ;
27335 char *kwnames[] = {
27336 (char *) "self",(char *) "format",(char *) "data", NULL
27337 };
27338
27339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27341 if (SWIG_arg_fail(1)) SWIG_fail;
27342 {
27343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27344 if (SWIG_arg_fail(2)) SWIG_fail;
27345 if (arg2 == NULL) {
27346 SWIG_null_ref("wxDataFormat");
27347 }
27348 if (SWIG_arg_fail(2)) SWIG_fail;
27349 }
27350 arg3 = obj2;
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27354
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 {
27359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27360 }
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27368 PyObject *obj;
27369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27370 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27371 Py_INCREF(obj);
27372 return Py_BuildValue((char *)"");
27373 }
27374 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27375 PyObject *resultobj;
27376 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27377 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27378 wxDataObjectSimple *result;
27379 PyObject * obj0 = 0 ;
27380 char *kwnames[] = {
27381 (char *) "format", NULL
27382 };
27383
27384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27385 if (obj0) {
27386 {
27387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27388 if (SWIG_arg_fail(1)) SWIG_fail;
27389 if (arg1 == NULL) {
27390 SWIG_null_ref("wxDataFormat");
27391 }
27392 if (SWIG_arg_fail(1)) SWIG_fail;
27393 }
27394 }
27395 {
27396 PyThreadState* __tstate = wxPyBeginAllowThreads();
27397 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27398
27399 wxPyEndAllowThreads(__tstate);
27400 if (PyErr_Occurred()) SWIG_fail;
27401 }
27402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27403 return resultobj;
27404 fail:
27405 return NULL;
27406 }
27407
27408
27409 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27410 PyObject *resultobj;
27411 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27412 wxDataFormat *result;
27413 PyObject * obj0 = 0 ;
27414 char *kwnames[] = {
27415 (char *) "self", NULL
27416 };
27417
27418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27420 if (SWIG_arg_fail(1)) SWIG_fail;
27421 {
27422 PyThreadState* __tstate = wxPyBeginAllowThreads();
27423 {
27424 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27425 result = (wxDataFormat *) &_result_ref;
27426 }
27427
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27439 PyObject *resultobj;
27440 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27441 wxDataFormat *arg2 = 0 ;
27442 PyObject * obj0 = 0 ;
27443 PyObject * obj1 = 0 ;
27444 char *kwnames[] = {
27445 (char *) "self",(char *) "format", NULL
27446 };
27447
27448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27450 if (SWIG_arg_fail(1)) SWIG_fail;
27451 {
27452 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27453 if (SWIG_arg_fail(2)) SWIG_fail;
27454 if (arg2 == NULL) {
27455 SWIG_null_ref("wxDataFormat");
27456 }
27457 if (SWIG_arg_fail(2)) SWIG_fail;
27458 }
27459 {
27460 PyThreadState* __tstate = wxPyBeginAllowThreads();
27461 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27462
27463 wxPyEndAllowThreads(__tstate);
27464 if (PyErr_Occurred()) SWIG_fail;
27465 }
27466 Py_INCREF(Py_None); resultobj = Py_None;
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27474 PyObject *resultobj;
27475 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27476 size_t result;
27477 PyObject * obj0 = 0 ;
27478 char *kwnames[] = {
27479 (char *) "self", NULL
27480 };
27481
27482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27484 if (SWIG_arg_fail(1)) SWIG_fail;
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27488
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27502 PyObject *resultobj;
27503 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27504 PyObject *result;
27505 PyObject * obj0 = 0 ;
27506 char *kwnames[] = {
27507 (char *) "self", NULL
27508 };
27509
27510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27512 if (SWIG_arg_fail(1)) SWIG_fail;
27513 {
27514 PyThreadState* __tstate = wxPyBeginAllowThreads();
27515 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27516
27517 wxPyEndAllowThreads(__tstate);
27518 if (PyErr_Occurred()) SWIG_fail;
27519 }
27520 resultobj = result;
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj;
27529 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27530 PyObject *arg2 = (PyObject *) 0 ;
27531 bool result;
27532 PyObject * obj0 = 0 ;
27533 PyObject * obj1 = 0 ;
27534 char *kwnames[] = {
27535 (char *) "self",(char *) "data", NULL
27536 };
27537
27538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27540 if (SWIG_arg_fail(1)) SWIG_fail;
27541 arg2 = obj1;
27542 {
27543 PyThreadState* __tstate = wxPyBeginAllowThreads();
27544 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27545
27546 wxPyEndAllowThreads(__tstate);
27547 if (PyErr_Occurred()) SWIG_fail;
27548 }
27549 {
27550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27551 }
27552 return resultobj;
27553 fail:
27554 return NULL;
27555 }
27556
27557
27558 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27559 PyObject *obj;
27560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27561 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27562 Py_INCREF(obj);
27563 return Py_BuildValue((char *)"");
27564 }
27565 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27566 PyObject *resultobj;
27567 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27568 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27569 wxPyDataObjectSimple *result;
27570 PyObject * obj0 = 0 ;
27571 char *kwnames[] = {
27572 (char *) "format", NULL
27573 };
27574
27575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27576 if (obj0) {
27577 {
27578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27579 if (SWIG_arg_fail(1)) SWIG_fail;
27580 if (arg1 == NULL) {
27581 SWIG_null_ref("wxDataFormat");
27582 }
27583 if (SWIG_arg_fail(1)) SWIG_fail;
27584 }
27585 }
27586 {
27587 PyThreadState* __tstate = wxPyBeginAllowThreads();
27588 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27589
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27601 PyObject *resultobj;
27602 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27603 PyObject *arg2 = (PyObject *) 0 ;
27604 PyObject *arg3 = (PyObject *) 0 ;
27605 PyObject * obj0 = 0 ;
27606 PyObject * obj1 = 0 ;
27607 PyObject * obj2 = 0 ;
27608 char *kwnames[] = {
27609 (char *) "self",(char *) "self",(char *) "_class", NULL
27610 };
27611
27612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27614 if (SWIG_arg_fail(1)) SWIG_fail;
27615 arg2 = obj1;
27616 arg3 = obj2;
27617 {
27618 PyThreadState* __tstate = wxPyBeginAllowThreads();
27619 (arg1)->_setCallbackInfo(arg2,arg3);
27620
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 Py_INCREF(Py_None); resultobj = Py_None;
27625 return resultobj;
27626 fail:
27627 return NULL;
27628 }
27629
27630
27631 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27632 PyObject *obj;
27633 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27634 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27635 Py_INCREF(obj);
27636 return Py_BuildValue((char *)"");
27637 }
27638 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27639 PyObject *resultobj;
27640 wxDataObjectComposite *result;
27641 char *kwnames[] = {
27642 NULL
27643 };
27644
27645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27646 {
27647 PyThreadState* __tstate = wxPyBeginAllowThreads();
27648 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27649
27650 wxPyEndAllowThreads(__tstate);
27651 if (PyErr_Occurred()) SWIG_fail;
27652 }
27653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27654 return resultobj;
27655 fail:
27656 return NULL;
27657 }
27658
27659
27660 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27661 PyObject *resultobj;
27662 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27663 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27664 bool arg3 = (bool) false ;
27665 PyObject * obj0 = 0 ;
27666 PyObject * obj1 = 0 ;
27667 PyObject * obj2 = 0 ;
27668 char *kwnames[] = {
27669 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27670 };
27671
27672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27674 if (SWIG_arg_fail(1)) SWIG_fail;
27675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27676 if (SWIG_arg_fail(2)) SWIG_fail;
27677 if (obj2) {
27678 {
27679 arg3 = (bool)(SWIG_As_bool(obj2));
27680 if (SWIG_arg_fail(3)) SWIG_fail;
27681 }
27682 }
27683 {
27684 PyThreadState* __tstate = wxPyBeginAllowThreads();
27685 (arg1)->Add(arg2,arg3);
27686
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 Py_INCREF(Py_None); resultobj = Py_None;
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27698 PyObject *obj;
27699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27700 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27701 Py_INCREF(obj);
27702 return Py_BuildValue((char *)"");
27703 }
27704 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27705 PyObject *resultobj;
27706 wxString const &arg1_defvalue = wxPyEmptyString ;
27707 wxString *arg1 = (wxString *) &arg1_defvalue ;
27708 wxTextDataObject *result;
27709 bool temp1 = false ;
27710 PyObject * obj0 = 0 ;
27711 char *kwnames[] = {
27712 (char *) "text", NULL
27713 };
27714
27715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27716 if (obj0) {
27717 {
27718 arg1 = wxString_in_helper(obj0);
27719 if (arg1 == NULL) SWIG_fail;
27720 temp1 = true;
27721 }
27722 }
27723 {
27724 PyThreadState* __tstate = wxPyBeginAllowThreads();
27725 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27726
27727 wxPyEndAllowThreads(__tstate);
27728 if (PyErr_Occurred()) SWIG_fail;
27729 }
27730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27731 {
27732 if (temp1)
27733 delete arg1;
27734 }
27735 return resultobj;
27736 fail:
27737 {
27738 if (temp1)
27739 delete arg1;
27740 }
27741 return NULL;
27742 }
27743
27744
27745 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27746 PyObject *resultobj;
27747 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27748 size_t result;
27749 PyObject * obj0 = 0 ;
27750 char *kwnames[] = {
27751 (char *) "self", NULL
27752 };
27753
27754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27756 if (SWIG_arg_fail(1)) SWIG_fail;
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 result = (size_t)(arg1)->GetTextLength();
27760
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 {
27765 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27766 }
27767 return resultobj;
27768 fail:
27769 return NULL;
27770 }
27771
27772
27773 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27774 PyObject *resultobj;
27775 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27776 wxString result;
27777 PyObject * obj0 = 0 ;
27778 char *kwnames[] = {
27779 (char *) "self", NULL
27780 };
27781
27782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27784 if (SWIG_arg_fail(1)) SWIG_fail;
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 result = (arg1)->GetText();
27788
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 {
27793 #if wxUSE_UNICODE
27794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27795 #else
27796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27797 #endif
27798 }
27799 return resultobj;
27800 fail:
27801 return NULL;
27802 }
27803
27804
27805 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27806 PyObject *resultobj;
27807 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27808 wxString *arg2 = 0 ;
27809 bool temp2 = false ;
27810 PyObject * obj0 = 0 ;
27811 PyObject * obj1 = 0 ;
27812 char *kwnames[] = {
27813 (char *) "self",(char *) "text", NULL
27814 };
27815
27816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27818 if (SWIG_arg_fail(1)) SWIG_fail;
27819 {
27820 arg2 = wxString_in_helper(obj1);
27821 if (arg2 == NULL) SWIG_fail;
27822 temp2 = true;
27823 }
27824 {
27825 PyThreadState* __tstate = wxPyBeginAllowThreads();
27826 (arg1)->SetText((wxString const &)*arg2);
27827
27828 wxPyEndAllowThreads(__tstate);
27829 if (PyErr_Occurred()) SWIG_fail;
27830 }
27831 Py_INCREF(Py_None); resultobj = Py_None;
27832 {
27833 if (temp2)
27834 delete arg2;
27835 }
27836 return resultobj;
27837 fail:
27838 {
27839 if (temp2)
27840 delete arg2;
27841 }
27842 return NULL;
27843 }
27844
27845
27846 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27847 PyObject *obj;
27848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27849 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27850 Py_INCREF(obj);
27851 return Py_BuildValue((char *)"");
27852 }
27853 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27854 PyObject *resultobj;
27855 wxString const &arg1_defvalue = wxPyEmptyString ;
27856 wxString *arg1 = (wxString *) &arg1_defvalue ;
27857 wxPyTextDataObject *result;
27858 bool temp1 = false ;
27859 PyObject * obj0 = 0 ;
27860 char *kwnames[] = {
27861 (char *) "text", NULL
27862 };
27863
27864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27865 if (obj0) {
27866 {
27867 arg1 = wxString_in_helper(obj0);
27868 if (arg1 == NULL) SWIG_fail;
27869 temp1 = true;
27870 }
27871 }
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27875
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27880 {
27881 if (temp1)
27882 delete arg1;
27883 }
27884 return resultobj;
27885 fail:
27886 {
27887 if (temp1)
27888 delete arg1;
27889 }
27890 return NULL;
27891 }
27892
27893
27894 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27895 PyObject *resultobj;
27896 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27897 PyObject *arg2 = (PyObject *) 0 ;
27898 PyObject *arg3 = (PyObject *) 0 ;
27899 PyObject * obj0 = 0 ;
27900 PyObject * obj1 = 0 ;
27901 PyObject * obj2 = 0 ;
27902 char *kwnames[] = {
27903 (char *) "self",(char *) "self",(char *) "_class", NULL
27904 };
27905
27906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27908 if (SWIG_arg_fail(1)) SWIG_fail;
27909 arg2 = obj1;
27910 arg3 = obj2;
27911 {
27912 PyThreadState* __tstate = wxPyBeginAllowThreads();
27913 (arg1)->_setCallbackInfo(arg2,arg3);
27914
27915 wxPyEndAllowThreads(__tstate);
27916 if (PyErr_Occurred()) SWIG_fail;
27917 }
27918 Py_INCREF(Py_None); resultobj = Py_None;
27919 return resultobj;
27920 fail:
27921 return NULL;
27922 }
27923
27924
27925 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27926 PyObject *obj;
27927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27928 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27929 Py_INCREF(obj);
27930 return Py_BuildValue((char *)"");
27931 }
27932 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27933 PyObject *resultobj;
27934 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27935 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27936 wxBitmapDataObject *result;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "bitmap", NULL
27940 };
27941
27942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27943 if (obj0) {
27944 {
27945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27946 if (SWIG_arg_fail(1)) SWIG_fail;
27947 if (arg1 == NULL) {
27948 SWIG_null_ref("wxBitmap");
27949 }
27950 if (SWIG_arg_fail(1)) SWIG_fail;
27951 }
27952 }
27953 {
27954 PyThreadState* __tstate = wxPyBeginAllowThreads();
27955 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27956
27957 wxPyEndAllowThreads(__tstate);
27958 if (PyErr_Occurred()) SWIG_fail;
27959 }
27960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj;
27969 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27970 wxBitmap result;
27971 PyObject * obj0 = 0 ;
27972 char *kwnames[] = {
27973 (char *) "self", NULL
27974 };
27975
27976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27978 if (SWIG_arg_fail(1)) SWIG_fail;
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27982
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 {
27987 wxBitmap * resultptr;
27988 resultptr = new wxBitmap((wxBitmap &)(result));
27989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27990 }
27991 return resultobj;
27992 fail:
27993 return NULL;
27994 }
27995
27996
27997 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27998 PyObject *resultobj;
27999 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28000 wxBitmap *arg2 = 0 ;
28001 PyObject * obj0 = 0 ;
28002 PyObject * obj1 = 0 ;
28003 char *kwnames[] = {
28004 (char *) "self",(char *) "bitmap", NULL
28005 };
28006
28007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28009 if (SWIG_arg_fail(1)) SWIG_fail;
28010 {
28011 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28012 if (SWIG_arg_fail(2)) SWIG_fail;
28013 if (arg2 == NULL) {
28014 SWIG_null_ref("wxBitmap");
28015 }
28016 if (SWIG_arg_fail(2)) SWIG_fail;
28017 }
28018 {
28019 PyThreadState* __tstate = wxPyBeginAllowThreads();
28020 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28021
28022 wxPyEndAllowThreads(__tstate);
28023 if (PyErr_Occurred()) SWIG_fail;
28024 }
28025 Py_INCREF(Py_None); resultobj = Py_None;
28026 return resultobj;
28027 fail:
28028 return NULL;
28029 }
28030
28031
28032 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28033 PyObject *obj;
28034 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28035 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28036 Py_INCREF(obj);
28037 return Py_BuildValue((char *)"");
28038 }
28039 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28040 PyObject *resultobj;
28041 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28042 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28043 wxPyBitmapDataObject *result;
28044 PyObject * obj0 = 0 ;
28045 char *kwnames[] = {
28046 (char *) "bitmap", NULL
28047 };
28048
28049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28050 if (obj0) {
28051 {
28052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28053 if (SWIG_arg_fail(1)) SWIG_fail;
28054 if (arg1 == NULL) {
28055 SWIG_null_ref("wxBitmap");
28056 }
28057 if (SWIG_arg_fail(1)) SWIG_fail;
28058 }
28059 }
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28063
28064 wxPyEndAllowThreads(__tstate);
28065 if (PyErr_Occurred()) SWIG_fail;
28066 }
28067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28068 return resultobj;
28069 fail:
28070 return NULL;
28071 }
28072
28073
28074 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28075 PyObject *resultobj;
28076 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28077 PyObject *arg2 = (PyObject *) 0 ;
28078 PyObject *arg3 = (PyObject *) 0 ;
28079 PyObject * obj0 = 0 ;
28080 PyObject * obj1 = 0 ;
28081 PyObject * obj2 = 0 ;
28082 char *kwnames[] = {
28083 (char *) "self",(char *) "self",(char *) "_class", NULL
28084 };
28085
28086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28088 if (SWIG_arg_fail(1)) SWIG_fail;
28089 arg2 = obj1;
28090 arg3 = obj2;
28091 {
28092 PyThreadState* __tstate = wxPyBeginAllowThreads();
28093 (arg1)->_setCallbackInfo(arg2,arg3);
28094
28095 wxPyEndAllowThreads(__tstate);
28096 if (PyErr_Occurred()) SWIG_fail;
28097 }
28098 Py_INCREF(Py_None); resultobj = Py_None;
28099 return resultobj;
28100 fail:
28101 return NULL;
28102 }
28103
28104
28105 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28106 PyObject *obj;
28107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28108 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28109 Py_INCREF(obj);
28110 return Py_BuildValue((char *)"");
28111 }
28112 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj;
28114 wxFileDataObject *result;
28115 char *kwnames[] = {
28116 NULL
28117 };
28118
28119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 result = (wxFileDataObject *)new wxFileDataObject();
28123
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj;
28136 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28137 wxArrayString *result;
28138 PyObject * obj0 = 0 ;
28139 char *kwnames[] = {
28140 (char *) "self", NULL
28141 };
28142
28143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28145 if (SWIG_arg_fail(1)) SWIG_fail;
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 {
28149 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28150 result = (wxArrayString *) &_result_ref;
28151 }
28152
28153 wxPyEndAllowThreads(__tstate);
28154 if (PyErr_Occurred()) SWIG_fail;
28155 }
28156 {
28157 resultobj = wxArrayString2PyList_helper(*result);
28158 }
28159 return resultobj;
28160 fail:
28161 return NULL;
28162 }
28163
28164
28165 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28166 PyObject *resultobj;
28167 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28168 wxString *arg2 = 0 ;
28169 bool temp2 = false ;
28170 PyObject * obj0 = 0 ;
28171 PyObject * obj1 = 0 ;
28172 char *kwnames[] = {
28173 (char *) "self",(char *) "filename", NULL
28174 };
28175
28176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28178 if (SWIG_arg_fail(1)) SWIG_fail;
28179 {
28180 arg2 = wxString_in_helper(obj1);
28181 if (arg2 == NULL) SWIG_fail;
28182 temp2 = true;
28183 }
28184 {
28185 PyThreadState* __tstate = wxPyBeginAllowThreads();
28186 (arg1)->AddFile((wxString const &)*arg2);
28187
28188 wxPyEndAllowThreads(__tstate);
28189 if (PyErr_Occurred()) SWIG_fail;
28190 }
28191 Py_INCREF(Py_None); resultobj = Py_None;
28192 {
28193 if (temp2)
28194 delete arg2;
28195 }
28196 return resultobj;
28197 fail:
28198 {
28199 if (temp2)
28200 delete arg2;
28201 }
28202 return NULL;
28203 }
28204
28205
28206 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28207 PyObject *obj;
28208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28209 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28210 Py_INCREF(obj);
28211 return Py_BuildValue((char *)"");
28212 }
28213 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28214 PyObject *resultobj;
28215 wxDataFormat *arg1 = 0 ;
28216 wxCustomDataObject *result;
28217 PyObject * obj0 = 0 ;
28218
28219 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28220 {
28221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28222 if (SWIG_arg_fail(1)) SWIG_fail;
28223 if (arg1 == NULL) {
28224 SWIG_null_ref("wxDataFormat");
28225 }
28226 if (SWIG_arg_fail(1)) SWIG_fail;
28227 }
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28231
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28243 PyObject *resultobj;
28244 wxString *arg1 = 0 ;
28245 wxCustomDataObject *result;
28246 bool temp1 = false ;
28247 PyObject * obj0 = 0 ;
28248
28249 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28250 {
28251 arg1 = wxString_in_helper(obj0);
28252 if (arg1 == NULL) SWIG_fail;
28253 temp1 = true;
28254 }
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28258
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28263 {
28264 if (temp1)
28265 delete arg1;
28266 }
28267 return resultobj;
28268 fail:
28269 {
28270 if (temp1)
28271 delete arg1;
28272 }
28273 return NULL;
28274 }
28275
28276
28277 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28278 PyObject *resultobj;
28279 wxCustomDataObject *result;
28280
28281 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28282 {
28283 PyThreadState* __tstate = wxPyBeginAllowThreads();
28284 result = (wxCustomDataObject *)new wxCustomDataObject();
28285
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28290 return resultobj;
28291 fail:
28292 return NULL;
28293 }
28294
28295
28296 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28297 int argc;
28298 PyObject *argv[2];
28299 int ii;
28300
28301 argc = PyObject_Length(args);
28302 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28303 argv[ii] = PyTuple_GetItem(args,ii);
28304 }
28305 if (argc == 0) {
28306 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28307 }
28308 if (argc == 1) {
28309 int _v;
28310 {
28311 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28312 }
28313 if (_v) {
28314 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28315 }
28316 }
28317 if (argc == 1) {
28318 int _v;
28319 {
28320 void *ptr = 0;
28321 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28322 _v = 0;
28323 PyErr_Clear();
28324 } else {
28325 _v = (ptr != 0);
28326 }
28327 }
28328 if (_v) {
28329 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28330 }
28331 }
28332
28333 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28334 return NULL;
28335 }
28336
28337
28338 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28339 PyObject *resultobj;
28340 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28341 PyObject *arg2 = (PyObject *) 0 ;
28342 bool result;
28343 PyObject * obj0 = 0 ;
28344 PyObject * obj1 = 0 ;
28345 char *kwnames[] = {
28346 (char *) "self",(char *) "data", NULL
28347 };
28348
28349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28351 if (SWIG_arg_fail(1)) SWIG_fail;
28352 arg2 = obj1;
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28356
28357 wxPyEndAllowThreads(__tstate);
28358 if (PyErr_Occurred()) SWIG_fail;
28359 }
28360 {
28361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28362 }
28363 return resultobj;
28364 fail:
28365 return NULL;
28366 }
28367
28368
28369 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28370 PyObject *resultobj;
28371 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28372 size_t result;
28373 PyObject * obj0 = 0 ;
28374 char *kwnames[] = {
28375 (char *) "self", NULL
28376 };
28377
28378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28380 if (SWIG_arg_fail(1)) SWIG_fail;
28381 {
28382 PyThreadState* __tstate = wxPyBeginAllowThreads();
28383 result = (size_t)(arg1)->GetSize();
28384
28385 wxPyEndAllowThreads(__tstate);
28386 if (PyErr_Occurred()) SWIG_fail;
28387 }
28388 {
28389 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28390 }
28391 return resultobj;
28392 fail:
28393 return NULL;
28394 }
28395
28396
28397 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28398 PyObject *resultobj;
28399 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28400 PyObject *result;
28401 PyObject * obj0 = 0 ;
28402 char *kwnames[] = {
28403 (char *) "self", NULL
28404 };
28405
28406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28408 if (SWIG_arg_fail(1)) SWIG_fail;
28409 {
28410 PyThreadState* __tstate = wxPyBeginAllowThreads();
28411 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28412
28413 wxPyEndAllowThreads(__tstate);
28414 if (PyErr_Occurred()) SWIG_fail;
28415 }
28416 resultobj = result;
28417 return resultobj;
28418 fail:
28419 return NULL;
28420 }
28421
28422
28423 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28424 PyObject *obj;
28425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28426 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28427 Py_INCREF(obj);
28428 return Py_BuildValue((char *)"");
28429 }
28430 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28431 PyObject *resultobj;
28432 wxURLDataObject *result;
28433 char *kwnames[] = {
28434 NULL
28435 };
28436
28437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28438 {
28439 PyThreadState* __tstate = wxPyBeginAllowThreads();
28440 result = (wxURLDataObject *)new wxURLDataObject();
28441
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28446 return resultobj;
28447 fail:
28448 return NULL;
28449 }
28450
28451
28452 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28453 PyObject *resultobj;
28454 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28455 wxString result;
28456 PyObject * obj0 = 0 ;
28457 char *kwnames[] = {
28458 (char *) "self", NULL
28459 };
28460
28461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28463 if (SWIG_arg_fail(1)) SWIG_fail;
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 result = (arg1)->GetURL();
28467
28468 wxPyEndAllowThreads(__tstate);
28469 if (PyErr_Occurred()) SWIG_fail;
28470 }
28471 {
28472 #if wxUSE_UNICODE
28473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28474 #else
28475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28476 #endif
28477 }
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28485 PyObject *resultobj;
28486 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28487 wxString *arg2 = 0 ;
28488 bool temp2 = false ;
28489 PyObject * obj0 = 0 ;
28490 PyObject * obj1 = 0 ;
28491 char *kwnames[] = {
28492 (char *) "self",(char *) "url", NULL
28493 };
28494
28495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28497 if (SWIG_arg_fail(1)) SWIG_fail;
28498 {
28499 arg2 = wxString_in_helper(obj1);
28500 if (arg2 == NULL) SWIG_fail;
28501 temp2 = true;
28502 }
28503 {
28504 PyThreadState* __tstate = wxPyBeginAllowThreads();
28505 (arg1)->SetURL((wxString const &)*arg2);
28506
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 Py_INCREF(Py_None); resultobj = Py_None;
28511 {
28512 if (temp2)
28513 delete arg2;
28514 }
28515 return resultobj;
28516 fail:
28517 {
28518 if (temp2)
28519 delete arg2;
28520 }
28521 return NULL;
28522 }
28523
28524
28525 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28526 PyObject *obj;
28527 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28528 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28529 Py_INCREF(obj);
28530 return Py_BuildValue((char *)"");
28531 }
28532 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28533 PyObject *resultobj;
28534 wxMetafileDataObject *result;
28535 char *kwnames[] = {
28536 NULL
28537 };
28538
28539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28540 {
28541 PyThreadState* __tstate = wxPyBeginAllowThreads();
28542 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28543
28544 wxPyEndAllowThreads(__tstate);
28545 if (PyErr_Occurred()) SWIG_fail;
28546 }
28547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28548 return resultobj;
28549 fail:
28550 return NULL;
28551 }
28552
28553
28554 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28555 PyObject *obj;
28556 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28557 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28558 Py_INCREF(obj);
28559 return Py_BuildValue((char *)"");
28560 }
28561 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28562 PyObject *resultobj;
28563 wxDragResult arg1 ;
28564 bool result;
28565 PyObject * obj0 = 0 ;
28566 char *kwnames[] = {
28567 (char *) "res", NULL
28568 };
28569
28570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28571 {
28572 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28573 if (SWIG_arg_fail(1)) SWIG_fail;
28574 }
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28578
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 {
28583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28584 }
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28592 PyObject *resultobj;
28593 wxWindow *arg1 = (wxWindow *) 0 ;
28594 wxIcon const &arg2_defvalue = wxNullIcon ;
28595 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28596 wxIcon const &arg3_defvalue = wxNullIcon ;
28597 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28598 wxIcon const &arg4_defvalue = wxNullIcon ;
28599 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28600 wxPyDropSource *result;
28601 PyObject * obj0 = 0 ;
28602 PyObject * obj1 = 0 ;
28603 PyObject * obj2 = 0 ;
28604 PyObject * obj3 = 0 ;
28605 char *kwnames[] = {
28606 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28607 };
28608
28609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28611 if (SWIG_arg_fail(1)) SWIG_fail;
28612 if (obj1) {
28613 {
28614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28615 if (SWIG_arg_fail(2)) SWIG_fail;
28616 if (arg2 == NULL) {
28617 SWIG_null_ref("wxIcon");
28618 }
28619 if (SWIG_arg_fail(2)) SWIG_fail;
28620 }
28621 }
28622 if (obj2) {
28623 {
28624 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28625 if (SWIG_arg_fail(3)) SWIG_fail;
28626 if (arg3 == NULL) {
28627 SWIG_null_ref("wxIcon");
28628 }
28629 if (SWIG_arg_fail(3)) SWIG_fail;
28630 }
28631 }
28632 if (obj3) {
28633 {
28634 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28635 if (SWIG_arg_fail(4)) SWIG_fail;
28636 if (arg4 == NULL) {
28637 SWIG_null_ref("wxIcon");
28638 }
28639 if (SWIG_arg_fail(4)) SWIG_fail;
28640 }
28641 }
28642 {
28643 PyThreadState* __tstate = wxPyBeginAllowThreads();
28644 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28645
28646 wxPyEndAllowThreads(__tstate);
28647 if (PyErr_Occurred()) SWIG_fail;
28648 }
28649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28650 return resultobj;
28651 fail:
28652 return NULL;
28653 }
28654
28655
28656 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28657 PyObject *resultobj;
28658 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28659 PyObject *arg2 = (PyObject *) 0 ;
28660 PyObject *arg3 = (PyObject *) 0 ;
28661 int arg4 ;
28662 PyObject * obj0 = 0 ;
28663 PyObject * obj1 = 0 ;
28664 PyObject * obj2 = 0 ;
28665 PyObject * obj3 = 0 ;
28666 char *kwnames[] = {
28667 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28668 };
28669
28670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28672 if (SWIG_arg_fail(1)) SWIG_fail;
28673 arg2 = obj1;
28674 arg3 = obj2;
28675 {
28676 arg4 = (int)(SWIG_As_int(obj3));
28677 if (SWIG_arg_fail(4)) SWIG_fail;
28678 }
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28682
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 Py_INCREF(Py_None); resultobj = Py_None;
28687 return resultobj;
28688 fail:
28689 return NULL;
28690 }
28691
28692
28693 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28694 PyObject *resultobj;
28695 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28696 PyObject * obj0 = 0 ;
28697 char *kwnames[] = {
28698 (char *) "self", NULL
28699 };
28700
28701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28703 if (SWIG_arg_fail(1)) SWIG_fail;
28704 {
28705 PyThreadState* __tstate = wxPyBeginAllowThreads();
28706 delete arg1;
28707
28708 wxPyEndAllowThreads(__tstate);
28709 if (PyErr_Occurred()) SWIG_fail;
28710 }
28711 Py_INCREF(Py_None); resultobj = Py_None;
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28719 PyObject *resultobj;
28720 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28721 wxDataObject *arg2 = 0 ;
28722 PyObject * obj0 = 0 ;
28723 PyObject * obj1 = 0 ;
28724 char *kwnames[] = {
28725 (char *) "self",(char *) "data", NULL
28726 };
28727
28728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28730 if (SWIG_arg_fail(1)) SWIG_fail;
28731 {
28732 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28733 if (SWIG_arg_fail(2)) SWIG_fail;
28734 if (arg2 == NULL) {
28735 SWIG_null_ref("wxDataObject");
28736 }
28737 if (SWIG_arg_fail(2)) SWIG_fail;
28738 }
28739 {
28740 PyThreadState* __tstate = wxPyBeginAllowThreads();
28741 (arg1)->SetData(*arg2);
28742
28743 wxPyEndAllowThreads(__tstate);
28744 if (PyErr_Occurred()) SWIG_fail;
28745 }
28746 Py_INCREF(Py_None); resultobj = Py_None;
28747 return resultobj;
28748 fail:
28749 return NULL;
28750 }
28751
28752
28753 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28754 PyObject *resultobj;
28755 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28756 wxDataObject *result;
28757 PyObject * obj0 = 0 ;
28758 char *kwnames[] = {
28759 (char *) "self", NULL
28760 };
28761
28762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28764 if (SWIG_arg_fail(1)) SWIG_fail;
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 result = (wxDataObject *)(arg1)->GetDataObject();
28768
28769 wxPyEndAllowThreads(__tstate);
28770 if (PyErr_Occurred()) SWIG_fail;
28771 }
28772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28780 PyObject *resultobj;
28781 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28782 wxDragResult arg2 ;
28783 wxCursor *arg3 = 0 ;
28784 PyObject * obj0 = 0 ;
28785 PyObject * obj1 = 0 ;
28786 PyObject * obj2 = 0 ;
28787 char *kwnames[] = {
28788 (char *) "self",(char *) "res",(char *) "cursor", NULL
28789 };
28790
28791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28793 if (SWIG_arg_fail(1)) SWIG_fail;
28794 {
28795 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28796 if (SWIG_arg_fail(2)) SWIG_fail;
28797 }
28798 {
28799 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28800 if (SWIG_arg_fail(3)) SWIG_fail;
28801 if (arg3 == NULL) {
28802 SWIG_null_ref("wxCursor");
28803 }
28804 if (SWIG_arg_fail(3)) SWIG_fail;
28805 }
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28809
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 Py_INCREF(Py_None); resultobj = Py_None;
28814 return resultobj;
28815 fail:
28816 return NULL;
28817 }
28818
28819
28820 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28821 PyObject *resultobj;
28822 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28823 int arg2 = (int) wxDrag_CopyOnly ;
28824 wxDragResult result;
28825 PyObject * obj0 = 0 ;
28826 PyObject * obj1 = 0 ;
28827 char *kwnames[] = {
28828 (char *) "self",(char *) "flags", NULL
28829 };
28830
28831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28833 if (SWIG_arg_fail(1)) SWIG_fail;
28834 if (obj1) {
28835 {
28836 arg2 = (int)(SWIG_As_int(obj1));
28837 if (SWIG_arg_fail(2)) SWIG_fail;
28838 }
28839 }
28840 {
28841 PyThreadState* __tstate = wxPyBeginAllowThreads();
28842 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28843
28844 wxPyEndAllowThreads(__tstate);
28845 if (PyErr_Occurred()) SWIG_fail;
28846 }
28847 resultobj = SWIG_From_int((result));
28848 return resultobj;
28849 fail:
28850 return NULL;
28851 }
28852
28853
28854 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28855 PyObject *resultobj;
28856 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28857 wxDragResult arg2 ;
28858 bool result;
28859 PyObject * obj0 = 0 ;
28860 PyObject * obj1 = 0 ;
28861 char *kwnames[] = {
28862 (char *) "self",(char *) "effect", NULL
28863 };
28864
28865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28867 if (SWIG_arg_fail(1)) SWIG_fail;
28868 {
28869 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28870 if (SWIG_arg_fail(2)) SWIG_fail;
28871 }
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28875
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 {
28880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28881 }
28882 return resultobj;
28883 fail:
28884 return NULL;
28885 }
28886
28887
28888 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28889 PyObject *obj;
28890 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28891 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28892 Py_INCREF(obj);
28893 return Py_BuildValue((char *)"");
28894 }
28895 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28896 PyObject *resultobj;
28897 wxDataObject *arg1 = (wxDataObject *) NULL ;
28898 wxPyDropTarget *result;
28899 PyObject * obj0 = 0 ;
28900 char *kwnames[] = {
28901 (char *) "dataObject", NULL
28902 };
28903
28904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28905 if (obj0) {
28906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28907 if (SWIG_arg_fail(1)) SWIG_fail;
28908 }
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28912
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj;
28925 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28926 PyObject *arg2 = (PyObject *) 0 ;
28927 PyObject *arg3 = (PyObject *) 0 ;
28928 PyObject * obj0 = 0 ;
28929 PyObject * obj1 = 0 ;
28930 PyObject * obj2 = 0 ;
28931 char *kwnames[] = {
28932 (char *) "self",(char *) "self",(char *) "_class", NULL
28933 };
28934
28935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28937 if (SWIG_arg_fail(1)) SWIG_fail;
28938 arg2 = obj1;
28939 arg3 = obj2;
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 (arg1)->_setCallbackInfo(arg2,arg3);
28943
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 Py_INCREF(Py_None); resultobj = Py_None;
28948 return resultobj;
28949 fail:
28950 return NULL;
28951 }
28952
28953
28954 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28955 PyObject *resultobj;
28956 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28957 PyObject * obj0 = 0 ;
28958 char *kwnames[] = {
28959 (char *) "self", NULL
28960 };
28961
28962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28964 if (SWIG_arg_fail(1)) SWIG_fail;
28965 {
28966 PyThreadState* __tstate = wxPyBeginAllowThreads();
28967 delete arg1;
28968
28969 wxPyEndAllowThreads(__tstate);
28970 if (PyErr_Occurred()) SWIG_fail;
28971 }
28972 Py_INCREF(Py_None); resultobj = Py_None;
28973 return resultobj;
28974 fail:
28975 return NULL;
28976 }
28977
28978
28979 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28980 PyObject *resultobj;
28981 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28982 wxDataObject *result;
28983 PyObject * obj0 = 0 ;
28984 char *kwnames[] = {
28985 (char *) "self", NULL
28986 };
28987
28988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28990 if (SWIG_arg_fail(1)) SWIG_fail;
28991 {
28992 PyThreadState* __tstate = wxPyBeginAllowThreads();
28993 result = (wxDataObject *)(arg1)->GetDataObject();
28994
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29006 PyObject *resultobj;
29007 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29008 wxDataObject *arg2 = (wxDataObject *) 0 ;
29009 PyObject * obj0 = 0 ;
29010 PyObject * obj1 = 0 ;
29011 char *kwnames[] = {
29012 (char *) "self",(char *) "dataObject", NULL
29013 };
29014
29015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29017 if (SWIG_arg_fail(1)) SWIG_fail;
29018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29019 if (SWIG_arg_fail(2)) SWIG_fail;
29020 {
29021 PyThreadState* __tstate = wxPyBeginAllowThreads();
29022 (arg1)->SetDataObject(arg2);
29023
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 Py_INCREF(Py_None); resultobj = Py_None;
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj;
29036 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29037 int arg2 ;
29038 int arg3 ;
29039 wxDragResult arg4 ;
29040 wxDragResult result;
29041 PyObject * obj0 = 0 ;
29042 PyObject * obj1 = 0 ;
29043 PyObject * obj2 = 0 ;
29044 PyObject * obj3 = 0 ;
29045 char *kwnames[] = {
29046 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29047 };
29048
29049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29051 if (SWIG_arg_fail(1)) SWIG_fail;
29052 {
29053 arg2 = (int)(SWIG_As_int(obj1));
29054 if (SWIG_arg_fail(2)) SWIG_fail;
29055 }
29056 {
29057 arg3 = (int)(SWIG_As_int(obj2));
29058 if (SWIG_arg_fail(3)) SWIG_fail;
29059 }
29060 {
29061 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29062 if (SWIG_arg_fail(4)) SWIG_fail;
29063 }
29064 {
29065 PyThreadState* __tstate = wxPyBeginAllowThreads();
29066 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29067
29068 wxPyEndAllowThreads(__tstate);
29069 if (PyErr_Occurred()) SWIG_fail;
29070 }
29071 resultobj = SWIG_From_int((result));
29072 return resultobj;
29073 fail:
29074 return NULL;
29075 }
29076
29077
29078 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29079 PyObject *resultobj;
29080 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29081 int arg2 ;
29082 int arg3 ;
29083 wxDragResult arg4 ;
29084 wxDragResult result;
29085 PyObject * obj0 = 0 ;
29086 PyObject * obj1 = 0 ;
29087 PyObject * obj2 = 0 ;
29088 PyObject * obj3 = 0 ;
29089 char *kwnames[] = {
29090 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29091 };
29092
29093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29095 if (SWIG_arg_fail(1)) SWIG_fail;
29096 {
29097 arg2 = (int)(SWIG_As_int(obj1));
29098 if (SWIG_arg_fail(2)) SWIG_fail;
29099 }
29100 {
29101 arg3 = (int)(SWIG_As_int(obj2));
29102 if (SWIG_arg_fail(3)) SWIG_fail;
29103 }
29104 {
29105 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29106 if (SWIG_arg_fail(4)) SWIG_fail;
29107 }
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29111
29112 wxPyEndAllowThreads(__tstate);
29113 if (PyErr_Occurred()) SWIG_fail;
29114 }
29115 resultobj = SWIG_From_int((result));
29116 return resultobj;
29117 fail:
29118 return NULL;
29119 }
29120
29121
29122 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29123 PyObject *resultobj;
29124 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29125 PyObject * obj0 = 0 ;
29126 char *kwnames[] = {
29127 (char *) "self", NULL
29128 };
29129
29130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29132 if (SWIG_arg_fail(1)) SWIG_fail;
29133 {
29134 PyThreadState* __tstate = wxPyBeginAllowThreads();
29135 (arg1)->base_OnLeave();
29136
29137 wxPyEndAllowThreads(__tstate);
29138 if (PyErr_Occurred()) SWIG_fail;
29139 }
29140 Py_INCREF(Py_None); resultobj = Py_None;
29141 return resultobj;
29142 fail:
29143 return NULL;
29144 }
29145
29146
29147 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29148 PyObject *resultobj;
29149 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29150 int arg2 ;
29151 int arg3 ;
29152 bool result;
29153 PyObject * obj0 = 0 ;
29154 PyObject * obj1 = 0 ;
29155 PyObject * obj2 = 0 ;
29156 char *kwnames[] = {
29157 (char *) "self",(char *) "x",(char *) "y", NULL
29158 };
29159
29160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29162 if (SWIG_arg_fail(1)) SWIG_fail;
29163 {
29164 arg2 = (int)(SWIG_As_int(obj1));
29165 if (SWIG_arg_fail(2)) SWIG_fail;
29166 }
29167 {
29168 arg3 = (int)(SWIG_As_int(obj2));
29169 if (SWIG_arg_fail(3)) SWIG_fail;
29170 }
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29174
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 {
29179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29180 }
29181 return resultobj;
29182 fail:
29183 return NULL;
29184 }
29185
29186
29187 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29188 PyObject *resultobj;
29189 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29190 bool result;
29191 PyObject * obj0 = 0 ;
29192 char *kwnames[] = {
29193 (char *) "self", NULL
29194 };
29195
29196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29198 if (SWIG_arg_fail(1)) SWIG_fail;
29199 {
29200 PyThreadState* __tstate = wxPyBeginAllowThreads();
29201 result = (bool)(arg1)->GetData();
29202
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 {
29207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29208 }
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29216 PyObject *resultobj;
29217 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29218 wxDragResult arg2 ;
29219 PyObject * obj0 = 0 ;
29220 PyObject * obj1 = 0 ;
29221 char *kwnames[] = {
29222 (char *) "self",(char *) "action", NULL
29223 };
29224
29225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29227 if (SWIG_arg_fail(1)) SWIG_fail;
29228 {
29229 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29230 if (SWIG_arg_fail(2)) SWIG_fail;
29231 }
29232 {
29233 PyThreadState* __tstate = wxPyBeginAllowThreads();
29234 (arg1)->SetDefaultAction((wxDragResult )arg2);
29235
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 Py_INCREF(Py_None); resultobj = Py_None;
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29249 wxDragResult result;
29250 PyObject * obj0 = 0 ;
29251 char *kwnames[] = {
29252 (char *) "self", NULL
29253 };
29254
29255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29257 if (SWIG_arg_fail(1)) SWIG_fail;
29258 {
29259 PyThreadState* __tstate = wxPyBeginAllowThreads();
29260 result = (wxDragResult)(arg1)->GetDefaultAction();
29261
29262 wxPyEndAllowThreads(__tstate);
29263 if (PyErr_Occurred()) SWIG_fail;
29264 }
29265 resultobj = SWIG_From_int((result));
29266 return resultobj;
29267 fail:
29268 return NULL;
29269 }
29270
29271
29272 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29273 PyObject *obj;
29274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29275 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29276 Py_INCREF(obj);
29277 return Py_BuildValue((char *)"");
29278 }
29279 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29280 PyObject *resultobj;
29281 wxPyTextDropTarget *result;
29282 char *kwnames[] = {
29283 NULL
29284 };
29285
29286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29287 {
29288 PyThreadState* __tstate = wxPyBeginAllowThreads();
29289 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29290
29291 wxPyEndAllowThreads(__tstate);
29292 if (PyErr_Occurred()) SWIG_fail;
29293 }
29294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29295 return resultobj;
29296 fail:
29297 return NULL;
29298 }
29299
29300
29301 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29302 PyObject *resultobj;
29303 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29304 PyObject *arg2 = (PyObject *) 0 ;
29305 PyObject *arg3 = (PyObject *) 0 ;
29306 PyObject * obj0 = 0 ;
29307 PyObject * obj1 = 0 ;
29308 PyObject * obj2 = 0 ;
29309 char *kwnames[] = {
29310 (char *) "self",(char *) "self",(char *) "_class", NULL
29311 };
29312
29313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29315 if (SWIG_arg_fail(1)) SWIG_fail;
29316 arg2 = obj1;
29317 arg3 = obj2;
29318 {
29319 PyThreadState* __tstate = wxPyBeginAllowThreads();
29320 (arg1)->_setCallbackInfo(arg2,arg3);
29321
29322 wxPyEndAllowThreads(__tstate);
29323 if (PyErr_Occurred()) SWIG_fail;
29324 }
29325 Py_INCREF(Py_None); resultobj = Py_None;
29326 return resultobj;
29327 fail:
29328 return NULL;
29329 }
29330
29331
29332 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29333 PyObject *resultobj;
29334 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29335 int arg2 ;
29336 int arg3 ;
29337 wxDragResult arg4 ;
29338 wxDragResult result;
29339 PyObject * obj0 = 0 ;
29340 PyObject * obj1 = 0 ;
29341 PyObject * obj2 = 0 ;
29342 PyObject * obj3 = 0 ;
29343 char *kwnames[] = {
29344 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29345 };
29346
29347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29349 if (SWIG_arg_fail(1)) SWIG_fail;
29350 {
29351 arg2 = (int)(SWIG_As_int(obj1));
29352 if (SWIG_arg_fail(2)) SWIG_fail;
29353 }
29354 {
29355 arg3 = (int)(SWIG_As_int(obj2));
29356 if (SWIG_arg_fail(3)) SWIG_fail;
29357 }
29358 {
29359 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29360 if (SWIG_arg_fail(4)) SWIG_fail;
29361 }
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 resultobj = SWIG_From_int((result));
29370 return resultobj;
29371 fail:
29372 return NULL;
29373 }
29374
29375
29376 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29377 PyObject *resultobj;
29378 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29379 int arg2 ;
29380 int arg3 ;
29381 wxDragResult arg4 ;
29382 wxDragResult result;
29383 PyObject * obj0 = 0 ;
29384 PyObject * obj1 = 0 ;
29385 PyObject * obj2 = 0 ;
29386 PyObject * obj3 = 0 ;
29387 char *kwnames[] = {
29388 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29389 };
29390
29391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29393 if (SWIG_arg_fail(1)) SWIG_fail;
29394 {
29395 arg2 = (int)(SWIG_As_int(obj1));
29396 if (SWIG_arg_fail(2)) SWIG_fail;
29397 }
29398 {
29399 arg3 = (int)(SWIG_As_int(obj2));
29400 if (SWIG_arg_fail(3)) SWIG_fail;
29401 }
29402 {
29403 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29404 if (SWIG_arg_fail(4)) SWIG_fail;
29405 }
29406 {
29407 PyThreadState* __tstate = wxPyBeginAllowThreads();
29408 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29409
29410 wxPyEndAllowThreads(__tstate);
29411 if (PyErr_Occurred()) SWIG_fail;
29412 }
29413 resultobj = SWIG_From_int((result));
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj;
29422 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29423 PyObject * obj0 = 0 ;
29424 char *kwnames[] = {
29425 (char *) "self", NULL
29426 };
29427
29428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29430 if (SWIG_arg_fail(1)) SWIG_fail;
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 (arg1)->base_OnLeave();
29434
29435 wxPyEndAllowThreads(__tstate);
29436 if (PyErr_Occurred()) SWIG_fail;
29437 }
29438 Py_INCREF(Py_None); resultobj = Py_None;
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj;
29447 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29448 int arg2 ;
29449 int arg3 ;
29450 bool result;
29451 PyObject * obj0 = 0 ;
29452 PyObject * obj1 = 0 ;
29453 PyObject * obj2 = 0 ;
29454 char *kwnames[] = {
29455 (char *) "self",(char *) "x",(char *) "y", NULL
29456 };
29457
29458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29460 if (SWIG_arg_fail(1)) SWIG_fail;
29461 {
29462 arg2 = (int)(SWIG_As_int(obj1));
29463 if (SWIG_arg_fail(2)) SWIG_fail;
29464 }
29465 {
29466 arg3 = (int)(SWIG_As_int(obj2));
29467 if (SWIG_arg_fail(3)) SWIG_fail;
29468 }
29469 {
29470 PyThreadState* __tstate = wxPyBeginAllowThreads();
29471 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29472
29473 wxPyEndAllowThreads(__tstate);
29474 if (PyErr_Occurred()) SWIG_fail;
29475 }
29476 {
29477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29478 }
29479 return resultobj;
29480 fail:
29481 return NULL;
29482 }
29483
29484
29485 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29486 PyObject *resultobj;
29487 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29488 int arg2 ;
29489 int arg3 ;
29490 wxDragResult arg4 ;
29491 wxDragResult result;
29492 PyObject * obj0 = 0 ;
29493 PyObject * obj1 = 0 ;
29494 PyObject * obj2 = 0 ;
29495 PyObject * obj3 = 0 ;
29496 char *kwnames[] = {
29497 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29498 };
29499
29500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29502 if (SWIG_arg_fail(1)) SWIG_fail;
29503 {
29504 arg2 = (int)(SWIG_As_int(obj1));
29505 if (SWIG_arg_fail(2)) SWIG_fail;
29506 }
29507 {
29508 arg3 = (int)(SWIG_As_int(obj2));
29509 if (SWIG_arg_fail(3)) SWIG_fail;
29510 }
29511 {
29512 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29513 if (SWIG_arg_fail(4)) SWIG_fail;
29514 }
29515 {
29516 PyThreadState* __tstate = wxPyBeginAllowThreads();
29517 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29518
29519 wxPyEndAllowThreads(__tstate);
29520 if (PyErr_Occurred()) SWIG_fail;
29521 }
29522 resultobj = SWIG_From_int((result));
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29530 PyObject *obj;
29531 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29532 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29533 Py_INCREF(obj);
29534 return Py_BuildValue((char *)"");
29535 }
29536 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29537 PyObject *resultobj;
29538 wxPyFileDropTarget *result;
29539 char *kwnames[] = {
29540 NULL
29541 };
29542
29543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29544 {
29545 PyThreadState* __tstate = wxPyBeginAllowThreads();
29546 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29547
29548 wxPyEndAllowThreads(__tstate);
29549 if (PyErr_Occurred()) SWIG_fail;
29550 }
29551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29552 return resultobj;
29553 fail:
29554 return NULL;
29555 }
29556
29557
29558 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29559 PyObject *resultobj;
29560 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29561 PyObject *arg2 = (PyObject *) 0 ;
29562 PyObject *arg3 = (PyObject *) 0 ;
29563 PyObject * obj0 = 0 ;
29564 PyObject * obj1 = 0 ;
29565 PyObject * obj2 = 0 ;
29566 char *kwnames[] = {
29567 (char *) "self",(char *) "self",(char *) "_class", NULL
29568 };
29569
29570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29572 if (SWIG_arg_fail(1)) SWIG_fail;
29573 arg2 = obj1;
29574 arg3 = obj2;
29575 {
29576 PyThreadState* __tstate = wxPyBeginAllowThreads();
29577 (arg1)->_setCallbackInfo(arg2,arg3);
29578
29579 wxPyEndAllowThreads(__tstate);
29580 if (PyErr_Occurred()) SWIG_fail;
29581 }
29582 Py_INCREF(Py_None); resultobj = Py_None;
29583 return resultobj;
29584 fail:
29585 return NULL;
29586 }
29587
29588
29589 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29590 PyObject *resultobj;
29591 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29592 int arg2 ;
29593 int arg3 ;
29594 wxDragResult arg4 ;
29595 wxDragResult result;
29596 PyObject * obj0 = 0 ;
29597 PyObject * obj1 = 0 ;
29598 PyObject * obj2 = 0 ;
29599 PyObject * obj3 = 0 ;
29600 char *kwnames[] = {
29601 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29602 };
29603
29604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29606 if (SWIG_arg_fail(1)) SWIG_fail;
29607 {
29608 arg2 = (int)(SWIG_As_int(obj1));
29609 if (SWIG_arg_fail(2)) SWIG_fail;
29610 }
29611 {
29612 arg3 = (int)(SWIG_As_int(obj2));
29613 if (SWIG_arg_fail(3)) SWIG_fail;
29614 }
29615 {
29616 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29617 if (SWIG_arg_fail(4)) SWIG_fail;
29618 }
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29622
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 resultobj = SWIG_From_int((result));
29627 return resultobj;
29628 fail:
29629 return NULL;
29630 }
29631
29632
29633 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29634 PyObject *resultobj;
29635 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29636 int arg2 ;
29637 int arg3 ;
29638 wxDragResult arg4 ;
29639 wxDragResult result;
29640 PyObject * obj0 = 0 ;
29641 PyObject * obj1 = 0 ;
29642 PyObject * obj2 = 0 ;
29643 PyObject * obj3 = 0 ;
29644 char *kwnames[] = {
29645 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29646 };
29647
29648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29650 if (SWIG_arg_fail(1)) SWIG_fail;
29651 {
29652 arg2 = (int)(SWIG_As_int(obj1));
29653 if (SWIG_arg_fail(2)) SWIG_fail;
29654 }
29655 {
29656 arg3 = (int)(SWIG_As_int(obj2));
29657 if (SWIG_arg_fail(3)) SWIG_fail;
29658 }
29659 {
29660 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29661 if (SWIG_arg_fail(4)) SWIG_fail;
29662 }
29663 {
29664 PyThreadState* __tstate = wxPyBeginAllowThreads();
29665 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29666
29667 wxPyEndAllowThreads(__tstate);
29668 if (PyErr_Occurred()) SWIG_fail;
29669 }
29670 resultobj = SWIG_From_int((result));
29671 return resultobj;
29672 fail:
29673 return NULL;
29674 }
29675
29676
29677 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29678 PyObject *resultobj;
29679 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29680 PyObject * obj0 = 0 ;
29681 char *kwnames[] = {
29682 (char *) "self", NULL
29683 };
29684
29685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29687 if (SWIG_arg_fail(1)) SWIG_fail;
29688 {
29689 PyThreadState* __tstate = wxPyBeginAllowThreads();
29690 (arg1)->base_OnLeave();
29691
29692 wxPyEndAllowThreads(__tstate);
29693 if (PyErr_Occurred()) SWIG_fail;
29694 }
29695 Py_INCREF(Py_None); resultobj = Py_None;
29696 return resultobj;
29697 fail:
29698 return NULL;
29699 }
29700
29701
29702 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29703 PyObject *resultobj;
29704 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29705 int arg2 ;
29706 int arg3 ;
29707 bool result;
29708 PyObject * obj0 = 0 ;
29709 PyObject * obj1 = 0 ;
29710 PyObject * obj2 = 0 ;
29711 char *kwnames[] = {
29712 (char *) "self",(char *) "x",(char *) "y", NULL
29713 };
29714
29715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29717 if (SWIG_arg_fail(1)) SWIG_fail;
29718 {
29719 arg2 = (int)(SWIG_As_int(obj1));
29720 if (SWIG_arg_fail(2)) SWIG_fail;
29721 }
29722 {
29723 arg3 = (int)(SWIG_As_int(obj2));
29724 if (SWIG_arg_fail(3)) SWIG_fail;
29725 }
29726 {
29727 PyThreadState* __tstate = wxPyBeginAllowThreads();
29728 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29729
29730 wxPyEndAllowThreads(__tstate);
29731 if (PyErr_Occurred()) SWIG_fail;
29732 }
29733 {
29734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29735 }
29736 return resultobj;
29737 fail:
29738 return NULL;
29739 }
29740
29741
29742 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29743 PyObject *resultobj;
29744 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29745 int arg2 ;
29746 int arg3 ;
29747 wxDragResult arg4 ;
29748 wxDragResult result;
29749 PyObject * obj0 = 0 ;
29750 PyObject * obj1 = 0 ;
29751 PyObject * obj2 = 0 ;
29752 PyObject * obj3 = 0 ;
29753 char *kwnames[] = {
29754 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29755 };
29756
29757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29759 if (SWIG_arg_fail(1)) SWIG_fail;
29760 {
29761 arg2 = (int)(SWIG_As_int(obj1));
29762 if (SWIG_arg_fail(2)) SWIG_fail;
29763 }
29764 {
29765 arg3 = (int)(SWIG_As_int(obj2));
29766 if (SWIG_arg_fail(3)) SWIG_fail;
29767 }
29768 {
29769 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29770 if (SWIG_arg_fail(4)) SWIG_fail;
29771 }
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29775
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 resultobj = SWIG_From_int((result));
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29787 PyObject *obj;
29788 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29789 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29790 Py_INCREF(obj);
29791 return Py_BuildValue((char *)"");
29792 }
29793 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29794 PyObject *resultobj;
29795 wxClipboard *result;
29796 char *kwnames[] = {
29797 NULL
29798 };
29799
29800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29801 {
29802 PyThreadState* __tstate = wxPyBeginAllowThreads();
29803 result = (wxClipboard *)new wxClipboard();
29804
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29809 return resultobj;
29810 fail:
29811 return NULL;
29812 }
29813
29814
29815 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29816 PyObject *resultobj;
29817 wxClipboard *arg1 = (wxClipboard *) 0 ;
29818 PyObject * obj0 = 0 ;
29819 char *kwnames[] = {
29820 (char *) "self", NULL
29821 };
29822
29823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29825 if (SWIG_arg_fail(1)) SWIG_fail;
29826 {
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 delete arg1;
29829
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 Py_INCREF(Py_None); resultobj = Py_None;
29834 return resultobj;
29835 fail:
29836 return NULL;
29837 }
29838
29839
29840 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29841 PyObject *resultobj;
29842 wxClipboard *arg1 = (wxClipboard *) 0 ;
29843 bool result;
29844 PyObject * obj0 = 0 ;
29845 char *kwnames[] = {
29846 (char *) "self", NULL
29847 };
29848
29849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29851 if (SWIG_arg_fail(1)) SWIG_fail;
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 result = (bool)(arg1)->Open();
29855
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 {
29860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29861 }
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj;
29870 wxClipboard *arg1 = (wxClipboard *) 0 ;
29871 PyObject * obj0 = 0 ;
29872 char *kwnames[] = {
29873 (char *) "self", NULL
29874 };
29875
29876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29878 if (SWIG_arg_fail(1)) SWIG_fail;
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 (arg1)->Close();
29882
29883 wxPyEndAllowThreads(__tstate);
29884 if (PyErr_Occurred()) SWIG_fail;
29885 }
29886 Py_INCREF(Py_None); resultobj = Py_None;
29887 return resultobj;
29888 fail:
29889 return NULL;
29890 }
29891
29892
29893 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29894 PyObject *resultobj;
29895 wxClipboard *arg1 = (wxClipboard *) 0 ;
29896 bool result;
29897 PyObject * obj0 = 0 ;
29898 char *kwnames[] = {
29899 (char *) "self", NULL
29900 };
29901
29902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29904 if (SWIG_arg_fail(1)) SWIG_fail;
29905 {
29906 PyThreadState* __tstate = wxPyBeginAllowThreads();
29907 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29908
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 {
29913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29914 }
29915 return resultobj;
29916 fail:
29917 return NULL;
29918 }
29919
29920
29921 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29922 PyObject *resultobj;
29923 wxClipboard *arg1 = (wxClipboard *) 0 ;
29924 wxDataObject *arg2 = (wxDataObject *) 0 ;
29925 bool result;
29926 PyObject * obj0 = 0 ;
29927 PyObject * obj1 = 0 ;
29928 char *kwnames[] = {
29929 (char *) "self",(char *) "data", NULL
29930 };
29931
29932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29934 if (SWIG_arg_fail(1)) SWIG_fail;
29935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29936 if (SWIG_arg_fail(2)) SWIG_fail;
29937 {
29938 PyThreadState* __tstate = wxPyBeginAllowThreads();
29939 result = (bool)(arg1)->AddData(arg2);
29940
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 {
29945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29946 }
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj;
29955 wxClipboard *arg1 = (wxClipboard *) 0 ;
29956 wxDataObject *arg2 = (wxDataObject *) 0 ;
29957 bool result;
29958 PyObject * obj0 = 0 ;
29959 PyObject * obj1 = 0 ;
29960 char *kwnames[] = {
29961 (char *) "self",(char *) "data", NULL
29962 };
29963
29964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29966 if (SWIG_arg_fail(1)) SWIG_fail;
29967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29968 if (SWIG_arg_fail(2)) SWIG_fail;
29969 {
29970 PyThreadState* __tstate = wxPyBeginAllowThreads();
29971 result = (bool)(arg1)->SetData(arg2);
29972
29973 wxPyEndAllowThreads(__tstate);
29974 if (PyErr_Occurred()) SWIG_fail;
29975 }
29976 {
29977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29978 }
29979 return resultobj;
29980 fail:
29981 return NULL;
29982 }
29983
29984
29985 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29986 PyObject *resultobj;
29987 wxClipboard *arg1 = (wxClipboard *) 0 ;
29988 wxDataFormat *arg2 = 0 ;
29989 bool result;
29990 PyObject * obj0 = 0 ;
29991 PyObject * obj1 = 0 ;
29992 char *kwnames[] = {
29993 (char *) "self",(char *) "format", NULL
29994 };
29995
29996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29998 if (SWIG_arg_fail(1)) SWIG_fail;
29999 {
30000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30001 if (SWIG_arg_fail(2)) SWIG_fail;
30002 if (arg2 == NULL) {
30003 SWIG_null_ref("wxDataFormat");
30004 }
30005 if (SWIG_arg_fail(2)) SWIG_fail;
30006 }
30007 {
30008 PyThreadState* __tstate = wxPyBeginAllowThreads();
30009 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30010
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 {
30015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30016 }
30017 return resultobj;
30018 fail:
30019 return NULL;
30020 }
30021
30022
30023 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30024 PyObject *resultobj;
30025 wxClipboard *arg1 = (wxClipboard *) 0 ;
30026 wxDataObject *arg2 = 0 ;
30027 bool result;
30028 PyObject * obj0 = 0 ;
30029 PyObject * obj1 = 0 ;
30030 char *kwnames[] = {
30031 (char *) "self",(char *) "data", NULL
30032 };
30033
30034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30036 if (SWIG_arg_fail(1)) SWIG_fail;
30037 {
30038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30039 if (SWIG_arg_fail(2)) SWIG_fail;
30040 if (arg2 == NULL) {
30041 SWIG_null_ref("wxDataObject");
30042 }
30043 if (SWIG_arg_fail(2)) SWIG_fail;
30044 }
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = (bool)(arg1)->GetData(*arg2);
30048
30049 wxPyEndAllowThreads(__tstate);
30050 if (PyErr_Occurred()) SWIG_fail;
30051 }
30052 {
30053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30054 }
30055 return resultobj;
30056 fail:
30057 return NULL;
30058 }
30059
30060
30061 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30062 PyObject *resultobj;
30063 wxClipboard *arg1 = (wxClipboard *) 0 ;
30064 PyObject * obj0 = 0 ;
30065 char *kwnames[] = {
30066 (char *) "self", NULL
30067 };
30068
30069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30071 if (SWIG_arg_fail(1)) SWIG_fail;
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 (arg1)->Clear();
30075
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 Py_INCREF(Py_None); resultobj = Py_None;
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30087 PyObject *resultobj;
30088 wxClipboard *arg1 = (wxClipboard *) 0 ;
30089 bool result;
30090 PyObject * obj0 = 0 ;
30091 char *kwnames[] = {
30092 (char *) "self", NULL
30093 };
30094
30095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30097 if (SWIG_arg_fail(1)) SWIG_fail;
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 result = (bool)(arg1)->Flush();
30101
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 {
30106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30107 }
30108 return resultobj;
30109 fail:
30110 return NULL;
30111 }
30112
30113
30114 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30115 PyObject *resultobj;
30116 wxClipboard *arg1 = (wxClipboard *) 0 ;
30117 bool arg2 = (bool) true ;
30118 PyObject * obj0 = 0 ;
30119 PyObject * obj1 = 0 ;
30120 char *kwnames[] = {
30121 (char *) "self",(char *) "primary", NULL
30122 };
30123
30124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30126 if (SWIG_arg_fail(1)) SWIG_fail;
30127 if (obj1) {
30128 {
30129 arg2 = (bool)(SWIG_As_bool(obj1));
30130 if (SWIG_arg_fail(2)) SWIG_fail;
30131 }
30132 }
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 (arg1)->UsePrimarySelection(arg2);
30136
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 Py_INCREF(Py_None); resultobj = Py_None;
30141 return resultobj;
30142 fail:
30143 return NULL;
30144 }
30145
30146
30147 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30148 PyObject *resultobj;
30149 wxClipboard *result;
30150 char *kwnames[] = {
30151 NULL
30152 };
30153
30154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = (wxClipboard *)wxClipboard::Get();
30158
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30170 PyObject *obj;
30171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30172 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30173 Py_INCREF(obj);
30174 return Py_BuildValue((char *)"");
30175 }
30176 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj;
30178 wxClipboard *arg1 = (wxClipboard *) NULL ;
30179 wxClipboardLocker *result;
30180 PyObject * obj0 = 0 ;
30181 char *kwnames[] = {
30182 (char *) "clipboard", NULL
30183 };
30184
30185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30186 if (obj0) {
30187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30188 if (SWIG_arg_fail(1)) SWIG_fail;
30189 }
30190 {
30191 PyThreadState* __tstate = wxPyBeginAllowThreads();
30192 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30193
30194 wxPyEndAllowThreads(__tstate);
30195 if (PyErr_Occurred()) SWIG_fail;
30196 }
30197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30198 return resultobj;
30199 fail:
30200 return NULL;
30201 }
30202
30203
30204 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30205 PyObject *resultobj;
30206 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30207 PyObject * obj0 = 0 ;
30208 char *kwnames[] = {
30209 (char *) "self", NULL
30210 };
30211
30212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30214 if (SWIG_arg_fail(1)) SWIG_fail;
30215 {
30216 PyThreadState* __tstate = wxPyBeginAllowThreads();
30217 delete arg1;
30218
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 Py_INCREF(Py_None); resultobj = Py_None;
30223 return resultobj;
30224 fail:
30225 return NULL;
30226 }
30227
30228
30229 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30230 PyObject *resultobj;
30231 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30232 bool result;
30233 PyObject * obj0 = 0 ;
30234 char *kwnames[] = {
30235 (char *) "self", NULL
30236 };
30237
30238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30240 if (SWIG_arg_fail(1)) SWIG_fail;
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = (bool)wxClipboardLocker___nonzero__(arg1);
30244
30245 wxPyEndAllowThreads(__tstate);
30246 if (PyErr_Occurred()) SWIG_fail;
30247 }
30248 {
30249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30250 }
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30258 PyObject *obj;
30259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30260 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30261 Py_INCREF(obj);
30262 return Py_BuildValue((char *)"");
30263 }
30264 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30265 PyObject *resultobj;
30266 int arg1 = (int) 0 ;
30267 int arg2 = (int) 0 ;
30268 int arg3 = (int) 0 ;
30269 int arg4 = (int) 0 ;
30270 wxVideoMode *result;
30271 PyObject * obj0 = 0 ;
30272 PyObject * obj1 = 0 ;
30273 PyObject * obj2 = 0 ;
30274 PyObject * obj3 = 0 ;
30275 char *kwnames[] = {
30276 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30277 };
30278
30279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30280 if (obj0) {
30281 {
30282 arg1 = (int)(SWIG_As_int(obj0));
30283 if (SWIG_arg_fail(1)) SWIG_fail;
30284 }
30285 }
30286 if (obj1) {
30287 {
30288 arg2 = (int)(SWIG_As_int(obj1));
30289 if (SWIG_arg_fail(2)) SWIG_fail;
30290 }
30291 }
30292 if (obj2) {
30293 {
30294 arg3 = (int)(SWIG_As_int(obj2));
30295 if (SWIG_arg_fail(3)) SWIG_fail;
30296 }
30297 }
30298 if (obj3) {
30299 {
30300 arg4 = (int)(SWIG_As_int(obj3));
30301 if (SWIG_arg_fail(4)) SWIG_fail;
30302 }
30303 }
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30307
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30312 return resultobj;
30313 fail:
30314 return NULL;
30315 }
30316
30317
30318 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30319 PyObject *resultobj;
30320 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30321 PyObject * obj0 = 0 ;
30322 char *kwnames[] = {
30323 (char *) "self", NULL
30324 };
30325
30326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30328 if (SWIG_arg_fail(1)) SWIG_fail;
30329 {
30330 PyThreadState* __tstate = wxPyBeginAllowThreads();
30331 delete arg1;
30332
30333 wxPyEndAllowThreads(__tstate);
30334 if (PyErr_Occurred()) SWIG_fail;
30335 }
30336 Py_INCREF(Py_None); resultobj = Py_None;
30337 return resultobj;
30338 fail:
30339 return NULL;
30340 }
30341
30342
30343 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30344 PyObject *resultobj;
30345 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30346 wxVideoMode *arg2 = 0 ;
30347 bool result;
30348 PyObject * obj0 = 0 ;
30349 PyObject * obj1 = 0 ;
30350 char *kwnames[] = {
30351 (char *) "self",(char *) "other", NULL
30352 };
30353
30354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30356 if (SWIG_arg_fail(1)) SWIG_fail;
30357 {
30358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30359 if (SWIG_arg_fail(2)) SWIG_fail;
30360 if (arg2 == NULL) {
30361 SWIG_null_ref("wxVideoMode");
30362 }
30363 if (SWIG_arg_fail(2)) SWIG_fail;
30364 }
30365 {
30366 PyThreadState* __tstate = wxPyBeginAllowThreads();
30367 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30368
30369 wxPyEndAllowThreads(__tstate);
30370 if (PyErr_Occurred()) SWIG_fail;
30371 }
30372 {
30373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30374 }
30375 return resultobj;
30376 fail:
30377 return NULL;
30378 }
30379
30380
30381 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30382 PyObject *resultobj;
30383 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30384 int result;
30385 PyObject * obj0 = 0 ;
30386 char *kwnames[] = {
30387 (char *) "self", NULL
30388 };
30389
30390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30392 if (SWIG_arg_fail(1)) SWIG_fail;
30393 {
30394 PyThreadState* __tstate = wxPyBeginAllowThreads();
30395 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30396
30397 wxPyEndAllowThreads(__tstate);
30398 if (PyErr_Occurred()) SWIG_fail;
30399 }
30400 {
30401 resultobj = SWIG_From_int((int)(result));
30402 }
30403 return resultobj;
30404 fail:
30405 return NULL;
30406 }
30407
30408
30409 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30410 PyObject *resultobj;
30411 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30412 int result;
30413 PyObject * obj0 = 0 ;
30414 char *kwnames[] = {
30415 (char *) "self", NULL
30416 };
30417
30418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30420 if (SWIG_arg_fail(1)) SWIG_fail;
30421 {
30422 PyThreadState* __tstate = wxPyBeginAllowThreads();
30423 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30424
30425 wxPyEndAllowThreads(__tstate);
30426 if (PyErr_Occurred()) SWIG_fail;
30427 }
30428 {
30429 resultobj = SWIG_From_int((int)(result));
30430 }
30431 return resultobj;
30432 fail:
30433 return NULL;
30434 }
30435
30436
30437 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30438 PyObject *resultobj;
30439 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30440 int result;
30441 PyObject * obj0 = 0 ;
30442 char *kwnames[] = {
30443 (char *) "self", NULL
30444 };
30445
30446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30448 if (SWIG_arg_fail(1)) SWIG_fail;
30449 {
30450 PyThreadState* __tstate = wxPyBeginAllowThreads();
30451 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30452
30453 wxPyEndAllowThreads(__tstate);
30454 if (PyErr_Occurred()) SWIG_fail;
30455 }
30456 {
30457 resultobj = SWIG_From_int((int)(result));
30458 }
30459 return resultobj;
30460 fail:
30461 return NULL;
30462 }
30463
30464
30465 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30466 PyObject *resultobj;
30467 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30468 bool result;
30469 PyObject * obj0 = 0 ;
30470 char *kwnames[] = {
30471 (char *) "self", NULL
30472 };
30473
30474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30476 if (SWIG_arg_fail(1)) SWIG_fail;
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30480
30481 wxPyEndAllowThreads(__tstate);
30482 if (PyErr_Occurred()) SWIG_fail;
30483 }
30484 {
30485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30486 }
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30494 PyObject *resultobj;
30495 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30496 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30497 bool result;
30498 PyObject * obj0 = 0 ;
30499 PyObject * obj1 = 0 ;
30500 char *kwnames[] = {
30501 (char *) "self",(char *) "other", NULL
30502 };
30503
30504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30506 if (SWIG_arg_fail(1)) SWIG_fail;
30507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30508 if (SWIG_arg_fail(2)) SWIG_fail;
30509 {
30510 PyThreadState* __tstate = wxPyBeginAllowThreads();
30511 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30512
30513 wxPyEndAllowThreads(__tstate);
30514 if (PyErr_Occurred()) SWIG_fail;
30515 }
30516 {
30517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30518 }
30519 return resultobj;
30520 fail:
30521 return NULL;
30522 }
30523
30524
30525 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30526 PyObject *resultobj;
30527 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30528 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30529 bool result;
30530 PyObject * obj0 = 0 ;
30531 PyObject * obj1 = 0 ;
30532 char *kwnames[] = {
30533 (char *) "self",(char *) "other", NULL
30534 };
30535
30536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30538 if (SWIG_arg_fail(1)) SWIG_fail;
30539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30540 if (SWIG_arg_fail(2)) SWIG_fail;
30541 {
30542 PyThreadState* __tstate = wxPyBeginAllowThreads();
30543 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30544
30545 wxPyEndAllowThreads(__tstate);
30546 if (PyErr_Occurred()) SWIG_fail;
30547 }
30548 {
30549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30550 }
30551 return resultobj;
30552 fail:
30553 return NULL;
30554 }
30555
30556
30557 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30558 PyObject *resultobj;
30559 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30560 int arg2 ;
30561 PyObject * obj0 = 0 ;
30562 PyObject * obj1 = 0 ;
30563 char *kwnames[] = {
30564 (char *) "self",(char *) "w", NULL
30565 };
30566
30567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30569 if (SWIG_arg_fail(1)) SWIG_fail;
30570 {
30571 arg2 = (int)(SWIG_As_int(obj1));
30572 if (SWIG_arg_fail(2)) SWIG_fail;
30573 }
30574 if (arg1) (arg1)->w = arg2;
30575
30576 Py_INCREF(Py_None); resultobj = Py_None;
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30584 PyObject *resultobj;
30585 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30586 int result;
30587 PyObject * obj0 = 0 ;
30588 char *kwnames[] = {
30589 (char *) "self", NULL
30590 };
30591
30592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30594 if (SWIG_arg_fail(1)) SWIG_fail;
30595 result = (int) ((arg1)->w);
30596
30597 {
30598 resultobj = SWIG_From_int((int)(result));
30599 }
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj;
30608 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30609 int arg2 ;
30610 PyObject * obj0 = 0 ;
30611 PyObject * obj1 = 0 ;
30612 char *kwnames[] = {
30613 (char *) "self",(char *) "h", NULL
30614 };
30615
30616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30618 if (SWIG_arg_fail(1)) SWIG_fail;
30619 {
30620 arg2 = (int)(SWIG_As_int(obj1));
30621 if (SWIG_arg_fail(2)) SWIG_fail;
30622 }
30623 if (arg1) (arg1)->h = arg2;
30624
30625 Py_INCREF(Py_None); resultobj = Py_None;
30626 return resultobj;
30627 fail:
30628 return NULL;
30629 }
30630
30631
30632 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30633 PyObject *resultobj;
30634 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30635 int result;
30636 PyObject * obj0 = 0 ;
30637 char *kwnames[] = {
30638 (char *) "self", NULL
30639 };
30640
30641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30643 if (SWIG_arg_fail(1)) SWIG_fail;
30644 result = (int) ((arg1)->h);
30645
30646 {
30647 resultobj = SWIG_From_int((int)(result));
30648 }
30649 return resultobj;
30650 fail:
30651 return NULL;
30652 }
30653
30654
30655 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30656 PyObject *resultobj;
30657 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30658 int arg2 ;
30659 PyObject * obj0 = 0 ;
30660 PyObject * obj1 = 0 ;
30661 char *kwnames[] = {
30662 (char *) "self",(char *) "bpp", NULL
30663 };
30664
30665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30667 if (SWIG_arg_fail(1)) SWIG_fail;
30668 {
30669 arg2 = (int)(SWIG_As_int(obj1));
30670 if (SWIG_arg_fail(2)) SWIG_fail;
30671 }
30672 if (arg1) (arg1)->bpp = arg2;
30673
30674 Py_INCREF(Py_None); resultobj = Py_None;
30675 return resultobj;
30676 fail:
30677 return NULL;
30678 }
30679
30680
30681 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30682 PyObject *resultobj;
30683 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30684 int result;
30685 PyObject * obj0 = 0 ;
30686 char *kwnames[] = {
30687 (char *) "self", NULL
30688 };
30689
30690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30692 if (SWIG_arg_fail(1)) SWIG_fail;
30693 result = (int) ((arg1)->bpp);
30694
30695 {
30696 resultobj = SWIG_From_int((int)(result));
30697 }
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30705 PyObject *resultobj;
30706 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30707 int arg2 ;
30708 PyObject * obj0 = 0 ;
30709 PyObject * obj1 = 0 ;
30710 char *kwnames[] = {
30711 (char *) "self",(char *) "refresh", NULL
30712 };
30713
30714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30716 if (SWIG_arg_fail(1)) SWIG_fail;
30717 {
30718 arg2 = (int)(SWIG_As_int(obj1));
30719 if (SWIG_arg_fail(2)) SWIG_fail;
30720 }
30721 if (arg1) (arg1)->refresh = arg2;
30722
30723 Py_INCREF(Py_None); resultobj = Py_None;
30724 return resultobj;
30725 fail:
30726 return NULL;
30727 }
30728
30729
30730 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30731 PyObject *resultobj;
30732 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30733 int result;
30734 PyObject * obj0 = 0 ;
30735 char *kwnames[] = {
30736 (char *) "self", NULL
30737 };
30738
30739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30741 if (SWIG_arg_fail(1)) SWIG_fail;
30742 result = (int) ((arg1)->refresh);
30743
30744 {
30745 resultobj = SWIG_From_int((int)(result));
30746 }
30747 return resultobj;
30748 fail:
30749 return NULL;
30750 }
30751
30752
30753 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30754 PyObject *obj;
30755 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30756 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30757 Py_INCREF(obj);
30758 return Py_BuildValue((char *)"");
30759 }
30760 static int _wrap_DefaultVideoMode_set(PyObject *) {
30761 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30762 return 1;
30763 }
30764
30765
30766 static PyObject *_wrap_DefaultVideoMode_get(void) {
30767 PyObject *pyobj;
30768
30769 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30770 return pyobj;
30771 }
30772
30773
30774 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30775 PyObject *resultobj;
30776 size_t arg1 = (size_t) 0 ;
30777 wxDisplay *result;
30778 PyObject * obj0 = 0 ;
30779 char *kwnames[] = {
30780 (char *) "index", NULL
30781 };
30782
30783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30784 if (obj0) {
30785 {
30786 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30787 if (SWIG_arg_fail(1)) SWIG_fail;
30788 }
30789 }
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 result = (wxDisplay *)new wxDisplay(arg1);
30793
30794 wxPyEndAllowThreads(__tstate);
30795 if (PyErr_Occurred()) SWIG_fail;
30796 }
30797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30805 PyObject *resultobj;
30806 wxDisplay *arg1 = (wxDisplay *) 0 ;
30807 PyObject * obj0 = 0 ;
30808 char *kwnames[] = {
30809 (char *) "self", NULL
30810 };
30811
30812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30814 if (SWIG_arg_fail(1)) SWIG_fail;
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 delete arg1;
30818
30819 wxPyEndAllowThreads(__tstate);
30820 if (PyErr_Occurred()) SWIG_fail;
30821 }
30822 Py_INCREF(Py_None); resultobj = Py_None;
30823 return resultobj;
30824 fail:
30825 return NULL;
30826 }
30827
30828
30829 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30830 PyObject *resultobj;
30831 size_t result;
30832 char *kwnames[] = {
30833 NULL
30834 };
30835
30836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30837 {
30838 PyThreadState* __tstate = wxPyBeginAllowThreads();
30839 result = (size_t)wxDisplay::GetCount();
30840
30841 wxPyEndAllowThreads(__tstate);
30842 if (PyErr_Occurred()) SWIG_fail;
30843 }
30844 {
30845 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30846 }
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30854 PyObject *resultobj;
30855 wxPoint *arg1 = 0 ;
30856 int result;
30857 wxPoint temp1 ;
30858 PyObject * obj0 = 0 ;
30859 char *kwnames[] = {
30860 (char *) "pt", NULL
30861 };
30862
30863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30864 {
30865 arg1 = &temp1;
30866 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30867 }
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30871
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 {
30876 resultobj = SWIG_From_int((int)(result));
30877 }
30878 return resultobj;
30879 fail:
30880 return NULL;
30881 }
30882
30883
30884 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30885 PyObject *resultobj;
30886 wxWindow *arg1 = (wxWindow *) 0 ;
30887 int result;
30888 PyObject * obj0 = 0 ;
30889 char *kwnames[] = {
30890 (char *) "window", NULL
30891 };
30892
30893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30895 if (SWIG_arg_fail(1)) SWIG_fail;
30896 {
30897 PyThreadState* __tstate = wxPyBeginAllowThreads();
30898 result = (int)Display_GetFromWindow(arg1);
30899
30900 wxPyEndAllowThreads(__tstate);
30901 if (PyErr_Occurred()) SWIG_fail;
30902 }
30903 {
30904 resultobj = SWIG_From_int((int)(result));
30905 }
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30913 PyObject *resultobj;
30914 wxDisplay *arg1 = (wxDisplay *) 0 ;
30915 bool result;
30916 PyObject * obj0 = 0 ;
30917 char *kwnames[] = {
30918 (char *) "self", NULL
30919 };
30920
30921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30923 if (SWIG_arg_fail(1)) SWIG_fail;
30924 {
30925 PyThreadState* __tstate = wxPyBeginAllowThreads();
30926 result = (bool)((wxDisplay const *)arg1)->IsOk();
30927
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 {
30932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30933 }
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj;
30942 wxDisplay *arg1 = (wxDisplay *) 0 ;
30943 wxRect result;
30944 PyObject * obj0 = 0 ;
30945 char *kwnames[] = {
30946 (char *) "self", NULL
30947 };
30948
30949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30951 if (SWIG_arg_fail(1)) SWIG_fail;
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 result = ((wxDisplay const *)arg1)->GetGeometry();
30955
30956 wxPyEndAllowThreads(__tstate);
30957 if (PyErr_Occurred()) SWIG_fail;
30958 }
30959 {
30960 wxRect * resultptr;
30961 resultptr = new wxRect((wxRect &)(result));
30962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30963 }
30964 return resultobj;
30965 fail:
30966 return NULL;
30967 }
30968
30969
30970 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30971 PyObject *resultobj;
30972 wxDisplay *arg1 = (wxDisplay *) 0 ;
30973 wxString result;
30974 PyObject * obj0 = 0 ;
30975 char *kwnames[] = {
30976 (char *) "self", NULL
30977 };
30978
30979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30981 if (SWIG_arg_fail(1)) SWIG_fail;
30982 {
30983 PyThreadState* __tstate = wxPyBeginAllowThreads();
30984 result = ((wxDisplay const *)arg1)->GetName();
30985
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 {
30990 #if wxUSE_UNICODE
30991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30992 #else
30993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30994 #endif
30995 }
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31003 PyObject *resultobj;
31004 wxDisplay *arg1 = (wxDisplay *) 0 ;
31005 bool result;
31006 PyObject * obj0 = 0 ;
31007 char *kwnames[] = {
31008 (char *) "self", NULL
31009 };
31010
31011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31013 if (SWIG_arg_fail(1)) SWIG_fail;
31014 {
31015 PyThreadState* __tstate = wxPyBeginAllowThreads();
31016 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31017
31018 wxPyEndAllowThreads(__tstate);
31019 if (PyErr_Occurred()) SWIG_fail;
31020 }
31021 {
31022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31023 }
31024 return resultobj;
31025 fail:
31026 return NULL;
31027 }
31028
31029
31030 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31031 PyObject *resultobj;
31032 wxDisplay *arg1 = (wxDisplay *) 0 ;
31033 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31034 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31035 PyObject *result;
31036 PyObject * obj0 = 0 ;
31037 PyObject * obj1 = 0 ;
31038 char *kwnames[] = {
31039 (char *) "self",(char *) "mode", NULL
31040 };
31041
31042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31044 if (SWIG_arg_fail(1)) SWIG_fail;
31045 if (obj1) {
31046 {
31047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31048 if (SWIG_arg_fail(2)) SWIG_fail;
31049 if (arg2 == NULL) {
31050 SWIG_null_ref("wxVideoMode");
31051 }
31052 if (SWIG_arg_fail(2)) SWIG_fail;
31053 }
31054 }
31055 {
31056 PyThreadState* __tstate = wxPyBeginAllowThreads();
31057 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31058
31059 wxPyEndAllowThreads(__tstate);
31060 if (PyErr_Occurred()) SWIG_fail;
31061 }
31062 resultobj = result;
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31070 PyObject *resultobj;
31071 wxDisplay *arg1 = (wxDisplay *) 0 ;
31072 wxVideoMode result;
31073 PyObject * obj0 = 0 ;
31074 char *kwnames[] = {
31075 (char *) "self", NULL
31076 };
31077
31078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31080 if (SWIG_arg_fail(1)) SWIG_fail;
31081 {
31082 PyThreadState* __tstate = wxPyBeginAllowThreads();
31083 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31084
31085 wxPyEndAllowThreads(__tstate);
31086 if (PyErr_Occurred()) SWIG_fail;
31087 }
31088 {
31089 wxVideoMode * resultptr;
31090 resultptr = new wxVideoMode((wxVideoMode &)(result));
31091 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31092 }
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31100 PyObject *resultobj;
31101 wxDisplay *arg1 = (wxDisplay *) 0 ;
31102 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31103 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31104 bool result;
31105 PyObject * obj0 = 0 ;
31106 PyObject * obj1 = 0 ;
31107 char *kwnames[] = {
31108 (char *) "self",(char *) "mode", NULL
31109 };
31110
31111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31113 if (SWIG_arg_fail(1)) SWIG_fail;
31114 if (obj1) {
31115 {
31116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31117 if (SWIG_arg_fail(2)) SWIG_fail;
31118 if (arg2 == NULL) {
31119 SWIG_null_ref("wxVideoMode");
31120 }
31121 if (SWIG_arg_fail(2)) SWIG_fail;
31122 }
31123 }
31124 {
31125 PyThreadState* __tstate = wxPyBeginAllowThreads();
31126 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31127
31128 wxPyEndAllowThreads(__tstate);
31129 if (PyErr_Occurred()) SWIG_fail;
31130 }
31131 {
31132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31133 }
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj;
31142 wxDisplay *arg1 = (wxDisplay *) 0 ;
31143 PyObject * obj0 = 0 ;
31144 char *kwnames[] = {
31145 (char *) "self", NULL
31146 };
31147
31148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31150 if (SWIG_arg_fail(1)) SWIG_fail;
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 (arg1)->ResetMode();
31154
31155 wxPyEndAllowThreads(__tstate);
31156 if (PyErr_Occurred()) SWIG_fail;
31157 }
31158 Py_INCREF(Py_None); resultobj = Py_None;
31159 return resultobj;
31160 fail:
31161 return NULL;
31162 }
31163
31164
31165 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31166 PyObject *obj;
31167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31168 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31169 Py_INCREF(obj);
31170 return Py_BuildValue((char *)"");
31171 }
31172 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31173 PyObject *resultobj;
31174 wxStandardPaths *result;
31175 char *kwnames[] = {
31176 NULL
31177 };
31178
31179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31180 {
31181 PyThreadState* __tstate = wxPyBeginAllowThreads();
31182 result = (wxStandardPaths *)StandardPaths_Get();
31183
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31195 PyObject *resultobj;
31196 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31197 wxString result;
31198 PyObject * obj0 = 0 ;
31199 char *kwnames[] = {
31200 (char *) "self", NULL
31201 };
31202
31203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31205 if (SWIG_arg_fail(1)) SWIG_fail;
31206 {
31207 PyThreadState* __tstate = wxPyBeginAllowThreads();
31208 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31209
31210 wxPyEndAllowThreads(__tstate);
31211 if (PyErr_Occurred()) SWIG_fail;
31212 }
31213 {
31214 #if wxUSE_UNICODE
31215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31216 #else
31217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31218 #endif
31219 }
31220 return resultobj;
31221 fail:
31222 return NULL;
31223 }
31224
31225
31226 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31227 PyObject *resultobj;
31228 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31229 wxString result;
31230 PyObject * obj0 = 0 ;
31231 char *kwnames[] = {
31232 (char *) "self", NULL
31233 };
31234
31235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31237 if (SWIG_arg_fail(1)) SWIG_fail;
31238 {
31239 PyThreadState* __tstate = wxPyBeginAllowThreads();
31240 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31241
31242 wxPyEndAllowThreads(__tstate);
31243 if (PyErr_Occurred()) SWIG_fail;
31244 }
31245 {
31246 #if wxUSE_UNICODE
31247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31248 #else
31249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31250 #endif
31251 }
31252 return resultobj;
31253 fail:
31254 return NULL;
31255 }
31256
31257
31258 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31259 PyObject *resultobj;
31260 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31261 wxString result;
31262 PyObject * obj0 = 0 ;
31263 char *kwnames[] = {
31264 (char *) "self", NULL
31265 };
31266
31267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31269 if (SWIG_arg_fail(1)) SWIG_fail;
31270 {
31271 PyThreadState* __tstate = wxPyBeginAllowThreads();
31272 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31273
31274 wxPyEndAllowThreads(__tstate);
31275 if (PyErr_Occurred()) SWIG_fail;
31276 }
31277 {
31278 #if wxUSE_UNICODE
31279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31280 #else
31281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31282 #endif
31283 }
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31291 PyObject *resultobj;
31292 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31293 wxString result;
31294 PyObject * obj0 = 0 ;
31295 char *kwnames[] = {
31296 (char *) "self", NULL
31297 };
31298
31299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31301 if (SWIG_arg_fail(1)) SWIG_fail;
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31305
31306 wxPyEndAllowThreads(__tstate);
31307 if (PyErr_Occurred()) SWIG_fail;
31308 }
31309 {
31310 #if wxUSE_UNICODE
31311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31312 #else
31313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31314 #endif
31315 }
31316 return resultobj;
31317 fail:
31318 return NULL;
31319 }
31320
31321
31322 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31323 PyObject *resultobj;
31324 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31325 wxString result;
31326 PyObject * obj0 = 0 ;
31327 char *kwnames[] = {
31328 (char *) "self", NULL
31329 };
31330
31331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31333 if (SWIG_arg_fail(1)) SWIG_fail;
31334 {
31335 PyThreadState* __tstate = wxPyBeginAllowThreads();
31336 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31337
31338 wxPyEndAllowThreads(__tstate);
31339 if (PyErr_Occurred()) SWIG_fail;
31340 }
31341 {
31342 #if wxUSE_UNICODE
31343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31344 #else
31345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31346 #endif
31347 }
31348 return resultobj;
31349 fail:
31350 return NULL;
31351 }
31352
31353
31354 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31355 PyObject *resultobj;
31356 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31357 wxString result;
31358 PyObject * obj0 = 0 ;
31359 char *kwnames[] = {
31360 (char *) "self", NULL
31361 };
31362
31363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31365 if (SWIG_arg_fail(1)) SWIG_fail;
31366 {
31367 PyThreadState* __tstate = wxPyBeginAllowThreads();
31368 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31369
31370 wxPyEndAllowThreads(__tstate);
31371 if (PyErr_Occurred()) SWIG_fail;
31372 }
31373 {
31374 #if wxUSE_UNICODE
31375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31376 #else
31377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31378 #endif
31379 }
31380 return resultobj;
31381 fail:
31382 return NULL;
31383 }
31384
31385
31386 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31387 PyObject *resultobj;
31388 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31389 wxString result;
31390 PyObject * obj0 = 0 ;
31391 char *kwnames[] = {
31392 (char *) "self", NULL
31393 };
31394
31395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31397 if (SWIG_arg_fail(1)) SWIG_fail;
31398 {
31399 PyThreadState* __tstate = wxPyBeginAllowThreads();
31400 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31401
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 {
31406 #if wxUSE_UNICODE
31407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31408 #else
31409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31410 #endif
31411 }
31412 return resultobj;
31413 fail:
31414 return NULL;
31415 }
31416
31417
31418 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31419 PyObject *resultobj;
31420 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31421 wxString *arg2 = 0 ;
31422 bool temp2 = false ;
31423 PyObject * obj0 = 0 ;
31424 PyObject * obj1 = 0 ;
31425 char *kwnames[] = {
31426 (char *) "self",(char *) "prefix", NULL
31427 };
31428
31429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31431 if (SWIG_arg_fail(1)) SWIG_fail;
31432 {
31433 arg2 = wxString_in_helper(obj1);
31434 if (arg2 == NULL) SWIG_fail;
31435 temp2 = true;
31436 }
31437 {
31438 PyThreadState* __tstate = wxPyBeginAllowThreads();
31439 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31440
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 Py_INCREF(Py_None); resultobj = Py_None;
31445 {
31446 if (temp2)
31447 delete arg2;
31448 }
31449 return resultobj;
31450 fail:
31451 {
31452 if (temp2)
31453 delete arg2;
31454 }
31455 return NULL;
31456 }
31457
31458
31459 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31460 PyObject *resultobj;
31461 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31462 wxString result;
31463 PyObject * obj0 = 0 ;
31464 char *kwnames[] = {
31465 (char *) "self", NULL
31466 };
31467
31468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31470 if (SWIG_arg_fail(1)) SWIG_fail;
31471 {
31472 PyThreadState* __tstate = wxPyBeginAllowThreads();
31473 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31474
31475 wxPyEndAllowThreads(__tstate);
31476 if (PyErr_Occurred()) SWIG_fail;
31477 }
31478 {
31479 #if wxUSE_UNICODE
31480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31481 #else
31482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31483 #endif
31484 }
31485 return resultobj;
31486 fail:
31487 return NULL;
31488 }
31489
31490
31491 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31492 PyObject *obj;
31493 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31494 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31495 Py_INCREF(obj);
31496 return Py_BuildValue((char *)"");
31497 }
31498 static PyMethodDef SwigMethods[] = {
31499 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31506 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31514 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31580 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31588 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31606 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31609 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31612 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31615 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31621 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31635 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31641 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31647 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31650 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31664 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31667 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31668 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31671 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31698 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31700 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31702 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31704 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31711 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31717 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31731 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31735 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31738 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31755 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31763 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31810 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31828 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31838 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31854 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31870 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31884 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31894 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31937 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31940 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31943 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31947 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32040 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32041 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32042 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32043 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32060 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32105 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32139 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32147 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32148 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32153 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32162 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32169 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32172 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32175 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32180 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32183 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32187 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32190 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32194 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32195 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32199 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32203 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32205 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32215 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32228 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32236 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32244 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32258 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32262 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32277 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32280 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32294 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32305 { NULL, NULL, 0, NULL }
32306 };
32307
32308
32309 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32310
32311 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32312 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32313 }
32314 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32315 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32316 }
32317 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32318 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32319 }
32320 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32321 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32322 }
32323 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32324 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32325 }
32326 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32327 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32328 }
32329 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32330 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32331 }
32332 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32333 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32334 }
32335 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32336 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32337 }
32338 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32339 return (void *)((wxEvent *) ((wxPyEvent *) x));
32340 }
32341 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32342 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32343 }
32344 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32345 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32346 }
32347 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32348 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32349 }
32350 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32351 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32352 }
32353 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32354 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32355 }
32356 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32357 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32358 }
32359 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32360 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32361 }
32362 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32363 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32364 }
32365 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32366 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32367 }
32368 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32369 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32370 }
32371 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32372 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32373 }
32374 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32375 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32376 }
32377 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32378 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32379 }
32380 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32381 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32382 }
32383 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32384 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32385 }
32386 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32387 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32388 }
32389 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32390 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32391 }
32392 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32393 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32394 }
32395 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32396 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32397 }
32398 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32399 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32400 }
32401 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32402 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32403 }
32404 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32405 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32406 }
32407 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32408 return (void *)((wxEvent *) ((wxShowEvent *) x));
32409 }
32410 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32411 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32412 }
32413 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32414 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32415 }
32416 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32417 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32418 }
32419 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32420 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32421 }
32422 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32423 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32424 }
32425 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32426 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32427 }
32428 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32429 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32430 }
32431 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32432 return (void *)((wxConfigBase *) ((wxConfig *) x));
32433 }
32434 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32435 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32436 }
32437 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32438 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32439 }
32440 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32441 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32442 }
32443 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32444 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32445 }
32446 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32447 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32448 }
32449 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32450 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32451 }
32452 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32453 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32454 }
32455 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32456 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32457 }
32458 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32459 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32460 }
32461 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32462 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32463 }
32464 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32465 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32466 }
32467 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32468 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32469 }
32470 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32471 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32472 }
32473 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32474 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32475 }
32476 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32477 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32478 }
32479 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32480 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32481 }
32482 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32483 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32484 }
32485 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32486 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32487 }
32488 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32489 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32490 }
32491 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32492 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32493 }
32494 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32495 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32496 }
32497 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32498 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32499 }
32500 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32501 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32502 }
32503 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32504 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32505 }
32506 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32507 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32508 }
32509 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32510 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32511 }
32512 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32513 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32514 }
32515 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32516 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32517 }
32518 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32519 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32520 }
32521 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32522 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32523 }
32524 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32525 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32526 }
32527 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32528 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32529 }
32530 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32531 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32532 }
32533 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32534 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32535 }
32536 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32537 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32538 }
32539 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32540 return (void *)((wxObject *) ((wxSizerItem *) x));
32541 }
32542 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32543 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32544 }
32545 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32546 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32547 }
32548 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32549 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32550 }
32551 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32552 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32553 }
32554 static void *_p_wxSizerTo_p_wxObject(void *x) {
32555 return (void *)((wxObject *) ((wxSizer *) x));
32556 }
32557 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32559 }
32560 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) ((wxFileHistory *) x));
32562 }
32563 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32565 }
32566 static void *_p_wxEventTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) ((wxEvent *) x));
32568 }
32569 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32571 }
32572 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32574 }
32575 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32577 }
32578 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32579 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32580 }
32581 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32582 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32583 }
32584 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32585 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32586 }
32587 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32588 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32589 }
32590 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32591 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32592 }
32593 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32594 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32595 }
32596 static void *_p_wxControlTo_p_wxObject(void *x) {
32597 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32598 }
32599 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32600 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32601 }
32602 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32603 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32604 }
32605 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32606 return (void *)((wxObject *) ((wxFSFile *) x));
32607 }
32608 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32609 return (void *)((wxObject *) ((wxClipboard *) x));
32610 }
32611 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32612 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32613 }
32614 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32615 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32616 }
32617 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32618 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32619 }
32620 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32621 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32622 }
32623 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32624 return (void *)((wxObject *) ((wxToolTip *) x));
32625 }
32626 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32627 return (void *)((wxObject *) ((wxMenuItem *) x));
32628 }
32629 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32630 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32631 }
32632 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32633 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32634 }
32635 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32636 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32637 }
32638 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32639 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32640 }
32641 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32642 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32643 }
32644 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32645 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32646 }
32647 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32648 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32649 }
32650 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32651 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32652 }
32653 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32654 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32655 }
32656 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32657 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32658 }
32659 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32660 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32661 }
32662 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32663 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32664 }
32665 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32666 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32667 }
32668 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32669 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32670 }
32671 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32672 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32673 }
32674 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32675 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32676 }
32677 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32678 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32679 }
32680 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32681 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32682 }
32683 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32684 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32685 }
32686 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32687 return (void *)((wxObject *) ((wxImageHandler *) x));
32688 }
32689 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32690 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32691 }
32692 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32693 return (void *)((wxObject *) ((wxEvtHandler *) x));
32694 }
32695 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32696 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32697 }
32698 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32699 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32700 }
32701 static void *_p_wxImageTo_p_wxObject(void *x) {
32702 return (void *)((wxObject *) ((wxImage *) x));
32703 }
32704 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32705 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32706 }
32707 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32708 return (void *)((wxObject *) ((wxSystemOptions *) x));
32709 }
32710 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32711 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32712 }
32713 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32714 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32715 }
32716 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32717 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32718 }
32719 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32720 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32721 }
32722 static void *_p_wxWindowTo_p_wxObject(void *x) {
32723 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32724 }
32725 static void *_p_wxMenuTo_p_wxObject(void *x) {
32726 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32727 }
32728 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32729 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32730 }
32731 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32732 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32733 }
32734 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32735 return (void *)((wxObject *) ((wxFileSystem *) x));
32736 }
32737 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32738 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32739 }
32740 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32741 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32742 }
32743 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32744 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32745 }
32746 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32747 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32748 }
32749 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32750 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32751 }
32752 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32753 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32754 }
32755 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32756 return (void *)((wxObject *) ((wxBusyInfo *) x));
32757 }
32758 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32759 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32760 }
32761 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32762 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32763 }
32764 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32765 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32766 }
32767 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32768 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32769 }
32770 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32771 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32772 }
32773 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32774 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32775 }
32776 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32777 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32778 }
32779 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32780 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32781 }
32782 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32783 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32784 }
32785 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32786 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32787 }
32788 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32789 return (void *)((wxLog *) ((wxLogStderr *) x));
32790 }
32791 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32792 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32793 }
32794 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32795 return (void *)((wxLog *) ((wxLogWindow *) x));
32796 }
32797 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32798 return (void *)((wxLog *) ((wxLogChain *) x));
32799 }
32800 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32801 return (void *)((wxLog *) ((wxLogGui *) x));
32802 }
32803 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32804 return (void *)((wxLog *) ((wxPyLog *) x));
32805 }
32806 static void *_p_wxControlTo_p_wxWindow(void *x) {
32807 return (void *)((wxWindow *) ((wxControl *) x));
32808 }
32809 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32810 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32811 }
32812 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32813 return (void *)((wxWindow *) ((wxMenuBar *) x));
32814 }
32815 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32816 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32817 }
32818 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32819 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32820 }
32821 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}};
32822 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}};
32823 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}};
32824 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}};
32825 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}};
32826 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}};
32827 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}};
32828 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}};
32829 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}};
32830 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}};
32831 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}};
32832 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}};
32833 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}};
32834 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}};
32835 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}};
32836 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}};
32837 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}};
32838 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}};
32839 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}};
32840 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}};
32841 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}};
32842 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}};
32843 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}};
32844 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}};
32845 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}};
32846 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}};
32847 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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 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}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 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}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 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}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882 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}};
32883 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}};
32884 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}};
32885 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}};
32886 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}};
32887 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}};
32888 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}};
32889 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}};
32890 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}};
32891 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}};
32892 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}};
32893 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}};
32894 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}};
32895 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}};
32896 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}};
32897 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}};
32898 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}};
32899 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}};
32900 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}};
32901 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}};
32902 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}};
32903 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}};
32904 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}};
32905 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}};
32906 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}};
32907 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}};
32908 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}};
32909 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}};
32910 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}};
32911 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}};
32912 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}};
32913 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}};
32914 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}};
32915 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}};
32916 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}};
32917 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}};
32918
32919 static swig_type_info *swig_types_initial[] = {
32920 _swigt__p_wxLogChain,
32921 _swigt__p_wxMutexGuiLocker,
32922 _swigt__p_wxFileHistory,
32923 _swigt__p_wxLog,
32924 _swigt__p_wxMenu,
32925 _swigt__p_wxEvent,
32926 _swigt__p_wxDateTime__TimeZone,
32927 _swigt__p_wxConfigBase,
32928 _swigt__p_wxDisplay,
32929 _swigt__p_wxFileType,
32930 _swigt__p_wxLogGui,
32931 _swigt__p_wxFont,
32932 _swigt__p_wxDataFormat,
32933 _swigt__p_wxTimerEvent,
32934 _swigt__p_wxCaret,
32935 _swigt__ptrdiff_t,
32936 _swigt__std__ptrdiff_t,
32937 _swigt__p_void,
32938 _swigt__p_int,
32939 _swigt__p_wxSize,
32940 _swigt__p_wxClipboard,
32941 _swigt__p_wxStopWatch,
32942 _swigt__p_wxDC,
32943 _swigt__p_wxClipboardLocker,
32944 _swigt__p_wxIcon,
32945 _swigt__p_wxLogStderr,
32946 _swigt__p_wxLogTextCtrl,
32947 _swigt__p_wxTextCtrl,
32948 _swigt__p_wxBusyCursor,
32949 _swigt__p_wxBitmapDataObject,
32950 _swigt__p_wxTextDataObject,
32951 _swigt__p_wxDataObject,
32952 _swigt__p_wxPyTextDataObject,
32953 _swigt__p_wxPyBitmapDataObject,
32954 _swigt__p_wxFileDataObject,
32955 _swigt__p_wxCustomDataObject,
32956 _swigt__p_wxURLDataObject,
32957 _swigt__p_wxMetafileDataObject,
32958 _swigt__p_wxSound,
32959 _swigt__p_wxTimerRunner,
32960 _swigt__p_wxLogWindow,
32961 _swigt__p_wxTimeSpan,
32962 _swigt__p_wxArrayString,
32963 _swigt__p_wxWindowDisabler,
32964 _swigt__p_form_ops_t,
32965 _swigt__p_wxToolTip,
32966 _swigt__p_wxDataObjectComposite,
32967 _swigt__p_wxSystemSettings,
32968 _swigt__p_wxFileConfig,
32969 _swigt__p_wxVideoMode,
32970 _swigt__p_wxDataObjectSimple,
32971 _swigt__p_wxPyDataObjectSimple,
32972 _swigt__p_wxDuplexMode,
32973 _swigt__p_wxEvtHandler,
32974 _swigt__p_wxRect,
32975 _swigt__p_char,
32976 _swigt__p_wxSingleInstanceChecker,
32977 _swigt__p_wxStandardPaths,
32978 _swigt__p_wxFileTypeInfo,
32979 _swigt__p_wxFrame,
32980 _swigt__p_wxTimer,
32981 _swigt__p_wxPaperSize,
32982 _swigt__p_wxMimeTypesManager,
32983 _swigt__p_wxPyArtProvider,
32984 _swigt__p_wxPyTipProvider,
32985 _swigt__p_wxTipProvider,
32986 _swigt__p_wxJoystick,
32987 _swigt__p_wxSystemOptions,
32988 _swigt__p_wxPoint,
32989 _swigt__p_wxJoystickEvent,
32990 _swigt__p_wxCursor,
32991 _swigt__p_wxObject,
32992 _swigt__p_wxOutputStream,
32993 _swigt__p_wxDateTime,
32994 _swigt__p_wxPyDropSource,
32995 _swigt__p_unsigned_long,
32996 _swigt__p_wxKillError,
32997 _swigt__p_wxWindow,
32998 _swigt__p_wxString,
32999 _swigt__p_wxPyProcess,
33000 _swigt__p_wxBitmap,
33001 _swigt__unsigned_int,
33002 _swigt__p_unsigned_int,
33003 _swigt__p_wxConfig,
33004 _swigt__p_unsigned_char,
33005 _swigt__p_wxChar,
33006 _swigt__p_wxBusyInfo,
33007 _swigt__p_wxPyDropTarget,
33008 _swigt__p_wxPyTextDropTarget,
33009 _swigt__p_wxPyFileDropTarget,
33010 _swigt__p_wxProcessEvent,
33011 _swigt__p_wxPyLog,
33012 _swigt__p_wxLogNull,
33013 _swigt__p_wxColour,
33014 _swigt__p_wxPyTimer,
33015 _swigt__p_wxConfigPathChanger,
33016 _swigt__p_wxDateSpan,
33017 0
33018 };
33019
33020
33021 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33022
33023 static swig_const_info swig_const_table[] = {
33024 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33025 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33026 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33027 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33028 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33029 {0, 0, 0, 0.0, 0, 0}};
33030
33031 #ifdef __cplusplus
33032 }
33033 #endif
33034
33035
33036 #ifdef __cplusplus
33037 extern "C" {
33038 #endif
33039
33040 /* Python-specific SWIG API */
33041 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33042 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33043 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33044
33045 /* -----------------------------------------------------------------------------
33046 * global variable support code.
33047 * ----------------------------------------------------------------------------- */
33048
33049 typedef struct swig_globalvar {
33050 char *name; /* Name of global variable */
33051 PyObject *(*get_attr)(); /* Return the current value */
33052 int (*set_attr)(PyObject *); /* Set the value */
33053 struct swig_globalvar *next;
33054 } swig_globalvar;
33055
33056 typedef struct swig_varlinkobject {
33057 PyObject_HEAD
33058 swig_globalvar *vars;
33059 } swig_varlinkobject;
33060
33061 static PyObject *
33062 swig_varlink_repr(swig_varlinkobject *v) {
33063 v = v;
33064 return PyString_FromString("<Swig global variables>");
33065 }
33066
33067 static int
33068 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33069 swig_globalvar *var;
33070 flags = flags;
33071 fprintf(fp,"Swig global variables { ");
33072 for (var = v->vars; var; var=var->next) {
33073 fprintf(fp,"%s", var->name);
33074 if (var->next) fprintf(fp,", ");
33075 }
33076 fprintf(fp," }\n");
33077 return 0;
33078 }
33079
33080 static PyObject *
33081 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33082 swig_globalvar *var = v->vars;
33083 while (var) {
33084 if (strcmp(var->name,n) == 0) {
33085 return (*var->get_attr)();
33086 }
33087 var = var->next;
33088 }
33089 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33090 return NULL;
33091 }
33092
33093 static int
33094 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33095 swig_globalvar *var = v->vars;
33096 while (var) {
33097 if (strcmp(var->name,n) == 0) {
33098 return (*var->set_attr)(p);
33099 }
33100 var = var->next;
33101 }
33102 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33103 return 1;
33104 }
33105
33106 static PyTypeObject varlinktype = {
33107 PyObject_HEAD_INIT(0)
33108 0, /* Number of items in variable part (ob_size) */
33109 (char *)"swigvarlink", /* Type name (tp_name) */
33110 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33111 0, /* Itemsize (tp_itemsize) */
33112 0, /* Deallocator (tp_dealloc) */
33113 (printfunc) swig_varlink_print, /* Print (tp_print) */
33114 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33115 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33116 0, /* tp_compare */
33117 (reprfunc) swig_varlink_repr, /* tp_repr */
33118 0, /* tp_as_number */
33119 0, /* tp_as_sequence */
33120 0, /* tp_as_mapping */
33121 0, /* tp_hash */
33122 0, /* tp_call */
33123 0, /* tp_str */
33124 0, /* tp_getattro */
33125 0, /* tp_setattro */
33126 0, /* tp_as_buffer */
33127 0, /* tp_flags */
33128 0, /* tp_doc */
33129 #if PY_VERSION_HEX >= 0x02000000
33130 0, /* tp_traverse */
33131 0, /* tp_clear */
33132 #endif
33133 #if PY_VERSION_HEX >= 0x02010000
33134 0, /* tp_richcompare */
33135 0, /* tp_weaklistoffset */
33136 #endif
33137 #if PY_VERSION_HEX >= 0x02020000
33138 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33139 #endif
33140 #if PY_VERSION_HEX >= 0x02030000
33141 0, /* tp_del */
33142 #endif
33143 #ifdef COUNT_ALLOCS
33144 0,0,0,0 /* tp_alloc -> tp_next */
33145 #endif
33146 };
33147
33148 /* Create a variable linking object for use later */
33149 static PyObject *
33150 SWIG_Python_newvarlink(void) {
33151 swig_varlinkobject *result = 0;
33152 result = PyMem_NEW(swig_varlinkobject,1);
33153 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33154 result->ob_type = &varlinktype;
33155 result->vars = 0;
33156 result->ob_refcnt = 0;
33157 Py_XINCREF((PyObject *) result);
33158 return ((PyObject*) result);
33159 }
33160
33161 static void
33162 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33163 swig_varlinkobject *v;
33164 swig_globalvar *gv;
33165 v= (swig_varlinkobject *) p;
33166 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33167 gv->name = (char *) malloc(strlen(name)+1);
33168 strcpy(gv->name,name);
33169 gv->get_attr = get_attr;
33170 gv->set_attr = set_attr;
33171 gv->next = v->vars;
33172 v->vars = gv;
33173 }
33174
33175 /* -----------------------------------------------------------------------------
33176 * constants/methods manipulation
33177 * ----------------------------------------------------------------------------- */
33178
33179 /* Install Constants */
33180 static void
33181 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33182 PyObject *obj = 0;
33183 size_t i;
33184 for (i = 0; constants[i].type; i++) {
33185 switch(constants[i].type) {
33186 case SWIG_PY_INT:
33187 obj = PyInt_FromLong(constants[i].lvalue);
33188 break;
33189 case SWIG_PY_FLOAT:
33190 obj = PyFloat_FromDouble(constants[i].dvalue);
33191 break;
33192 case SWIG_PY_STRING:
33193 if (constants[i].pvalue) {
33194 obj = PyString_FromString((char *) constants[i].pvalue);
33195 } else {
33196 Py_INCREF(Py_None);
33197 obj = Py_None;
33198 }
33199 break;
33200 case SWIG_PY_POINTER:
33201 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33202 break;
33203 case SWIG_PY_BINARY:
33204 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33205 break;
33206 default:
33207 obj = 0;
33208 break;
33209 }
33210 if (obj) {
33211 PyDict_SetItemString(d,constants[i].name,obj);
33212 Py_DECREF(obj);
33213 }
33214 }
33215 }
33216
33217 /* -----------------------------------------------------------------------------*/
33218 /* Fix SwigMethods to carry the callback ptrs when needed */
33219 /* -----------------------------------------------------------------------------*/
33220
33221 static void
33222 SWIG_Python_FixMethods(PyMethodDef *methods,
33223 swig_const_info *const_table,
33224 swig_type_info **types,
33225 swig_type_info **types_initial) {
33226 size_t i;
33227 for (i = 0; methods[i].ml_name; ++i) {
33228 char *c = methods[i].ml_doc;
33229 if (c && (c = strstr(c, "swig_ptr: "))) {
33230 int j;
33231 swig_const_info *ci = 0;
33232 char *name = c + 10;
33233 for (j = 0; const_table[j].type; j++) {
33234 if (strncmp(const_table[j].name, name,
33235 strlen(const_table[j].name)) == 0) {
33236 ci = &(const_table[j]);
33237 break;
33238 }
33239 }
33240 if (ci) {
33241 size_t shift = (ci->ptype) - types;
33242 swig_type_info *ty = types_initial[shift];
33243 size_t ldoc = (c - methods[i].ml_doc);
33244 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33245 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33246 char *buff = ndoc;
33247 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33248 strncpy(buff, methods[i].ml_doc, ldoc);
33249 buff += ldoc;
33250 strncpy(buff, "swig_ptr: ", 10);
33251 buff += 10;
33252 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33253 methods[i].ml_doc = ndoc;
33254 }
33255 }
33256 }
33257 }
33258
33259 /* -----------------------------------------------------------------------------*
33260 * Initialize type list
33261 * -----------------------------------------------------------------------------*/
33262
33263 #if PY_MAJOR_VERSION < 2
33264 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33265 is copied out of Python/modsupport.c in python version 2.3.4 */
33266 static int
33267 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33268 {
33269 PyObject *dict;
33270 if (!PyModule_Check(m)) {
33271 PyErr_SetString(PyExc_TypeError,
33272 "PyModule_AddObject() needs module as first arg");
33273 return -1;
33274 }
33275 if (!o) {
33276 PyErr_SetString(PyExc_TypeError,
33277 "PyModule_AddObject() needs non-NULL value");
33278 return -1;
33279 }
33280
33281 dict = PyModule_GetDict(m);
33282 if (dict == NULL) {
33283 /* Internal error -- modules must have a dict! */
33284 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33285 PyModule_GetName(m));
33286 return -1;
33287 }
33288 if (PyDict_SetItemString(dict, name, o))
33289 return -1;
33290 Py_DECREF(o);
33291 return 0;
33292 }
33293 #endif
33294
33295 static swig_type_info **
33296 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33297 static PyMethodDef swig_empty_runtime_method_table[] = {
33298 {
33299 NULL, NULL, 0, NULL
33300 }
33301 };/* Sentinel */
33302
33303 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33304 swig_empty_runtime_method_table);
33305 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33306 if (pointer && module) {
33307 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33308 }
33309 return type_list_handle;
33310 }
33311
33312 static swig_type_info **
33313 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33314 swig_type_info **type_pointer;
33315
33316 /* first check if module already created */
33317 type_pointer = SWIG_Python_GetTypeListHandle();
33318 if (type_pointer) {
33319 return type_pointer;
33320 } else {
33321 /* create a new module and variable */
33322 return SWIG_Python_SetTypeListHandle(type_list_handle);
33323 }
33324 }
33325
33326 #ifdef __cplusplus
33327 }
33328 #endif
33329
33330 /* -----------------------------------------------------------------------------*
33331 * Partial Init method
33332 * -----------------------------------------------------------------------------*/
33333
33334 #ifdef SWIG_LINK_RUNTIME
33335 #ifdef __cplusplus
33336 extern "C"
33337 #endif
33338 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33339 #endif
33340
33341 #ifdef __cplusplus
33342 extern "C"
33343 #endif
33344 SWIGEXPORT(void) SWIG_init(void) {
33345 static PyObject *SWIG_globals = 0;
33346 static int typeinit = 0;
33347 PyObject *m, *d;
33348 int i;
33349 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33350
33351 /* Fix SwigMethods to carry the callback ptrs when needed */
33352 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33353
33354 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33355 d = PyModule_GetDict(m);
33356
33357 if (!typeinit) {
33358 #ifdef SWIG_LINK_RUNTIME
33359 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33360 #else
33361 # ifndef SWIG_STATIC_RUNTIME
33362 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33363 # endif
33364 #endif
33365 for (i = 0; swig_types_initial[i]; i++) {
33366 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33367 }
33368 typeinit = 1;
33369 }
33370 SWIG_InstallConstants(d,swig_const_table);
33371
33372 {
33373 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33374 }
33375 {
33376 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33377 }
33378 {
33379 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33380 }
33381 {
33382 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33383 }
33384 {
33385 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33386 }
33387 {
33388 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33389 }
33390 {
33391 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33392 }
33393 {
33394 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33419 }
33420 {
33421 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33422 }
33423 {
33424 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33644 }
33645 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33646 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33647 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33648 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33649 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33650 {
33651 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33661 }
33662 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33663
33664 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33665
33666 {
33667 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33698 }
33699 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33700 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33701 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33702 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33703 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33704 {
33705 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33796 }
33797 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33798 {
33799 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33812 }
33813
33814 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33815
33816 {
33817 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33836 }
33837 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33838 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33839 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33840 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33841 {
33842 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33843 }
33844 {
33845 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33864 }
33865 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33866 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33867 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33868 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33869 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33870 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33871 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33872 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33873 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33874 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33875 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33876 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33877 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33878 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33879 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33880 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33881 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33882 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33883 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33884 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33885 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33886 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33887 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33888 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33889 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33890 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33891 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33892 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33893 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33894 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33895 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33896 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33897 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33898 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33899 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33900 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33901 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33902 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33903 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33904 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33905 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33906 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33907 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33908 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33909 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33910 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33911 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33912 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33913 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33914 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33915 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33916 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33917 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33918 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33919 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33920 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33921
33922 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33923
33924 {
33925 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33950 }
33951 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33952 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33953 {
33954 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33994 }
33995 {
33996 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33997 }
33998 {
33999 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34132 }
34133 {
34134 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34135 }
34136 {
34137 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34138 }
34139 {
34140 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34141 }
34142 {
34143 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34144 }
34145 {
34146 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34147 }
34148 {
34149 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34150 }
34151 {
34152 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34153 }
34154 {
34155 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34156 }
34157 {
34158 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34159 }
34160 {
34161 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34162 }
34163 {
34164 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34165 }
34166 {
34167 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34168 }
34169 {
34170 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34171 }
34172 {
34173 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34174 }
34175 {
34176 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34177 }
34178 {
34179 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34180 }
34181 {
34182 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34183 }
34184 {
34185 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34186 }
34187 {
34188 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34189 }
34190 {
34191 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34192 }
34193 {
34194 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34195 }
34196 {
34197 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34231 }
34232 {
34233 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34234 }
34235 {
34236 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34237 }
34238 {
34239 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34246 }
34247 {
34248 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34249 }
34250 {
34251 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34252 }
34253 {
34254 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34255 }
34256 {
34257 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34258 }
34259 {
34260 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34261 }
34262 {
34263 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34264 }
34265 {
34266 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34267 }
34268 {
34269 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34297 }
34298 {
34299 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34303 }
34304 {
34305 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34306 }
34307 {
34308 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34309 }
34310 {
34311 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34312 }
34313 {
34314 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34315 }
34316 {
34317 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34318 }
34319 {
34320 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34321 }
34322 {
34323 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34324 }
34325 {
34326 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34327 }
34328 {
34329 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34330 }
34331 {
34332 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34333 }
34334 {
34335 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34336 }
34337 {
34338 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34339 }
34340 {
34341 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34342 }
34343 {
34344 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34345 }
34346 {
34347 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34348 }
34349 {
34350 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34351 }
34352 {
34353 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34354 }
34355 {
34356 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34357 }
34358 {
34359 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34360 }
34361 {
34362 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34363 }
34364 {
34365 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34366 }
34367 {
34368 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34369 }
34370 {
34371 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34372 }
34373 {
34374 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34375 }
34376 {
34377 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34378 }
34379 {
34380 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34381 }
34382 {
34383 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34384 }
34385 {
34386 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34387 }
34388 {
34389 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34390 }
34391 {
34392 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34393 }
34394 {
34395 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34396 }
34397 {
34398 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34399 }
34400 {
34401 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34402 }
34403 {
34404 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34405 }
34406 {
34407 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34408 }
34409 {
34410 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34411 }
34412 {
34413 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34414 }
34415 {
34416 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34417 }
34418 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34419 {
34420 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34421 }
34422 {
34423 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34424 }
34425 {
34426 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34427 }
34428 {
34429 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34430 }
34431 {
34432 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34433 }
34434 {
34435 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34436 }
34437 {
34438 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34439 }
34440 {
34441 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34442 }
34443 {
34444 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34460 }
34461 {
34462 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34463 }
34464 {
34465 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34466 }
34467 {
34468 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34469 }
34470 {
34471 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34472 }
34473 {
34474 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34475 }
34476 {
34477 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34478 }
34479 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34480 {
34481 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34482 }
34483 {
34484 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34485 }
34486 {
34487 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34488 }
34489 {
34490 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34491 }
34492 {
34493 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34494 }
34495 {
34496 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34497 }
34498 {
34499 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34500 }
34501 {
34502 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34503 }
34504 {
34505 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34506 }
34507 {
34508 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34509 }
34510 {
34511 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34512 }
34513 {
34514 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34515 }
34516
34517 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34518 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34519 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34520 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34521
34522 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34523 }
34524
wxWidgets (Impactor)