]> 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
Get rid of wxFontMapper in wxBase library.
[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 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxDC swig_types[21]
1363 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1364 #define SWIGTYPE_p_wxIcon swig_types[23]
1365 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1366 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1369 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxSound swig_types[37]
1379 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1380 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1381 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1382 #define SWIGTYPE_p_wxArrayString swig_types[41]
1383 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxToolTip swig_types[44]
1386 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1387 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxFileConfig swig_types[47]
1389 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1390 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1393 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1394 #define SWIGTYPE_p_wxRect swig_types[53]
1395 #define SWIGTYPE_p_char swig_types[54]
1396 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1397 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1398 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1399 #define SWIGTYPE_p_wxFrame swig_types[58]
1400 #define SWIGTYPE_p_wxTimer swig_types[59]
1401 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1402 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1403 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1404 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxJoystick swig_types[65]
1407 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1408 #define SWIGTYPE_p_wxPoint swig_types[67]
1409 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1410 #define SWIGTYPE_p_wxCursor swig_types[69]
1411 #define SWIGTYPE_p_wxObject swig_types[70]
1412 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1413 #define SWIGTYPE_p_wxDateTime swig_types[72]
1414 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1415 #define SWIGTYPE_p_unsigned_long swig_types[74]
1416 #define SWIGTYPE_p_wxKillError swig_types[75]
1417 #define SWIGTYPE_p_wxWindow swig_types[76]
1418 #define SWIGTYPE_p_wxString swig_types[77]
1419 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1420 #define SWIGTYPE_p_wxBitmap swig_types[79]
1421 #define SWIGTYPE_p_wxConfig swig_types[80]
1422 #define SWIGTYPE_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_char swig_types[83]
1425 #define SWIGTYPE_p_wxChar swig_types[84]
1426 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1427 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPyLog swig_types[90]
1432 #define SWIGTYPE_p_wxLogNull swig_types[91]
1433 #define SWIGTYPE_p_wxColour swig_types[92]
1434 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1435 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1436 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443 @(target):= _misc_.so
1444 ------------------------------------------------*/
1445 #define SWIG_init init_misc_
1446
1447 #define SWIG_name "_misc_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451 #include "wx/wxPython/pyistream.h"
1452
1453 static const wxString wxPyEmptyString(wxEmptyString);
1454
1455
1456
1457 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1458 #define SWIG_From_int PyInt_FromLong
1459 /*@@*/
1460
1461
1462 #include <limits.h>
1463
1464
1465 SWIGINTERN int
1466 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1467 const char *errmsg)
1468 {
1469 if (value < min_value) {
1470 if (errmsg) {
1471 PyErr_Format(PyExc_OverflowError,
1472 "value %ld is less than '%s' minimum %ld",
1473 value, errmsg, min_value);
1474 }
1475 return 0;
1476 } else if (value > max_value) {
1477 if (errmsg) {
1478 PyErr_Format(PyExc_OverflowError,
1479 "value %ld is greater than '%s' maximum %ld",
1480 value, errmsg, max_value);
1481 }
1482 return 0;
1483 }
1484 return 1;
1485 }
1486
1487
1488 SWIGINTERN int
1489 SWIG_AsVal_long(PyObject* obj, long* val)
1490 {
1491 if (PyNumber_Check(obj)) {
1492 if (val) *val = PyInt_AsLong(obj);
1493 return 1;
1494 }
1495 else {
1496 SWIG_type_error("number", obj);
1497 }
1498 return 0;
1499 }
1500
1501
1502 #if INT_MAX != LONG_MAX
1503 SWIGINTERN int
1504 SWIG_AsVal_int(PyObject *obj, int *val)
1505 {
1506 const char* errmsg = val ? "int" : (char*)0;
1507 long v;
1508 if (SWIG_AsVal_long(obj, &v)) {
1509 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1510 if (val) *val = (int)(v);
1511 return 1;
1512 } else {
1513 return 0;
1514 }
1515 } else {
1516 PyErr_Clear();
1517 }
1518 if (val) {
1519 SWIG_type_error(errmsg, obj);
1520 }
1521 return 0;
1522 }
1523 #else
1524 SWIGINTERNSHORT int
1525 SWIG_AsVal_int(PyObject *obj, int *val)
1526 {
1527 return SWIG_AsVal_long(obj,(long*)val);
1528 }
1529 #endif
1530
1531
1532 SWIGINTERNSHORT int
1533 SWIG_As_int(PyObject* obj)
1534 {
1535 int v;
1536 if (!SWIG_AsVal_int(obj, &v)) {
1537 /*
1538 this is needed to make valgrind/purify happier.
1539 */
1540 memset((void*)&v, 0, sizeof(int));
1541 }
1542 return v;
1543 }
1544
1545
1546 SWIGINTERNSHORT int
1547 SWIG_Check_int(PyObject* obj)
1548 {
1549 return SWIG_AsVal_int(obj, (int*)0);
1550 }
1551
1552 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1553
1554 #include <wx/stockitem.h>
1555
1556 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1557 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1558 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1559
1560 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1561 #define SWIG_From_long PyInt_FromLong
1562 /*@@*/
1563
1564
1565 SWIGINTERNSHORT long
1566 SWIG_As_long(PyObject* obj)
1567 {
1568 long v;
1569 if (!SWIG_AsVal_long(obj, &v)) {
1570 /*
1571 this is needed to make valgrind/purify happier.
1572 */
1573 memset((void*)&v, 0, sizeof(long));
1574 }
1575 return v;
1576 }
1577
1578
1579 SWIGINTERNSHORT int
1580 SWIG_Check_long(PyObject* obj)
1581 {
1582 return SWIG_AsVal_long(obj, (long*)0);
1583 }
1584
1585
1586 SWIGINTERN int
1587 SWIG_AsVal_bool(PyObject *obj, bool *val)
1588 {
1589 if (obj == Py_True) {
1590 if (val) *val = true;
1591 return 1;
1592 }
1593 if (obj == Py_False) {
1594 if (val) *val = false;
1595 return 1;
1596 }
1597 int res = 0;
1598 if (SWIG_AsVal_int(obj, &res)) {
1599 if (val) *val = res ? true : false;
1600 return 1;
1601 } else {
1602 PyErr_Clear();
1603 }
1604 if (val) {
1605 SWIG_type_error("bool", obj);
1606 }
1607 return 0;
1608 }
1609
1610
1611 SWIGINTERNSHORT bool
1612 SWIG_As_bool(PyObject* obj)
1613 {
1614 bool v;
1615 if (!SWIG_AsVal_bool(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(bool));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_bool(PyObject* obj)
1627 {
1628 return SWIG_AsVal_bool(obj, (bool*)0);
1629 }
1630
1631
1632 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1633 PyObject* o2;
1634 PyObject* o3;
1635
1636 if (!target) {
1637 target = o;
1638 } else if (target == Py_None) {
1639 Py_DECREF(Py_None);
1640 target = o;
1641 } else {
1642 if (!PyTuple_Check(target)) {
1643 o2 = target;
1644 target = PyTuple_New(1);
1645 PyTuple_SetItem(target, 0, o2);
1646 }
1647 o3 = PyTuple_New(1);
1648 PyTuple_SetItem(o3, 0, o);
1649
1650 o2 = target;
1651 target = PySequence_Concat(o2, o3);
1652 Py_DECREF(o2);
1653 Py_DECREF(o3);
1654 }
1655 return target;
1656 }
1657
1658
1659
1660 long wxGetFreeMemory()
1661 { wxPyRaiseNotImplemented(); return 0; }
1662
1663
1664 SWIGINTERN int
1665 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1666 {
1667 long v = 0;
1668 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1669 SWIG_type_error("unsigned number", obj);
1670 }
1671 else if (val)
1672 *val = (unsigned long)v;
1673 return 1;
1674 }
1675
1676
1677 SWIGINTERNSHORT unsigned long
1678 SWIG_As_unsigned_SS_long(PyObject* obj)
1679 {
1680 unsigned long v;
1681 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1682 /*
1683 this is needed to make valgrind/purify happier.
1684 */
1685 memset((void*)&v, 0, sizeof(unsigned long));
1686 }
1687 return v;
1688 }
1689
1690
1691 SWIGINTERNSHORT int
1692 SWIG_Check_unsigned_SS_long(PyObject* obj)
1693 {
1694 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1695 }
1696
1697
1698 SWIGINTERNSHORT PyObject*
1699 SWIG_From_unsigned_SS_long(unsigned long value)
1700 {
1701 return (value > LONG_MAX) ?
1702 PyLong_FromUnsignedLong(value)
1703 : PyInt_FromLong((long)(value));
1704 }
1705
1706
1707 void wxWakeUpMainThread() {}
1708
1709
1710 bool wxThread_IsMain() {
1711 #ifdef WXP_WITH_THREAD
1712 return wxThread::IsMain();
1713 #else
1714 return true;
1715 #endif
1716 }
1717
1718 static void wxCaret_Destroy(wxCaret *self){
1719 delete self;
1720 }
1721
1722 #include <wx/snglinst.h>
1723
1724
1725 #ifdef __WXMSW__
1726 #include <wx/msw/private.h>
1727 #include <wx/dynload.h>
1728 #endif
1729
1730
1731
1732 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1733 #if 0
1734 , int method
1735 #endif
1736 )
1737 {
1738 #ifdef __WXMSW__
1739 #if 0
1740 switch (method)
1741 {
1742 case 1:
1743 // This one only partially works. Appears to be an undocumented
1744 // "standard" convention that not all widgets adhear to. For
1745 // example, for some widgets backgrounds or non-client areas may
1746 // not be painted.
1747 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1748 break;
1749
1750 case 2:
1751 #endif
1752 // This one works much better, nearly all widgets and their
1753 // children are captured correctly[**]. Prior to the big
1754 // background erase changes that Vadim did in 2004-2005 this
1755 // method failed badly on XP with Themes activated, most native
1756 // widgets draw only partially, if at all. Without themes it
1757 // worked just like on Win2k. After those changes this method
1758 // works very well.
1759 //
1760 // ** For example the radio buttons in a wxRadioBox are not its
1761 // children by default, but you can capture it via the panel
1762 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1763 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1764 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1765 PRF_ERASEBKGND | PRF_OWNED );
1766 return true;
1767 #if 0
1768 break;
1769
1770 case 3:
1771 // This one is only defined in the latest SDK and is only
1772 // available on XP. MSDN says it is similar to sending WM_PRINT
1773 // so I expect that it will work similar to the above. Since it
1774 // is avaialble only on XP, it can't be compiled like this and
1775 // will have to be loaded dynamically.
1776 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1777
1778 // fall through
1779
1780 case 4:
1781 // Use PrintWindow if available, or fallback to WM_PRINT
1782 // otherwise. Unfortunately using PrintWindow is even worse than
1783 // WM_PRINT. For most native widgets nothing is drawn to the dc
1784 // at all, with or without Themes.
1785 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1786 static bool s_triedToLoad = false;
1787 static PrintWindow_t pfnPrintWindow = NULL;
1788 if ( !s_triedToLoad )
1789 {
1790
1791 s_triedToLoad = true;
1792 wxDynamicLibrary dllUser32(_T("user32.dll"));
1793 if ( dllUser32.IsLoaded() )
1794 {
1795 wxLogNull nolog; // Don't report errors here
1796 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1797 }
1798 }
1799 if (pfnPrintWindow)
1800 {
1801 //printf("Using PrintWindow\n");
1802 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1803 }
1804 else
1805 {
1806 //printf("Using WM_PRINT\n");
1807 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1808 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1809 PRF_ERASEBKGND | PRF_OWNED );
1810 }
1811 }
1812 #endif // 0
1813 #else
1814 return false;
1815 #endif // __WXMSW__
1816 }
1817
1818
1819
1820 #include <wx/tipdlg.h>
1821
1822
1823 class wxPyTipProvider : public wxTipProvider {
1824 public:
1825 wxPyTipProvider(size_t currentTip)
1826 : wxTipProvider(currentTip) {}
1827
1828 DEC_PYCALLBACK_STRING__pure(GetTip);
1829 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1830 PYPRIVATE;
1831 };
1832
1833 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1834 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1835
1836
1837 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1838
1839 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1840
1841 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1842 : wxTimer(owner, id)
1843 {
1844 if (owner == NULL) SetOwner(this);
1845 }
1846
1847
1848 void wxPyTimer::Notify() {
1849 bool found;
1850 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1851 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1852 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1853 wxPyEndBlockThreads(blocked);
1854 if (! found)
1855 wxTimer::Notify();
1856 }
1857 void wxPyTimer::base_Notify() {
1858 wxTimer::Notify();
1859 }
1860
1861
1862
1863 SWIGINTERN PyObject *
1864 SWIG_FromCharPtr(const char* cptr)
1865 {
1866 if (cptr) {
1867 size_t size = strlen(cptr);
1868 if (size > INT_MAX) {
1869 return SWIG_NewPointerObj((char*)(cptr),
1870 SWIG_TypeQuery("char *"), 0);
1871 } else {
1872 if (size != 0) {
1873 return PyString_FromStringAndSize(cptr, size);
1874 } else {
1875 return PyString_FromString(cptr);
1876 }
1877 }
1878 }
1879 Py_INCREF(Py_None);
1880 return Py_None;
1881 }
1882
1883
1884 SWIGINTERNSHORT int
1885 SWIG_CheckUnsignedLongInRange(unsigned long value,
1886 unsigned long max_value,
1887 const char *errmsg)
1888 {
1889 if (value > max_value) {
1890 if (errmsg) {
1891 PyErr_Format(PyExc_OverflowError,
1892 "value %lu is greater than '%s' minimum %lu",
1893 value, errmsg, max_value);
1894 }
1895 return 0;
1896 }
1897 return 1;
1898 }
1899
1900
1901 #if UINT_MAX != ULONG_MAX
1902 SWIGINTERN int
1903 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1904 {
1905 const char* errmsg = val ? "unsigned int" : (char*)0;
1906 unsigned long v;
1907 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1908 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1909 if (val) *val = (unsigned int)(v);
1910 return 1;
1911 }
1912 } else {
1913 PyErr_Clear();
1914 }
1915 if (val) {
1916 SWIG_type_error(errmsg, obj);
1917 }
1918 return 0;
1919 }
1920 #else
1921 SWIGINTERNSHORT unsigned int
1922 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1923 {
1924 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1925 }
1926 #endif
1927
1928
1929 SWIGINTERNSHORT unsigned int
1930 SWIG_As_unsigned_SS_int(PyObject* obj)
1931 {
1932 unsigned int v;
1933 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1934 /*
1935 this is needed to make valgrind/purify happier.
1936 */
1937 memset((void*)&v, 0, sizeof(unsigned int));
1938 }
1939 return v;
1940 }
1941
1942
1943 SWIGINTERNSHORT int
1944 SWIG_Check_unsigned_SS_int(PyObject* obj)
1945 {
1946 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1947 }
1948
1949 static wxString Log_TimeStamp(){
1950 wxString msg;
1951 wxLog::TimeStamp(&msg);
1952 return msg;
1953 }
1954 static void wxLog_Destroy(wxLog *self){ delete self; }
1955 // Make somce wrappers that double any % signs so they are 'escaped'
1956 void wxPyLogFatalError(const wxString& msg)
1957 {
1958 wxString m(msg);
1959 m.Replace(wxT("%"), wxT("%%"));
1960 wxLogFatalError(m);
1961 }
1962
1963 void wxPyLogError(const wxString& msg)
1964 {
1965 wxString m(msg);
1966 m.Replace(wxT("%"), wxT("%%"));
1967 wxLogError(m);
1968 }
1969
1970 void wxPyLogWarning(const wxString& msg)
1971 {
1972 wxString m(msg);
1973 m.Replace(wxT("%"), wxT("%%"));
1974 wxLogWarning(m);
1975 }
1976
1977 void wxPyLogMessage(const wxString& msg)
1978 {
1979 wxString m(msg);
1980 m.Replace(wxT("%"), wxT("%%"));
1981 wxLogMessage(m);
1982 }
1983
1984 void wxPyLogInfo(const wxString& msg)
1985 {
1986 wxString m(msg);
1987 m.Replace(wxT("%"), wxT("%%"));
1988 wxLogInfo(m);
1989 }
1990
1991 void wxPyLogDebug(const wxString& msg)
1992 {
1993 wxString m(msg);
1994 m.Replace(wxT("%"), wxT("%%"));
1995 wxLogDebug(m);
1996 }
1997
1998 void wxPyLogVerbose(const wxString& msg)
1999 {
2000 wxString m(msg);
2001 m.Replace(wxT("%"), wxT("%%"));
2002 wxLogVerbose(m);
2003 }
2004
2005 void wxPyLogStatus(const wxString& msg)
2006 {
2007 wxString m(msg);
2008 m.Replace(wxT("%"), wxT("%%"));
2009 wxLogStatus(m);
2010 }
2011
2012 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2013 {
2014 wxString m(msg);
2015 m.Replace(wxT("%"), wxT("%%"));
2016 wxLogStatus(pFrame, m);
2017 }
2018
2019 void wxPyLogSysError(const wxString& msg)
2020 {
2021 wxString m(msg);
2022 m.Replace(wxT("%"), wxT("%%"));
2023 wxLogSysError(m);
2024 }
2025
2026 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2027 {
2028 wxString m(msg);
2029 m.Replace(wxT("%"), wxT("%%"));
2030 wxLogGeneric(level, m);
2031 }
2032
2033 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2034 {
2035 wxString m(msg);
2036 m.Replace(wxT("%"), wxT("%%"));
2037 wxLogTrace(mask, m);
2038 }
2039
2040 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2041 {
2042 wxString m(msg);
2043 m.Replace(wxT("%"), wxT("%%"));
2044 wxLogTrace(mask, m);
2045 }
2046
2047
2048
2049 // A wxLog class that can be derived from in wxPython
2050 class wxPyLog : public wxLog {
2051 public:
2052 wxPyLog() : wxLog() {}
2053
2054 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2055 bool found;
2056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2057 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2058 PyObject* s = wx2PyString(szString);
2059 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2060 Py_DECREF(s);
2061 }
2062 wxPyEndBlockThreads(blocked);
2063 if (! found)
2064 wxLog::DoLog(level, szString, t);
2065 }
2066
2067 virtual void DoLogString(const wxChar *szString, time_t t) {
2068 bool found;
2069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2070 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2071 PyObject* s = wx2PyString(szString);
2072 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2073 Py_DECREF(s);
2074 }
2075 wxPyEndBlockThreads(blocked);
2076 if (! found)
2077 wxLog::DoLogString(szString, t);
2078 }
2079
2080 PYPRIVATE;
2081 };
2082
2083
2084
2085
2086 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2087
2088
2089 #include <wx/joystick.h>
2090
2091
2092 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2093 // A C++ stub class for wxJoystick for platforms that don't have it.
2094 class wxJoystick : public wxObject {
2095 public:
2096 wxJoystick(int joystick = wxJOYSTICK1) {
2097 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2098 PyErr_SetString(PyExc_NotImplementedError,
2099 "wxJoystick is not available on this platform.");
2100 wxPyEndBlockThreads(blocked);
2101 }
2102 wxPoint GetPosition() { return wxPoint(-1,-1); }
2103 int GetZPosition() { return -1; }
2104 int GetButtonState() { return -1; }
2105 int GetPOVPosition() { return -1; }
2106 int GetPOVCTSPosition() { return -1; }
2107 int GetRudderPosition() { return -1; }
2108 int GetUPosition() { return -1; }
2109 int GetVPosition() { return -1; }
2110 int GetMovementThreshold() { return -1; }
2111 void SetMovementThreshold(int threshold) {}
2112
2113 bool IsOk(void) { return false; }
2114 int GetNumberJoysticks() { return -1; }
2115 int GetManufacturerId() { return -1; }
2116 int GetProductId() { return -1; }
2117 wxString GetProductName() { return wxEmptyString; }
2118 int GetXMin() { return -1; }
2119 int GetYMin() { return -1; }
2120 int GetZMin() { return -1; }
2121 int GetXMax() { return -1; }
2122 int GetYMax() { return -1; }
2123 int GetZMax() { return -1; }
2124 int GetNumberButtons() { return -1; }
2125 int GetNumberAxes() { return -1; }
2126 int GetMaxButtons() { return -1; }
2127 int GetMaxAxes() { return -1; }
2128 int GetPollingMin() { return -1; }
2129 int GetPollingMax() { return -1; }
2130 int GetRudderMin() { return -1; }
2131 int GetRudderMax() { return -1; }
2132 int GetUMin() { return -1; }
2133 int GetUMax() { return -1; }
2134 int GetVMin() { return -1; }
2135 int GetVMax() { return -1; }
2136
2137 bool HasRudder() { return false; }
2138 bool HasZ() { return false; }
2139 bool HasU() { return false; }
2140 bool HasV() { return false; }
2141 bool HasPOV() { return false; }
2142 bool HasPOV4Dir() { return false; }
2143 bool HasPOVCTS() { return false; }
2144
2145 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2146 bool ReleaseCapture() { return false; }
2147 };
2148 #endif
2149
2150
2151 #include <wx/sound.h>
2152
2153
2154 #if !wxUSE_SOUND
2155 // A C++ stub class for wxWave for platforms that don't have it.
2156 class wxSound : public wxObject
2157 {
2158 public:
2159 wxSound() {
2160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(const wxString&/*, bool*/) {
2166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171 wxSound(int, const wxByte*) {
2172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177
2178 ~wxSound() {};
2179
2180 bool Create(const wxString&/*, bool*/) { return false; }
2181 bool Create(int, const wxByte*) { return false; };
2182 bool IsOk() { return false; };
2183 bool Play(unsigned) const { return false; }
2184 static bool Play(const wxString&, unsigned) { return false; }
2185 static void Stop() {}
2186 };
2187
2188 #endif
2189
2190 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2191 if (fileName.Length() == 0)
2192 return new wxSound;
2193 else
2194 return new wxSound(fileName);
2195 }
2196 static wxSound *new_wxSound(PyObject *data){
2197 unsigned char* buffer; int size;
2198 wxSound *sound = NULL;
2199
2200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2201 if (!PyArg_Parse(data, "t#", &buffer, &size))
2202 goto done;
2203 sound = new wxSound(size, buffer);
2204 done:
2205 wxPyEndBlockThreads(blocked);
2206 return sound;
2207 }
2208 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2209 #ifndef __WXMAC__
2210 unsigned char* buffer;
2211 int size;
2212 bool rv = false;
2213
2214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2215 if (!PyArg_Parse(data, "t#", &buffer, &size))
2216 goto done;
2217 rv = self->Create(size, buffer);
2218 done:
2219 wxPyEndBlockThreads(blocked);
2220 return rv;
2221 #else
2222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2223 PyErr_SetString(PyExc_NotImplementedError,
2224 "Create from data is not available on this platform.");
2225 wxPyEndBlockThreads(blocked);
2226 return false;
2227 #endif
2228 }
2229
2230 #include <wx/mimetype.h>
2231
2232 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2233 wxString str;
2234 if (self->GetMimeType(&str))
2235 return wx2PyString(str);
2236 else
2237 RETURN_NONE();
2238 }
2239 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2240 wxArrayString arr;
2241 if (self->GetMimeTypes(arr))
2242 return wxArrayString2PyList_helper(arr);
2243 else
2244 RETURN_NONE();
2245 }
2246 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2247 wxArrayString arr;
2248 if (self->GetExtensions(arr))
2249 return wxArrayString2PyList_helper(arr);
2250 else
2251 RETURN_NONE();
2252 }
2253 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2254 wxIconLocation loc;
2255 if (self->GetIcon(&loc))
2256 return new wxIcon(loc);
2257 else
2258 return NULL;
2259 }
2260 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2261 wxIconLocation loc;
2262 if (self->GetIcon(&loc)) {
2263 wxString iconFile = loc.GetFileName();
2264 int iconIndex = -1;
2265
2266
2267
2268 // Make a tuple and put the values in it
2269 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2270 PyObject* tuple = PyTuple_New(3);
2271 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2272 wxT("wxIcon"), true));
2273 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2274 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2275 wxPyEndBlockThreads(blocked);
2276 return tuple;
2277 }
2278 else
2279 RETURN_NONE();
2280 }
2281 static PyObject *wxFileType_GetDescription(wxFileType *self){
2282 wxString str;
2283 if (self->GetDescription(&str))
2284 return wx2PyString(str);
2285 else
2286 RETURN_NONE();
2287 }
2288 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2289 wxString str;
2290 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2291 return wx2PyString(str);
2292 else
2293 RETURN_NONE();
2294 }
2295 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2296 wxString str;
2297 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2298 return wx2PyString(str);
2299 else
2300 RETURN_NONE();
2301 }
2302 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2303 wxArrayString verbs;
2304 wxArrayString commands;
2305 if (self->GetAllCommands(&verbs, &commands,
2306 wxFileType::MessageParameters(filename, mimetype))) {
2307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2308 PyObject* tuple = PyTuple_New(2);
2309 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2310 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2311 wxPyEndBlockThreads(blocked);
2312 return tuple;
2313 }
2314 else
2315 RETURN_NONE();
2316 }
2317 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2318 return wxFileType::ExpandCommand(command,
2319 wxFileType::MessageParameters(filename, mimetype));
2320 }
2321 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2322 wxArrayString arr;
2323 self->EnumAllFileTypes(arr);
2324 return wxArrayString2PyList_helper(arr);
2325 }
2326
2327 #include <wx/artprov.h>
2328
2329 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2330 static const wxString wxPyART_MENU(wxART_MENU);
2331 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2332 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2333 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2334 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2335 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2336 static const wxString wxPyART_OTHER(wxART_OTHER);
2337 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2338 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2339 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2340 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2341 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2342 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2343 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2344 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2345 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2346 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2347 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2348 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2349 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2350 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2351 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2352 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2353 static const wxString wxPyART_PRINT(wxART_PRINT);
2354 static const wxString wxPyART_HELP(wxART_HELP);
2355 static const wxString wxPyART_TIP(wxART_TIP);
2356 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2357 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2358 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2359 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2360 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2361 static const wxString wxPyART_CDROM(wxART_CDROM);
2362 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2363 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2364 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2365 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2366 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2367 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2368 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2369 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2370 static const wxString wxPyART_ERROR(wxART_ERROR);
2371 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2372 static const wxString wxPyART_WARNING(wxART_WARNING);
2373 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2374 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2375 static const wxString wxPyART_COPY(wxART_COPY);
2376 static const wxString wxPyART_CUT(wxART_CUT);
2377 static const wxString wxPyART_PASTE(wxART_PASTE);
2378 static const wxString wxPyART_DELETE(wxART_DELETE);
2379 static const wxString wxPyART_UNDO(wxART_UNDO);
2380 static const wxString wxPyART_REDO(wxART_REDO);
2381 static const wxString wxPyART_QUIT(wxART_QUIT);
2382 static const wxString wxPyART_FIND(wxART_FIND);
2383 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2384 // Python aware wxArtProvider
2385 class wxPyArtProvider : public wxArtProvider {
2386 public:
2387
2388 virtual wxBitmap CreateBitmap(const wxArtID& id,
2389 const wxArtClient& client,
2390 const wxSize& size) {
2391 wxBitmap rval = wxNullBitmap;
2392 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2393 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2394 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2395 PyObject* ro;
2396 wxBitmap* ptr;
2397 PyObject* s1, *s2;
2398 s1 = wx2PyString(id);
2399 s2 = wx2PyString(client);
2400 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2401 Py_DECREF(so);
2402 Py_DECREF(s1);
2403 Py_DECREF(s2);
2404 if (ro) {
2405 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2406 rval = *ptr;
2407 Py_DECREF(ro);
2408 }
2409 }
2410 wxPyEndBlockThreads(blocked);
2411 return rval;
2412 }
2413
2414 PYPRIVATE;
2415 };
2416
2417 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2418
2419
2420
2421 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2422 PyObject* ret = PyTuple_New(3);
2423 if (ret) {
2424 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2425 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2426 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2427 }
2428 return ret;
2429 }
2430
2431 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2432 bool cont;
2433 long index = 0;
2434 wxString value;
2435
2436 cont = self->GetFirstGroup(value, index);
2437 return __EnumerationHelper(cont, value, index);
2438 }
2439 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2440 bool cont;
2441 wxString value;
2442
2443 cont = self->GetNextGroup(value, index);
2444 return __EnumerationHelper(cont, value, index);
2445 }
2446 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2447 bool cont;
2448 long index = 0;
2449 wxString value;
2450
2451 cont = self->GetFirstEntry(value, index);
2452 return __EnumerationHelper(cont, value, index);
2453 }
2454 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2455 bool cont;
2456 wxString value;
2457
2458 cont = self->GetNextEntry(value, index);
2459 return __EnumerationHelper(cont, value, index);
2460 }
2461 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2462 long rv;
2463 self->Read(key, &rv, defaultVal);
2464 return rv;
2465 }
2466
2467 SWIGINTERN int
2468 SWIG_AsVal_double(PyObject *obj, double* val)
2469 {
2470 if (PyNumber_Check(obj)) {
2471 if (val) *val = PyFloat_AsDouble(obj);
2472 return 1;
2473 }
2474 else {
2475 SWIG_type_error("number", obj);
2476 }
2477 return 0;
2478 }
2479
2480
2481 SWIGINTERNSHORT double
2482 SWIG_As_double(PyObject* obj)
2483 {
2484 double v;
2485 if (!SWIG_AsVal_double(obj, &v)) {
2486 /*
2487 this is needed to make valgrind/purify happier.
2488 */
2489 memset((void*)&v, 0, sizeof(double));
2490 }
2491 return v;
2492 }
2493
2494
2495 SWIGINTERNSHORT int
2496 SWIG_Check_double(PyObject* obj)
2497 {
2498 return SWIG_AsVal_double(obj, (double*)0);
2499 }
2500
2501 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2502 double rv;
2503 self->Read(key, &rv, defaultVal);
2504 return rv;
2505 }
2506
2507 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2508 #define SWIG_From_double PyFloat_FromDouble
2509 /*@@*/
2510
2511 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2512 bool rv;
2513 self->Read(key, &rv, defaultVal);
2514 return rv;
2515 }
2516
2517 #include <wx/datetime.h>
2518
2519 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2520 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2521
2522 #define LOCAL_TZ wxDateTime::Local
2523
2524 static PyObject *DateTime_GetAmPmStrings(){
2525 wxString am;
2526 wxString pm;
2527 wxDateTime::GetAmPmStrings(&am, &pm);
2528 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2529 PyObject* tup = PyTuple_New(2);
2530 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2531 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2532 wxPyEndBlockThreads(blocked);
2533 return tup;
2534 }
2535
2536 #if UINT_MAX < LONG_MAX
2537 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2538 #define SWIG_From_unsigned_SS_int SWIG_From_long
2539 /*@@*/
2540 #else
2541 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2542 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2543 /*@@*/
2544 #endif
2545
2546 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2547 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2548 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2549 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2550 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2551 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2552 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2553 return (*self < *other);
2554 }
2555 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2556 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2557 return (*self <= *other);
2558 }
2559 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2560 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2561 return (*self > *other);
2562 }
2563 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2564 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2565 return (*self >= *other);
2566 }
2567 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2568 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2569 return (*self == *other);
2570 }
2571 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2572 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2573 return (*self != *other);
2574 }
2575 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2576 const wxChar* rv;
2577 const wxChar* _date = date;
2578 rv = self->ParseRfc822Date(_date);
2579 if (rv == NULL) return -1;
2580 return rv - _date;
2581 }
2582 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2583 const wxChar* rv;
2584 const wxChar* _date = date;
2585 rv = self->ParseFormat(_date, format, dateDef);
2586 if (rv == NULL) return -1;
2587 return rv - _date;
2588 }
2589 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2590 const wxChar* rv;
2591 const wxChar* _datetime = datetime;
2592 rv = self->ParseDateTime(_datetime);
2593 if (rv == NULL) return -1;
2594 return rv - _datetime;
2595 }
2596 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2597 const wxChar* rv;
2598 const wxChar* _date = date;
2599 rv = self->ParseDate(_date);
2600 if (rv == NULL) return -1;
2601 return rv - _date;
2602 }
2603 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2604 const wxChar* rv;
2605 const wxChar* _time = time;
2606 rv = self->ParseTime(_time);
2607 if (rv == NULL) return -1;
2608 return rv - _time;
2609 }
2610 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2611 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2612 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2613 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2614 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2615 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2616 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2617 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2618 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2620 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2621 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2622 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2623 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2624 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2625 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2626
2627 #include <wx/dataobj.h>
2628
2629 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2630 size_t count = self->GetFormatCount(dir);
2631 wxDataFormat* formats = new wxDataFormat[count];
2632 self->GetAllFormats(formats, dir);
2633
2634 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2635 PyObject* list = PyList_New(count);
2636 for (size_t i=0; i<count; i++) {
2637 wxDataFormat* format = new wxDataFormat(formats[i]);
2638 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2639 PyList_Append(list, obj);
2640 Py_DECREF(obj);
2641 }
2642 wxPyEndBlockThreads(blocked);
2643 delete [] formats;
2644 return list;
2645 }
2646 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2647 PyObject* rval = NULL;
2648 size_t size = self->GetDataSize(format);
2649 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2650 if (size) {
2651 char* buf = new char[size];
2652 if (self->GetDataHere(format, buf))
2653 rval = PyString_FromStringAndSize(buf, size);
2654 delete [] buf;
2655 }
2656 if (! rval) {
2657 rval = Py_None;
2658 Py_INCREF(rval);
2659 }
2660 wxPyEndBlockThreads(blocked);
2661 return rval;
2662 }
2663 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2664 bool rval;
2665 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2666 if (PyString_Check(data)) {
2667 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2668 }
2669 else {
2670 // raise a TypeError if not a string
2671 PyErr_SetString(PyExc_TypeError, "String expected.");
2672 rval = false;
2673 }
2674 wxPyEndBlockThreads(blocked);
2675 return rval;
2676 }
2677 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2678 PyObject* rval = NULL;
2679 size_t size = self->GetDataSize();
2680 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2681 if (size) {
2682 char* buf = new char[size];
2683 if (self->GetDataHere(buf))
2684 rval = PyString_FromStringAndSize(buf, size);
2685 delete [] buf;
2686 }
2687 if (! rval) {
2688 rval = Py_None;
2689 Py_INCREF(rval);
2690 }
2691 wxPyEndBlockThreads(blocked);
2692 return rval;
2693 }
2694 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2695 bool rval;
2696 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2697 if (PyString_Check(data)) {
2698 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2699 }
2700 else {
2701 // raise a TypeError if not a string
2702 PyErr_SetString(PyExc_TypeError, "String expected.");
2703 rval = false;
2704 }
2705 wxPyEndBlockThreads(blocked);
2706 return rval;
2707 }
2708 // Create a new class for wxPython to use
2709 class wxPyDataObjectSimple : public wxDataObjectSimple {
2710 public:
2711 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2712 : wxDataObjectSimple(format) {}
2713
2714 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2715 bool GetDataHere(void *buf) const;
2716 bool SetData(size_t len, const void *buf) const;
2717 PYPRIVATE;
2718 };
2719
2720 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2721
2722 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2723 // We need to get the data for this object and write it to buf. I think
2724 // the best way to do this for wxPython is to have the Python method
2725 // return either a string or None and then act appropriately with the
2726 // C++ version.
2727
2728 bool rval = false;
2729 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2730 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2731 PyObject* ro;
2732 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2733 if (ro) {
2734 rval = (ro != Py_None && PyString_Check(ro));
2735 if (rval)
2736 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2737 Py_DECREF(ro);
2738 }
2739 }
2740 wxPyEndBlockThreads(blocked);
2741 return rval;
2742 }
2743
2744 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2745 // For this one we simply need to make a string from buf and len
2746 // and send it to the Python method.
2747 bool rval = false;
2748 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2749 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2750 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2751 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2752 Py_DECREF(data);
2753 }
2754 wxPyEndBlockThreads(blocked);
2755 return rval;
2756 }
2757
2758 // Create a new class for wxPython to use
2759 class wxPyTextDataObject : public wxTextDataObject {
2760 public:
2761 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2762 : wxTextDataObject(text) {}
2763
2764 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2765 DEC_PYCALLBACK_STRING__const(GetText);
2766 DEC_PYCALLBACK__STRING(SetText);
2767 PYPRIVATE;
2768 };
2769
2770 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2771 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2772 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2773
2774
2775 // Create a new class for wxPython to use
2776 class wxPyBitmapDataObject : public wxBitmapDataObject {
2777 public:
2778 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2779 : wxBitmapDataObject(bitmap) {}
2780
2781 wxBitmap GetBitmap() const;
2782 void SetBitmap(const wxBitmap& bitmap);
2783 PYPRIVATE;
2784 };
2785
2786 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2787 wxBitmap* rval = &wxNullBitmap;
2788 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2789 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2790 PyObject* ro;
2791 wxBitmap* ptr;
2792 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2793 if (ro) {
2794 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2795 rval = ptr;
2796 Py_DECREF(ro);
2797 }
2798 }
2799 wxPyEndBlockThreads(blocked);
2800 return *rval;
2801 }
2802
2803 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2804 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2805 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2806 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2807 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2808 Py_DECREF(bo);
2809 }
2810 wxPyEndBlockThreads(blocked);
2811 }
2812
2813 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2814 return new wxCustomDataObject(wxDataFormat(formatName));
2815 }
2816 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2817 bool rval;
2818 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2819 if (PyString_Check(data)) {
2820 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2821 }
2822 else {
2823 // raise a TypeError if not a string
2824 PyErr_SetString(PyExc_TypeError, "String expected.");
2825 rval = false;
2826 }
2827 wxPyEndBlockThreads(blocked);
2828 return rval;
2829 }
2830 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2831 PyObject* obj;
2832 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2833 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2834 wxPyEndBlockThreads(blocked);
2835 return obj;
2836 }
2837
2838 class wxMetafileDataObject : public wxDataObjectSimple
2839 {
2840 public:
2841 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2842 };
2843
2844
2845 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2846
2847
2848 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2849 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2850 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2851 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2852 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2853
2854
2855 class wxPyTextDropTarget : public wxTextDropTarget {
2856 public:
2857 wxPyTextDropTarget() {}
2858
2859 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2860
2861 DEC_PYCALLBACK__(OnLeave);
2862 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2863 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2864 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2865 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2866
2867 PYPRIVATE;
2868 };
2869
2870 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2871 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2872 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2873 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2874 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2875 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2876
2877
2878
2879 class wxPyFileDropTarget : public wxFileDropTarget {
2880 public:
2881 wxPyFileDropTarget() {}
2882
2883 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2884
2885 DEC_PYCALLBACK__(OnLeave);
2886 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2887 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2888 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2889 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2890
2891 PYPRIVATE;
2892 };
2893
2894 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2895 const wxArrayString& filenames) {
2896 bool rval = false;
2897 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2898 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2899 PyObject* list = wxArrayString2PyList_helper(filenames);
2900 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2901 Py_DECREF(list);
2902 }
2903 wxPyEndBlockThreads(blocked);
2904 return rval;
2905 }
2906
2907
2908
2909 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2910 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2911 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2912 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2913 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2914
2915
2916
2917
2918 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2919
2920 #include <wx/display.h>
2921
2922 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2923 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2924
2925 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2926 #if !wxUSE_DISPLAY
2927 #include <wx/dynarray.h>
2928 #include <wx/vidmode.h>
2929
2930 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2931 #include "wx/arrimpl.cpp"
2932 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2933 const wxVideoMode wxDefaultVideoMode;
2934
2935 class wxDisplay
2936 {
2937 public:
2938 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2939 ~wxDisplay() {}
2940
2941 static size_t GetCount()
2942 { wxPyRaiseNotImplemented(); return 0; }
2943
2944 static int GetFromPoint(const wxPoint& pt)
2945 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2946 static int GetFromWindow(wxWindow *window)
2947 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2948
2949 virtual bool IsOk() const { return false; }
2950 virtual wxRect GetGeometry() const { wxRect r; return r; }
2951 virtual wxString GetName() const { return wxEmptyString; }
2952 bool IsPrimary() const { return false; }
2953
2954 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2955 { wxArrayVideoModes a; return a; }
2956
2957 virtual wxVideoMode GetCurrentMode() const
2958 { return wxDefaultVideoMode; }
2959
2960 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2961 { return false; }
2962
2963 void ResetMode() {}
2964 };
2965 #endif
2966
2967 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2968 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2969 PyObject* pyList = NULL;
2970 wxArrayVideoModes arr = self->GetModes(mode);
2971 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2972 pyList = PyList_New(0);
2973 for (int i=0; i < arr.GetCount(); i++) {
2974 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2975 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2976 PyList_Append(pyList, pyObj);
2977 Py_DECREF(pyObj);
2978 }
2979 wxPyEndBlockThreads(blocked);
2980 return pyList;
2981 }
2982
2983 #include <wx/stdpaths.h>
2984
2985 static wxStandardPaths *StandardPaths_Get(){
2986 return (wxStandardPaths*) &wxStandardPaths::Get();
2987 }
2988 #ifdef __cplusplus
2989 extern "C" {
2990 #endif
2991 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2992 PyObject *resultobj;
2993 wxSystemColour arg1 ;
2994 wxColour result;
2995 PyObject * obj0 = 0 ;
2996 char *kwnames[] = {
2997 (char *) "index", NULL
2998 };
2999
3000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3001 {
3002 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3003 if (SWIG_arg_fail(1)) SWIG_fail;
3004 }
3005 {
3006 if (!wxPyCheckForApp()) SWIG_fail;
3007 PyThreadState* __tstate = wxPyBeginAllowThreads();
3008 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3009
3010 wxPyEndAllowThreads(__tstate);
3011 if (PyErr_Occurred()) SWIG_fail;
3012 }
3013 {
3014 wxColour * resultptr;
3015 resultptr = new wxColour((wxColour &)(result));
3016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3017 }
3018 return resultobj;
3019 fail:
3020 return NULL;
3021 }
3022
3023
3024 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3025 PyObject *resultobj;
3026 wxSystemFont arg1 ;
3027 wxFont result;
3028 PyObject * obj0 = 0 ;
3029 char *kwnames[] = {
3030 (char *) "index", NULL
3031 };
3032
3033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3034 {
3035 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3036 if (SWIG_arg_fail(1)) SWIG_fail;
3037 }
3038 {
3039 if (!wxPyCheckForApp()) SWIG_fail;
3040 PyThreadState* __tstate = wxPyBeginAllowThreads();
3041 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3042
3043 wxPyEndAllowThreads(__tstate);
3044 if (PyErr_Occurred()) SWIG_fail;
3045 }
3046 {
3047 wxFont * resultptr;
3048 resultptr = new wxFont((wxFont &)(result));
3049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3050 }
3051 return resultobj;
3052 fail:
3053 return NULL;
3054 }
3055
3056
3057 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3058 PyObject *resultobj;
3059 wxSystemMetric arg1 ;
3060 wxWindow *arg2 = (wxWindow *) NULL ;
3061 int result;
3062 PyObject * obj0 = 0 ;
3063 PyObject * obj1 = 0 ;
3064 char *kwnames[] = {
3065 (char *) "index",(char *) "win", NULL
3066 };
3067
3068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3069 {
3070 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3071 if (SWIG_arg_fail(1)) SWIG_fail;
3072 }
3073 if (obj1) {
3074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3075 if (SWIG_arg_fail(2)) SWIG_fail;
3076 }
3077 {
3078 if (!wxPyCheckForApp()) SWIG_fail;
3079 PyThreadState* __tstate = wxPyBeginAllowThreads();
3080 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3081
3082 wxPyEndAllowThreads(__tstate);
3083 if (PyErr_Occurred()) SWIG_fail;
3084 }
3085 {
3086 resultobj = SWIG_From_int((int)(result));
3087 }
3088 return resultobj;
3089 fail:
3090 return NULL;
3091 }
3092
3093
3094 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3095 PyObject *resultobj;
3096 wxSystemFeature arg1 ;
3097 bool result;
3098 PyObject * obj0 = 0 ;
3099 char *kwnames[] = {
3100 (char *) "index", NULL
3101 };
3102
3103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3104 {
3105 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3106 if (SWIG_arg_fail(1)) SWIG_fail;
3107 }
3108 {
3109 if (!wxPyCheckForApp()) SWIG_fail;
3110 PyThreadState* __tstate = wxPyBeginAllowThreads();
3111 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3112
3113 wxPyEndAllowThreads(__tstate);
3114 if (PyErr_Occurred()) SWIG_fail;
3115 }
3116 {
3117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3118 }
3119 return resultobj;
3120 fail:
3121 return NULL;
3122 }
3123
3124
3125 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3126 PyObject *resultobj;
3127 wxSystemScreenType result;
3128 char *kwnames[] = {
3129 NULL
3130 };
3131
3132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3133 {
3134 if (!wxPyCheckForApp()) SWIG_fail;
3135 PyThreadState* __tstate = wxPyBeginAllowThreads();
3136 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3137
3138 wxPyEndAllowThreads(__tstate);
3139 if (PyErr_Occurred()) SWIG_fail;
3140 }
3141 resultobj = SWIG_From_int((result));
3142 return resultobj;
3143 fail:
3144 return NULL;
3145 }
3146
3147
3148 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3149 PyObject *resultobj;
3150 wxSystemScreenType arg1 ;
3151 PyObject * obj0 = 0 ;
3152 char *kwnames[] = {
3153 (char *) "screen", NULL
3154 };
3155
3156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3157 {
3158 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3159 if (SWIG_arg_fail(1)) SWIG_fail;
3160 }
3161 {
3162 if (!wxPyCheckForApp()) SWIG_fail;
3163 PyThreadState* __tstate = wxPyBeginAllowThreads();
3164 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3165
3166 wxPyEndAllowThreads(__tstate);
3167 if (PyErr_Occurred()) SWIG_fail;
3168 }
3169 Py_INCREF(Py_None); resultobj = Py_None;
3170 return resultobj;
3171 fail:
3172 return NULL;
3173 }
3174
3175
3176 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3177 PyObject *obj;
3178 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3179 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3180 Py_INCREF(obj);
3181 return Py_BuildValue((char *)"");
3182 }
3183 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3184 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3185 return 1;
3186 }
3187
3188
3189 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3190 PyObject *pyobj;
3191
3192 {
3193 #if wxUSE_UNICODE
3194 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3195 #else
3196 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3197 #endif
3198 }
3199 return pyobj;
3200 }
3201
3202
3203 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3204 PyObject *resultobj;
3205 wxSystemOptions *result;
3206 char *kwnames[] = {
3207 NULL
3208 };
3209
3210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3211 {
3212 PyThreadState* __tstate = wxPyBeginAllowThreads();
3213 result = (wxSystemOptions *)new wxSystemOptions();
3214
3215 wxPyEndAllowThreads(__tstate);
3216 if (PyErr_Occurred()) SWIG_fail;
3217 }
3218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3219 return resultobj;
3220 fail:
3221 return NULL;
3222 }
3223
3224
3225 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3226 PyObject *resultobj;
3227 wxString *arg1 = 0 ;
3228 wxString *arg2 = 0 ;
3229 bool temp1 = false ;
3230 bool temp2 = false ;
3231 PyObject * obj0 = 0 ;
3232 PyObject * obj1 = 0 ;
3233 char *kwnames[] = {
3234 (char *) "name",(char *) "value", NULL
3235 };
3236
3237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3238 {
3239 arg1 = wxString_in_helper(obj0);
3240 if (arg1 == NULL) SWIG_fail;
3241 temp1 = true;
3242 }
3243 {
3244 arg2 = wxString_in_helper(obj1);
3245 if (arg2 == NULL) SWIG_fail;
3246 temp2 = true;
3247 }
3248 {
3249 PyThreadState* __tstate = wxPyBeginAllowThreads();
3250 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3251
3252 wxPyEndAllowThreads(__tstate);
3253 if (PyErr_Occurred()) SWIG_fail;
3254 }
3255 Py_INCREF(Py_None); resultobj = Py_None;
3256 {
3257 if (temp1)
3258 delete arg1;
3259 }
3260 {
3261 if (temp2)
3262 delete arg2;
3263 }
3264 return resultobj;
3265 fail:
3266 {
3267 if (temp1)
3268 delete arg1;
3269 }
3270 {
3271 if (temp2)
3272 delete arg2;
3273 }
3274 return NULL;
3275 }
3276
3277
3278 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3279 PyObject *resultobj;
3280 wxString *arg1 = 0 ;
3281 int arg2 ;
3282 bool temp1 = false ;
3283 PyObject * obj0 = 0 ;
3284 PyObject * obj1 = 0 ;
3285 char *kwnames[] = {
3286 (char *) "name",(char *) "value", NULL
3287 };
3288
3289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3290 {
3291 arg1 = wxString_in_helper(obj0);
3292 if (arg1 == NULL) SWIG_fail;
3293 temp1 = true;
3294 }
3295 {
3296 arg2 = (int)(SWIG_As_int(obj1));
3297 if (SWIG_arg_fail(2)) SWIG_fail;
3298 }
3299 {
3300 PyThreadState* __tstate = wxPyBeginAllowThreads();
3301 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3302
3303 wxPyEndAllowThreads(__tstate);
3304 if (PyErr_Occurred()) SWIG_fail;
3305 }
3306 Py_INCREF(Py_None); resultobj = Py_None;
3307 {
3308 if (temp1)
3309 delete arg1;
3310 }
3311 return resultobj;
3312 fail:
3313 {
3314 if (temp1)
3315 delete arg1;
3316 }
3317 return NULL;
3318 }
3319
3320
3321 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3322 PyObject *resultobj;
3323 wxString *arg1 = 0 ;
3324 wxString result;
3325 bool temp1 = false ;
3326 PyObject * obj0 = 0 ;
3327 char *kwnames[] = {
3328 (char *) "name", NULL
3329 };
3330
3331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3332 {
3333 arg1 = wxString_in_helper(obj0);
3334 if (arg1 == NULL) SWIG_fail;
3335 temp1 = true;
3336 }
3337 {
3338 PyThreadState* __tstate = wxPyBeginAllowThreads();
3339 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3340
3341 wxPyEndAllowThreads(__tstate);
3342 if (PyErr_Occurred()) SWIG_fail;
3343 }
3344 {
3345 #if wxUSE_UNICODE
3346 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3347 #else
3348 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3349 #endif
3350 }
3351 {
3352 if (temp1)
3353 delete arg1;
3354 }
3355 return resultobj;
3356 fail:
3357 {
3358 if (temp1)
3359 delete arg1;
3360 }
3361 return NULL;
3362 }
3363
3364
3365 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3366 PyObject *resultobj;
3367 wxString *arg1 = 0 ;
3368 int result;
3369 bool temp1 = false ;
3370 PyObject * obj0 = 0 ;
3371 char *kwnames[] = {
3372 (char *) "name", NULL
3373 };
3374
3375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3376 {
3377 arg1 = wxString_in_helper(obj0);
3378 if (arg1 == NULL) SWIG_fail;
3379 temp1 = true;
3380 }
3381 {
3382 PyThreadState* __tstate = wxPyBeginAllowThreads();
3383 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3384
3385 wxPyEndAllowThreads(__tstate);
3386 if (PyErr_Occurred()) SWIG_fail;
3387 }
3388 {
3389 resultobj = SWIG_From_int((int)(result));
3390 }
3391 {
3392 if (temp1)
3393 delete arg1;
3394 }
3395 return resultobj;
3396 fail:
3397 {
3398 if (temp1)
3399 delete arg1;
3400 }
3401 return NULL;
3402 }
3403
3404
3405 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3406 PyObject *resultobj;
3407 wxString *arg1 = 0 ;
3408 bool result;
3409 bool temp1 = false ;
3410 PyObject * obj0 = 0 ;
3411 char *kwnames[] = {
3412 (char *) "name", NULL
3413 };
3414
3415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3416 {
3417 arg1 = wxString_in_helper(obj0);
3418 if (arg1 == NULL) SWIG_fail;
3419 temp1 = true;
3420 }
3421 {
3422 PyThreadState* __tstate = wxPyBeginAllowThreads();
3423 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3424
3425 wxPyEndAllowThreads(__tstate);
3426 if (PyErr_Occurred()) SWIG_fail;
3427 }
3428 {
3429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3430 }
3431 {
3432 if (temp1)
3433 delete arg1;
3434 }
3435 return resultobj;
3436 fail:
3437 {
3438 if (temp1)
3439 delete arg1;
3440 }
3441 return NULL;
3442 }
3443
3444
3445 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3446 PyObject *resultobj;
3447 wxString *arg1 = 0 ;
3448 bool result;
3449 bool temp1 = false ;
3450 PyObject * obj0 = 0 ;
3451 char *kwnames[] = {
3452 (char *) "name", NULL
3453 };
3454
3455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3456 {
3457 arg1 = wxString_in_helper(obj0);
3458 if (arg1 == NULL) SWIG_fail;
3459 temp1 = true;
3460 }
3461 {
3462 PyThreadState* __tstate = wxPyBeginAllowThreads();
3463 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3464
3465 wxPyEndAllowThreads(__tstate);
3466 if (PyErr_Occurred()) SWIG_fail;
3467 }
3468 {
3469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3470 }
3471 {
3472 if (temp1)
3473 delete arg1;
3474 }
3475 return resultobj;
3476 fail:
3477 {
3478 if (temp1)
3479 delete arg1;
3480 }
3481 return NULL;
3482 }
3483
3484
3485 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3486 PyObject *obj;
3487 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3488 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3489 Py_INCREF(obj);
3490 return Py_BuildValue((char *)"");
3491 }
3492 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3493 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3494 return 1;
3495 }
3496
3497
3498 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3499 PyObject *pyobj;
3500
3501 {
3502 #if wxUSE_UNICODE
3503 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3504 #else
3505 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3506 #endif
3507 }
3508 return pyobj;
3509 }
3510
3511
3512 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3513 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3514 return 1;
3515 }
3516
3517
3518 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3519 PyObject *pyobj;
3520
3521 {
3522 #if wxUSE_UNICODE
3523 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3524 #else
3525 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3526 #endif
3527 }
3528 return pyobj;
3529 }
3530
3531
3532 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3533 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3534 return 1;
3535 }
3536
3537
3538 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3539 PyObject *pyobj;
3540
3541 {
3542 #if wxUSE_UNICODE
3543 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3544 #else
3545 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3546 #endif
3547 }
3548 return pyobj;
3549 }
3550
3551
3552 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3553 PyObject *resultobj;
3554 long result;
3555 char *kwnames[] = {
3556 NULL
3557 };
3558
3559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3560 {
3561 PyThreadState* __tstate = wxPyBeginAllowThreads();
3562 result = (long)wxNewId();
3563
3564 wxPyEndAllowThreads(__tstate);
3565 if (PyErr_Occurred()) SWIG_fail;
3566 }
3567 {
3568 resultobj = SWIG_From_long((long)(result));
3569 }
3570 return resultobj;
3571 fail:
3572 return NULL;
3573 }
3574
3575
3576 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3577 PyObject *resultobj;
3578 long arg1 ;
3579 PyObject * obj0 = 0 ;
3580 char *kwnames[] = {
3581 (char *) "id", NULL
3582 };
3583
3584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3585 {
3586 arg1 = (long)(SWIG_As_long(obj0));
3587 if (SWIG_arg_fail(1)) SWIG_fail;
3588 }
3589 {
3590 PyThreadState* __tstate = wxPyBeginAllowThreads();
3591 wxRegisterId(arg1);
3592
3593 wxPyEndAllowThreads(__tstate);
3594 if (PyErr_Occurred()) SWIG_fail;
3595 }
3596 Py_INCREF(Py_None); resultobj = Py_None;
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3604 PyObject *resultobj;
3605 long result;
3606 char *kwnames[] = {
3607 NULL
3608 };
3609
3610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3611 {
3612 PyThreadState* __tstate = wxPyBeginAllowThreads();
3613 result = (long)wxGetCurrentId();
3614
3615 wxPyEndAllowThreads(__tstate);
3616 if (PyErr_Occurred()) SWIG_fail;
3617 }
3618 {
3619 resultobj = SWIG_From_long((long)(result));
3620 }
3621 return resultobj;
3622 fail:
3623 return NULL;
3624 }
3625
3626
3627 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3628 PyObject *resultobj;
3629 int arg1 ;
3630 bool result;
3631 PyObject * obj0 = 0 ;
3632 char *kwnames[] = {
3633 (char *) "id", NULL
3634 };
3635
3636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3637 {
3638 arg1 = (int)(SWIG_As_int(obj0));
3639 if (SWIG_arg_fail(1)) SWIG_fail;
3640 }
3641 {
3642 PyThreadState* __tstate = wxPyBeginAllowThreads();
3643 result = (bool)wxIsStockID(arg1);
3644
3645 wxPyEndAllowThreads(__tstate);
3646 if (PyErr_Occurred()) SWIG_fail;
3647 }
3648 {
3649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3650 }
3651 return resultobj;
3652 fail:
3653 return NULL;
3654 }
3655
3656
3657 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3658 PyObject *resultobj;
3659 int arg1 ;
3660 wxString *arg2 = 0 ;
3661 bool result;
3662 bool temp2 = false ;
3663 PyObject * obj0 = 0 ;
3664 PyObject * obj1 = 0 ;
3665 char *kwnames[] = {
3666 (char *) "id",(char *) "label", NULL
3667 };
3668
3669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3670 {
3671 arg1 = (int)(SWIG_As_int(obj0));
3672 if (SWIG_arg_fail(1)) SWIG_fail;
3673 }
3674 {
3675 arg2 = wxString_in_helper(obj1);
3676 if (arg2 == NULL) SWIG_fail;
3677 temp2 = true;
3678 }
3679 {
3680 PyThreadState* __tstate = wxPyBeginAllowThreads();
3681 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3682
3683 wxPyEndAllowThreads(__tstate);
3684 if (PyErr_Occurred()) SWIG_fail;
3685 }
3686 {
3687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3688 }
3689 {
3690 if (temp2)
3691 delete arg2;
3692 }
3693 return resultobj;
3694 fail:
3695 {
3696 if (temp2)
3697 delete arg2;
3698 }
3699 return NULL;
3700 }
3701
3702
3703 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3704 PyObject *resultobj;
3705 int arg1 ;
3706 bool arg2 = (bool) true ;
3707 wxString arg3 = (wxString) wxPyEmptyString ;
3708 wxString result;
3709 PyObject * obj0 = 0 ;
3710 PyObject * obj1 = 0 ;
3711 PyObject * obj2 = 0 ;
3712 char *kwnames[] = {
3713 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3714 };
3715
3716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3717 {
3718 arg1 = (int)(SWIG_As_int(obj0));
3719 if (SWIG_arg_fail(1)) SWIG_fail;
3720 }
3721 if (obj1) {
3722 {
3723 arg2 = (bool)(SWIG_As_bool(obj1));
3724 if (SWIG_arg_fail(2)) SWIG_fail;
3725 }
3726 }
3727 if (obj2) {
3728 {
3729 wxString* sptr = wxString_in_helper(obj2);
3730 if (sptr == NULL) SWIG_fail;
3731 arg3 = *sptr;
3732 delete sptr;
3733 }
3734 }
3735 {
3736 PyThreadState* __tstate = wxPyBeginAllowThreads();
3737 result = wxGetStockLabel(arg1,arg2,arg3);
3738
3739 wxPyEndAllowThreads(__tstate);
3740 if (PyErr_Occurred()) SWIG_fail;
3741 }
3742 {
3743 #if wxUSE_UNICODE
3744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3745 #else
3746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3747 #endif
3748 }
3749 return resultobj;
3750 fail:
3751 return NULL;
3752 }
3753
3754
3755 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3756 PyObject *resultobj;
3757 char *kwnames[] = {
3758 NULL
3759 };
3760
3761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3762 {
3763 if (!wxPyCheckForApp()) SWIG_fail;
3764 PyThreadState* __tstate = wxPyBeginAllowThreads();
3765 wxBell();
3766
3767 wxPyEndAllowThreads(__tstate);
3768 if (PyErr_Occurred()) SWIG_fail;
3769 }
3770 Py_INCREF(Py_None); resultobj = Py_None;
3771 return resultobj;
3772 fail:
3773 return NULL;
3774 }
3775
3776
3777 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3778 PyObject *resultobj;
3779 char *kwnames[] = {
3780 NULL
3781 };
3782
3783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3784 {
3785 if (!wxPyCheckForApp()) SWIG_fail;
3786 PyThreadState* __tstate = wxPyBeginAllowThreads();
3787 wxEndBusyCursor();
3788
3789 wxPyEndAllowThreads(__tstate);
3790 if (PyErr_Occurred()) SWIG_fail;
3791 }
3792 Py_INCREF(Py_None); resultobj = Py_None;
3793 return resultobj;
3794 fail:
3795 return NULL;
3796 }
3797
3798
3799 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3800 PyObject *resultobj;
3801 bool arg1 = (bool) true ;
3802 long result;
3803 PyObject * obj0 = 0 ;
3804 char *kwnames[] = {
3805 (char *) "resetTimer", NULL
3806 };
3807
3808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3809 if (obj0) {
3810 {
3811 arg1 = (bool)(SWIG_As_bool(obj0));
3812 if (SWIG_arg_fail(1)) SWIG_fail;
3813 }
3814 }
3815 {
3816 PyThreadState* __tstate = wxPyBeginAllowThreads();
3817 result = (long)wxGetElapsedTime(arg1);
3818
3819 wxPyEndAllowThreads(__tstate);
3820 if (PyErr_Occurred()) SWIG_fail;
3821 }
3822 {
3823 resultobj = SWIG_From_long((long)(result));
3824 }
3825 return resultobj;
3826 fail:
3827 return NULL;
3828 }
3829
3830
3831 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3832 PyObject *resultobj;
3833 int *arg1 = (int *) 0 ;
3834 int *arg2 = (int *) 0 ;
3835 int temp1 ;
3836 int res1 = 0 ;
3837 int temp2 ;
3838 int res2 = 0 ;
3839 char *kwnames[] = {
3840 NULL
3841 };
3842
3843 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3844 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3846 {
3847 if (!wxPyCheckForApp()) SWIG_fail;
3848 PyThreadState* __tstate = wxPyBeginAllowThreads();
3849 wxGetMousePosition(arg1,arg2);
3850
3851 wxPyEndAllowThreads(__tstate);
3852 if (PyErr_Occurred()) SWIG_fail;
3853 }
3854 Py_INCREF(Py_None); resultobj = Py_None;
3855 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3856 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3857 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3858 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3859 return resultobj;
3860 fail:
3861 return NULL;
3862 }
3863
3864
3865 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3866 PyObject *resultobj;
3867 bool result;
3868 char *kwnames[] = {
3869 NULL
3870 };
3871
3872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3873 {
3874 PyThreadState* __tstate = wxPyBeginAllowThreads();
3875 result = (bool)wxIsBusy();
3876
3877 wxPyEndAllowThreads(__tstate);
3878 if (PyErr_Occurred()) SWIG_fail;
3879 }
3880 {
3881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3882 }
3883 return resultobj;
3884 fail:
3885 return NULL;
3886 }
3887
3888
3889 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3890 PyObject *resultobj;
3891 wxString result;
3892 char *kwnames[] = {
3893 NULL
3894 };
3895
3896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3897 {
3898 PyThreadState* __tstate = wxPyBeginAllowThreads();
3899 result = wxNow();
3900
3901 wxPyEndAllowThreads(__tstate);
3902 if (PyErr_Occurred()) SWIG_fail;
3903 }
3904 {
3905 #if wxUSE_UNICODE
3906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3907 #else
3908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3909 #endif
3910 }
3911 return resultobj;
3912 fail:
3913 return NULL;
3914 }
3915
3916
3917 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3918 PyObject *resultobj;
3919 wxString const &arg1_defvalue = wxPyEmptyString ;
3920 wxString *arg1 = (wxString *) &arg1_defvalue ;
3921 bool result;
3922 bool temp1 = false ;
3923 PyObject * obj0 = 0 ;
3924 char *kwnames[] = {
3925 (char *) "command", NULL
3926 };
3927
3928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3929 if (obj0) {
3930 {
3931 arg1 = wxString_in_helper(obj0);
3932 if (arg1 == NULL) SWIG_fail;
3933 temp1 = true;
3934 }
3935 }
3936 {
3937 PyThreadState* __tstate = wxPyBeginAllowThreads();
3938 result = (bool)wxShell((wxString const &)*arg1);
3939
3940 wxPyEndAllowThreads(__tstate);
3941 if (PyErr_Occurred()) SWIG_fail;
3942 }
3943 {
3944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3945 }
3946 {
3947 if (temp1)
3948 delete arg1;
3949 }
3950 return resultobj;
3951 fail:
3952 {
3953 if (temp1)
3954 delete arg1;
3955 }
3956 return NULL;
3957 }
3958
3959
3960 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3961 PyObject *resultobj;
3962 char *kwnames[] = {
3963 NULL
3964 };
3965
3966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3967 {
3968 PyThreadState* __tstate = wxPyBeginAllowThreads();
3969 wxStartTimer();
3970
3971 wxPyEndAllowThreads(__tstate);
3972 if (PyErr_Occurred()) SWIG_fail;
3973 }
3974 Py_INCREF(Py_None); resultobj = Py_None;
3975 return resultobj;
3976 fail:
3977 return NULL;
3978 }
3979
3980
3981 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3982 PyObject *resultobj;
3983 int *arg1 = (int *) 0 ;
3984 int *arg2 = (int *) 0 ;
3985 int result;
3986 int temp1 ;
3987 int res1 = 0 ;
3988 int temp2 ;
3989 int res2 = 0 ;
3990 char *kwnames[] = {
3991 NULL
3992 };
3993
3994 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3995 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3997 {
3998 PyThreadState* __tstate = wxPyBeginAllowThreads();
3999 result = (int)wxGetOsVersion(arg1,arg2);
4000
4001 wxPyEndAllowThreads(__tstate);
4002 if (PyErr_Occurred()) SWIG_fail;
4003 }
4004 {
4005 resultobj = SWIG_From_int((int)(result));
4006 }
4007 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4008 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4009 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4010 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4011 return resultobj;
4012 fail:
4013 return NULL;
4014 }
4015
4016
4017 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4018 PyObject *resultobj;
4019 wxString result;
4020 char *kwnames[] = {
4021 NULL
4022 };
4023
4024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4025 {
4026 PyThreadState* __tstate = wxPyBeginAllowThreads();
4027 result = wxGetOsDescription();
4028
4029 wxPyEndAllowThreads(__tstate);
4030 if (PyErr_Occurred()) SWIG_fail;
4031 }
4032 {
4033 #if wxUSE_UNICODE
4034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4035 #else
4036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4037 #endif
4038 }
4039 return resultobj;
4040 fail:
4041 return NULL;
4042 }
4043
4044
4045 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4046 PyObject *resultobj;
4047 long result;
4048 char *kwnames[] = {
4049 NULL
4050 };
4051
4052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4053 {
4054 PyThreadState* __tstate = wxPyBeginAllowThreads();
4055 result = (long)wxGetFreeMemory();
4056
4057 wxPyEndAllowThreads(__tstate);
4058 if (PyErr_Occurred()) SWIG_fail;
4059 }
4060 {
4061 resultobj = SWIG_From_long((long)(result));
4062 }
4063 return resultobj;
4064 fail:
4065 return NULL;
4066 }
4067
4068
4069 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4070 PyObject *resultobj;
4071 wxShutdownFlags arg1 ;
4072 bool result;
4073 PyObject * obj0 = 0 ;
4074 char *kwnames[] = {
4075 (char *) "wFlags", NULL
4076 };
4077
4078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4079 {
4080 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4081 if (SWIG_arg_fail(1)) SWIG_fail;
4082 }
4083 {
4084 if (!wxPyCheckForApp()) SWIG_fail;
4085 PyThreadState* __tstate = wxPyBeginAllowThreads();
4086 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4087
4088 wxPyEndAllowThreads(__tstate);
4089 if (PyErr_Occurred()) SWIG_fail;
4090 }
4091 {
4092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4093 }
4094 return resultobj;
4095 fail:
4096 return NULL;
4097 }
4098
4099
4100 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj;
4102 int arg1 ;
4103 PyObject * obj0 = 0 ;
4104 char *kwnames[] = {
4105 (char *) "secs", NULL
4106 };
4107
4108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4109 {
4110 arg1 = (int)(SWIG_As_int(obj0));
4111 if (SWIG_arg_fail(1)) SWIG_fail;
4112 }
4113 {
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 wxSleep(arg1);
4116
4117 wxPyEndAllowThreads(__tstate);
4118 if (PyErr_Occurred()) SWIG_fail;
4119 }
4120 Py_INCREF(Py_None); resultobj = Py_None;
4121 return resultobj;
4122 fail:
4123 return NULL;
4124 }
4125
4126
4127 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4128 PyObject *resultobj;
4129 unsigned long arg1 ;
4130 PyObject * obj0 = 0 ;
4131 char *kwnames[] = {
4132 (char *) "milliseconds", NULL
4133 };
4134
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4136 {
4137 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4138 if (SWIG_arg_fail(1)) SWIG_fail;
4139 }
4140 {
4141 PyThreadState* __tstate = wxPyBeginAllowThreads();
4142 wxMilliSleep(arg1);
4143
4144 wxPyEndAllowThreads(__tstate);
4145 if (PyErr_Occurred()) SWIG_fail;
4146 }
4147 Py_INCREF(Py_None); resultobj = Py_None;
4148 return resultobj;
4149 fail:
4150 return NULL;
4151 }
4152
4153
4154 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4155 PyObject *resultobj;
4156 unsigned long arg1 ;
4157 PyObject * obj0 = 0 ;
4158 char *kwnames[] = {
4159 (char *) "microseconds", NULL
4160 };
4161
4162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4163 {
4164 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4165 if (SWIG_arg_fail(1)) SWIG_fail;
4166 }
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 wxMicroSleep(arg1);
4170
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 Py_INCREF(Py_None); resultobj = Py_None;
4175 return resultobj;
4176 fail:
4177 return NULL;
4178 }
4179
4180
4181 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4182 PyObject *resultobj;
4183 bool arg1 ;
4184 PyObject * obj0 = 0 ;
4185 char *kwnames[] = {
4186 (char *) "enable", NULL
4187 };
4188
4189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4190 {
4191 arg1 = (bool)(SWIG_As_bool(obj0));
4192 if (SWIG_arg_fail(1)) SWIG_fail;
4193 }
4194 {
4195 PyThreadState* __tstate = wxPyBeginAllowThreads();
4196 wxEnableTopLevelWindows(arg1);
4197
4198 wxPyEndAllowThreads(__tstate);
4199 if (PyErr_Occurred()) SWIG_fail;
4200 }
4201 Py_INCREF(Py_None); resultobj = Py_None;
4202 return resultobj;
4203 fail:
4204 return NULL;
4205 }
4206
4207
4208 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4209 PyObject *resultobj;
4210 wxString *arg1 = 0 ;
4211 wxString result;
4212 bool temp1 = false ;
4213 PyObject * obj0 = 0 ;
4214 char *kwnames[] = {
4215 (char *) "in", NULL
4216 };
4217
4218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4219 {
4220 arg1 = wxString_in_helper(obj0);
4221 if (arg1 == NULL) SWIG_fail;
4222 temp1 = true;
4223 }
4224 {
4225 PyThreadState* __tstate = wxPyBeginAllowThreads();
4226 result = wxStripMenuCodes((wxString const &)*arg1);
4227
4228 wxPyEndAllowThreads(__tstate);
4229 if (PyErr_Occurred()) SWIG_fail;
4230 }
4231 {
4232 #if wxUSE_UNICODE
4233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4234 #else
4235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4236 #endif
4237 }
4238 {
4239 if (temp1)
4240 delete arg1;
4241 }
4242 return resultobj;
4243 fail:
4244 {
4245 if (temp1)
4246 delete arg1;
4247 }
4248 return NULL;
4249 }
4250
4251
4252 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4253 PyObject *resultobj;
4254 wxString result;
4255 char *kwnames[] = {
4256 NULL
4257 };
4258
4259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4260 {
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 result = wxGetEmailAddress();
4263
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 {
4268 #if wxUSE_UNICODE
4269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4270 #else
4271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4272 #endif
4273 }
4274 return resultobj;
4275 fail:
4276 return NULL;
4277 }
4278
4279
4280 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4281 PyObject *resultobj;
4282 wxString result;
4283 char *kwnames[] = {
4284 NULL
4285 };
4286
4287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4288 {
4289 PyThreadState* __tstate = wxPyBeginAllowThreads();
4290 result = wxGetHostName();
4291
4292 wxPyEndAllowThreads(__tstate);
4293 if (PyErr_Occurred()) SWIG_fail;
4294 }
4295 {
4296 #if wxUSE_UNICODE
4297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4298 #else
4299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4300 #endif
4301 }
4302 return resultobj;
4303 fail:
4304 return NULL;
4305 }
4306
4307
4308 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4309 PyObject *resultobj;
4310 wxString result;
4311 char *kwnames[] = {
4312 NULL
4313 };
4314
4315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4316 {
4317 PyThreadState* __tstate = wxPyBeginAllowThreads();
4318 result = wxGetFullHostName();
4319
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 {
4324 #if wxUSE_UNICODE
4325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4326 #else
4327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4328 #endif
4329 }
4330 return resultobj;
4331 fail:
4332 return NULL;
4333 }
4334
4335
4336 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4337 PyObject *resultobj;
4338 wxString result;
4339 char *kwnames[] = {
4340 NULL
4341 };
4342
4343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4344 {
4345 PyThreadState* __tstate = wxPyBeginAllowThreads();
4346 result = wxGetUserId();
4347
4348 wxPyEndAllowThreads(__tstate);
4349 if (PyErr_Occurred()) SWIG_fail;
4350 }
4351 {
4352 #if wxUSE_UNICODE
4353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4354 #else
4355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4356 #endif
4357 }
4358 return resultobj;
4359 fail:
4360 return NULL;
4361 }
4362
4363
4364 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4365 PyObject *resultobj;
4366 wxString result;
4367 char *kwnames[] = {
4368 NULL
4369 };
4370
4371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4372 {
4373 PyThreadState* __tstate = wxPyBeginAllowThreads();
4374 result = wxGetUserName();
4375
4376 wxPyEndAllowThreads(__tstate);
4377 if (PyErr_Occurred()) SWIG_fail;
4378 }
4379 {
4380 #if wxUSE_UNICODE
4381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4382 #else
4383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4384 #endif
4385 }
4386 return resultobj;
4387 fail:
4388 return NULL;
4389 }
4390
4391
4392 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4393 PyObject *resultobj;
4394 wxString result;
4395 char *kwnames[] = {
4396 NULL
4397 };
4398
4399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4400 {
4401 PyThreadState* __tstate = wxPyBeginAllowThreads();
4402 result = wxGetHomeDir();
4403
4404 wxPyEndAllowThreads(__tstate);
4405 if (PyErr_Occurred()) SWIG_fail;
4406 }
4407 {
4408 #if wxUSE_UNICODE
4409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4410 #else
4411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4412 #endif
4413 }
4414 return resultobj;
4415 fail:
4416 return NULL;
4417 }
4418
4419
4420 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4421 PyObject *resultobj;
4422 wxString const &arg1_defvalue = wxPyEmptyString ;
4423 wxString *arg1 = (wxString *) &arg1_defvalue ;
4424 wxString result;
4425 bool temp1 = false ;
4426 PyObject * obj0 = 0 ;
4427 char *kwnames[] = {
4428 (char *) "user", NULL
4429 };
4430
4431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4432 if (obj0) {
4433 {
4434 arg1 = wxString_in_helper(obj0);
4435 if (arg1 == NULL) SWIG_fail;
4436 temp1 = true;
4437 }
4438 }
4439 {
4440 PyThreadState* __tstate = wxPyBeginAllowThreads();
4441 result = wxGetUserHome((wxString const &)*arg1);
4442
4443 wxPyEndAllowThreads(__tstate);
4444 if (PyErr_Occurred()) SWIG_fail;
4445 }
4446 {
4447 #if wxUSE_UNICODE
4448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4449 #else
4450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4451 #endif
4452 }
4453 {
4454 if (temp1)
4455 delete arg1;
4456 }
4457 return resultobj;
4458 fail:
4459 {
4460 if (temp1)
4461 delete arg1;
4462 }
4463 return NULL;
4464 }
4465
4466
4467 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4468 PyObject *resultobj;
4469 unsigned long result;
4470 char *kwnames[] = {
4471 NULL
4472 };
4473
4474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4475 {
4476 PyThreadState* __tstate = wxPyBeginAllowThreads();
4477 result = (unsigned long)wxGetProcessId();
4478
4479 wxPyEndAllowThreads(__tstate);
4480 if (PyErr_Occurred()) SWIG_fail;
4481 }
4482 {
4483 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4484 }
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4492 PyObject *resultobj;
4493 char *kwnames[] = {
4494 NULL
4495 };
4496
4497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4498 {
4499 PyThreadState* __tstate = wxPyBeginAllowThreads();
4500 wxTrap();
4501
4502 wxPyEndAllowThreads(__tstate);
4503 if (PyErr_Occurred()) SWIG_fail;
4504 }
4505 Py_INCREF(Py_None); resultobj = Py_None;
4506 return resultobj;
4507 fail:
4508 return NULL;
4509 }
4510
4511
4512 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4513 PyObject *resultobj;
4514 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4515 wxString *arg1 = (wxString *) &arg1_defvalue ;
4516 wxString const &arg2_defvalue = wxPyEmptyString ;
4517 wxString *arg2 = (wxString *) &arg2_defvalue ;
4518 wxString const &arg3_defvalue = wxPyEmptyString ;
4519 wxString *arg3 = (wxString *) &arg3_defvalue ;
4520 wxString const &arg4_defvalue = wxPyEmptyString ;
4521 wxString *arg4 = (wxString *) &arg4_defvalue ;
4522 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4523 wxString *arg5 = (wxString *) &arg5_defvalue ;
4524 int arg6 = (int) 0 ;
4525 wxWindow *arg7 = (wxWindow *) NULL ;
4526 int arg8 = (int) -1 ;
4527 int arg9 = (int) -1 ;
4528 wxString result;
4529 bool temp1 = false ;
4530 bool temp2 = false ;
4531 bool temp3 = false ;
4532 bool temp4 = false ;
4533 bool temp5 = false ;
4534 PyObject * obj0 = 0 ;
4535 PyObject * obj1 = 0 ;
4536 PyObject * obj2 = 0 ;
4537 PyObject * obj3 = 0 ;
4538 PyObject * obj4 = 0 ;
4539 PyObject * obj5 = 0 ;
4540 PyObject * obj6 = 0 ;
4541 PyObject * obj7 = 0 ;
4542 PyObject * obj8 = 0 ;
4543 char *kwnames[] = {
4544 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4545 };
4546
4547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4548 if (obj0) {
4549 {
4550 arg1 = wxString_in_helper(obj0);
4551 if (arg1 == NULL) SWIG_fail;
4552 temp1 = true;
4553 }
4554 }
4555 if (obj1) {
4556 {
4557 arg2 = wxString_in_helper(obj1);
4558 if (arg2 == NULL) SWIG_fail;
4559 temp2 = true;
4560 }
4561 }
4562 if (obj2) {
4563 {
4564 arg3 = wxString_in_helper(obj2);
4565 if (arg3 == NULL) SWIG_fail;
4566 temp3 = true;
4567 }
4568 }
4569 if (obj3) {
4570 {
4571 arg4 = wxString_in_helper(obj3);
4572 if (arg4 == NULL) SWIG_fail;
4573 temp4 = true;
4574 }
4575 }
4576 if (obj4) {
4577 {
4578 arg5 = wxString_in_helper(obj4);
4579 if (arg5 == NULL) SWIG_fail;
4580 temp5 = true;
4581 }
4582 }
4583 if (obj5) {
4584 {
4585 arg6 = (int)(SWIG_As_int(obj5));
4586 if (SWIG_arg_fail(6)) SWIG_fail;
4587 }
4588 }
4589 if (obj6) {
4590 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4591 if (SWIG_arg_fail(7)) SWIG_fail;
4592 }
4593 if (obj7) {
4594 {
4595 arg8 = (int)(SWIG_As_int(obj7));
4596 if (SWIG_arg_fail(8)) SWIG_fail;
4597 }
4598 }
4599 if (obj8) {
4600 {
4601 arg9 = (int)(SWIG_As_int(obj8));
4602 if (SWIG_arg_fail(9)) SWIG_fail;
4603 }
4604 }
4605 {
4606 if (!wxPyCheckForApp()) SWIG_fail;
4607 PyThreadState* __tstate = wxPyBeginAllowThreads();
4608 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4609
4610 wxPyEndAllowThreads(__tstate);
4611 if (PyErr_Occurred()) SWIG_fail;
4612 }
4613 {
4614 #if wxUSE_UNICODE
4615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4616 #else
4617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4618 #endif
4619 }
4620 {
4621 if (temp1)
4622 delete arg1;
4623 }
4624 {
4625 if (temp2)
4626 delete arg2;
4627 }
4628 {
4629 if (temp3)
4630 delete arg3;
4631 }
4632 {
4633 if (temp4)
4634 delete arg4;
4635 }
4636 {
4637 if (temp5)
4638 delete arg5;
4639 }
4640 return resultobj;
4641 fail:
4642 {
4643 if (temp1)
4644 delete arg1;
4645 }
4646 {
4647 if (temp2)
4648 delete arg2;
4649 }
4650 {
4651 if (temp3)
4652 delete arg3;
4653 }
4654 {
4655 if (temp4)
4656 delete arg4;
4657 }
4658 {
4659 if (temp5)
4660 delete arg5;
4661 }
4662 return NULL;
4663 }
4664
4665
4666 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4667 PyObject *resultobj;
4668 wxString *arg1 = 0 ;
4669 wxString *arg2 = 0 ;
4670 wxString const &arg3_defvalue = wxPyEmptyString ;
4671 wxString *arg3 = (wxString *) &arg3_defvalue ;
4672 wxWindow *arg4 = (wxWindow *) NULL ;
4673 wxString result;
4674 bool temp1 = false ;
4675 bool temp2 = false ;
4676 bool temp3 = false ;
4677 PyObject * obj0 = 0 ;
4678 PyObject * obj1 = 0 ;
4679 PyObject * obj2 = 0 ;
4680 PyObject * obj3 = 0 ;
4681 char *kwnames[] = {
4682 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4683 };
4684
4685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4686 {
4687 arg1 = wxString_in_helper(obj0);
4688 if (arg1 == NULL) SWIG_fail;
4689 temp1 = true;
4690 }
4691 {
4692 arg2 = wxString_in_helper(obj1);
4693 if (arg2 == NULL) SWIG_fail;
4694 temp2 = true;
4695 }
4696 if (obj2) {
4697 {
4698 arg3 = wxString_in_helper(obj2);
4699 if (arg3 == NULL) SWIG_fail;
4700 temp3 = true;
4701 }
4702 }
4703 if (obj3) {
4704 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4705 if (SWIG_arg_fail(4)) SWIG_fail;
4706 }
4707 {
4708 if (!wxPyCheckForApp()) SWIG_fail;
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4711
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 #if wxUSE_UNICODE
4717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4718 #else
4719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4720 #endif
4721 }
4722 {
4723 if (temp1)
4724 delete arg1;
4725 }
4726 {
4727 if (temp2)
4728 delete arg2;
4729 }
4730 {
4731 if (temp3)
4732 delete arg3;
4733 }
4734 return resultobj;
4735 fail:
4736 {
4737 if (temp1)
4738 delete arg1;
4739 }
4740 {
4741 if (temp2)
4742 delete arg2;
4743 }
4744 {
4745 if (temp3)
4746 delete arg3;
4747 }
4748 return NULL;
4749 }
4750
4751
4752 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4753 PyObject *resultobj;
4754 wxString *arg1 = 0 ;
4755 wxString *arg2 = 0 ;
4756 wxString const &arg3_defvalue = wxPyEmptyString ;
4757 wxString *arg3 = (wxString *) &arg3_defvalue ;
4758 wxWindow *arg4 = (wxWindow *) NULL ;
4759 wxString result;
4760 bool temp1 = false ;
4761 bool temp2 = false ;
4762 bool temp3 = false ;
4763 PyObject * obj0 = 0 ;
4764 PyObject * obj1 = 0 ;
4765 PyObject * obj2 = 0 ;
4766 PyObject * obj3 = 0 ;
4767 char *kwnames[] = {
4768 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4769 };
4770
4771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4772 {
4773 arg1 = wxString_in_helper(obj0);
4774 if (arg1 == NULL) SWIG_fail;
4775 temp1 = true;
4776 }
4777 {
4778 arg2 = wxString_in_helper(obj1);
4779 if (arg2 == NULL) SWIG_fail;
4780 temp2 = true;
4781 }
4782 if (obj2) {
4783 {
4784 arg3 = wxString_in_helper(obj2);
4785 if (arg3 == NULL) SWIG_fail;
4786 temp3 = true;
4787 }
4788 }
4789 if (obj3) {
4790 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4791 if (SWIG_arg_fail(4)) SWIG_fail;
4792 }
4793 {
4794 if (!wxPyCheckForApp()) SWIG_fail;
4795 PyThreadState* __tstate = wxPyBeginAllowThreads();
4796 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4797
4798 wxPyEndAllowThreads(__tstate);
4799 if (PyErr_Occurred()) SWIG_fail;
4800 }
4801 {
4802 #if wxUSE_UNICODE
4803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4804 #else
4805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4806 #endif
4807 }
4808 {
4809 if (temp1)
4810 delete arg1;
4811 }
4812 {
4813 if (temp2)
4814 delete arg2;
4815 }
4816 {
4817 if (temp3)
4818 delete arg3;
4819 }
4820 return resultobj;
4821 fail:
4822 {
4823 if (temp1)
4824 delete arg1;
4825 }
4826 {
4827 if (temp2)
4828 delete arg2;
4829 }
4830 {
4831 if (temp3)
4832 delete arg3;
4833 }
4834 return NULL;
4835 }
4836
4837
4838 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj;
4840 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4841 wxString *arg1 = (wxString *) &arg1_defvalue ;
4842 wxString const &arg2_defvalue = wxPyEmptyString ;
4843 wxString *arg2 = (wxString *) &arg2_defvalue ;
4844 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4845 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4846 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4847 wxWindow *arg5 = (wxWindow *) NULL ;
4848 wxString result;
4849 bool temp1 = false ;
4850 bool temp2 = false ;
4851 wxPoint temp4 ;
4852 PyObject * obj0 = 0 ;
4853 PyObject * obj1 = 0 ;
4854 PyObject * obj2 = 0 ;
4855 PyObject * obj3 = 0 ;
4856 PyObject * obj4 = 0 ;
4857 char *kwnames[] = {
4858 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4859 };
4860
4861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4862 if (obj0) {
4863 {
4864 arg1 = wxString_in_helper(obj0);
4865 if (arg1 == NULL) SWIG_fail;
4866 temp1 = true;
4867 }
4868 }
4869 if (obj1) {
4870 {
4871 arg2 = wxString_in_helper(obj1);
4872 if (arg2 == NULL) SWIG_fail;
4873 temp2 = true;
4874 }
4875 }
4876 if (obj2) {
4877 {
4878 arg3 = (long)(SWIG_As_long(obj2));
4879 if (SWIG_arg_fail(3)) SWIG_fail;
4880 }
4881 }
4882 if (obj3) {
4883 {
4884 arg4 = &temp4;
4885 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4886 }
4887 }
4888 if (obj4) {
4889 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4890 if (SWIG_arg_fail(5)) SWIG_fail;
4891 }
4892 {
4893 if (!wxPyCheckForApp()) SWIG_fail;
4894 PyThreadState* __tstate = wxPyBeginAllowThreads();
4895 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4896
4897 wxPyEndAllowThreads(__tstate);
4898 if (PyErr_Occurred()) SWIG_fail;
4899 }
4900 {
4901 #if wxUSE_UNICODE
4902 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4903 #else
4904 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4905 #endif
4906 }
4907 {
4908 if (temp1)
4909 delete arg1;
4910 }
4911 {
4912 if (temp2)
4913 delete arg2;
4914 }
4915 return resultobj;
4916 fail:
4917 {
4918 if (temp1)
4919 delete arg1;
4920 }
4921 {
4922 if (temp2)
4923 delete arg2;
4924 }
4925 return NULL;
4926 }
4927
4928
4929 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4930 PyObject *resultobj;
4931 wxString *arg1 = 0 ;
4932 wxString const &arg2_defvalue = wxPyEmptyString ;
4933 wxString *arg2 = (wxString *) &arg2_defvalue ;
4934 wxString const &arg3_defvalue = wxPyEmptyString ;
4935 wxString *arg3 = (wxString *) &arg3_defvalue ;
4936 wxWindow *arg4 = (wxWindow *) NULL ;
4937 int arg5 = (int) -1 ;
4938 int arg6 = (int) -1 ;
4939 bool arg7 = (bool) true ;
4940 wxString result;
4941 bool temp1 = false ;
4942 bool temp2 = false ;
4943 bool temp3 = false ;
4944 PyObject * obj0 = 0 ;
4945 PyObject * obj1 = 0 ;
4946 PyObject * obj2 = 0 ;
4947 PyObject * obj3 = 0 ;
4948 PyObject * obj4 = 0 ;
4949 PyObject * obj5 = 0 ;
4950 PyObject * obj6 = 0 ;
4951 char *kwnames[] = {
4952 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4953 };
4954
4955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4956 {
4957 arg1 = wxString_in_helper(obj0);
4958 if (arg1 == NULL) SWIG_fail;
4959 temp1 = true;
4960 }
4961 if (obj1) {
4962 {
4963 arg2 = wxString_in_helper(obj1);
4964 if (arg2 == NULL) SWIG_fail;
4965 temp2 = true;
4966 }
4967 }
4968 if (obj2) {
4969 {
4970 arg3 = wxString_in_helper(obj2);
4971 if (arg3 == NULL) SWIG_fail;
4972 temp3 = true;
4973 }
4974 }
4975 if (obj3) {
4976 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4977 if (SWIG_arg_fail(4)) SWIG_fail;
4978 }
4979 if (obj4) {
4980 {
4981 arg5 = (int)(SWIG_As_int(obj4));
4982 if (SWIG_arg_fail(5)) SWIG_fail;
4983 }
4984 }
4985 if (obj5) {
4986 {
4987 arg6 = (int)(SWIG_As_int(obj5));
4988 if (SWIG_arg_fail(6)) SWIG_fail;
4989 }
4990 }
4991 if (obj6) {
4992 {
4993 arg7 = (bool)(SWIG_As_bool(obj6));
4994 if (SWIG_arg_fail(7)) SWIG_fail;
4995 }
4996 }
4997 {
4998 if (!wxPyCheckForApp()) SWIG_fail;
4999 PyThreadState* __tstate = wxPyBeginAllowThreads();
5000 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5001
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 {
5006 #if wxUSE_UNICODE
5007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5008 #else
5009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5010 #endif
5011 }
5012 {
5013 if (temp1)
5014 delete arg1;
5015 }
5016 {
5017 if (temp2)
5018 delete arg2;
5019 }
5020 {
5021 if (temp3)
5022 delete arg3;
5023 }
5024 return resultobj;
5025 fail:
5026 {
5027 if (temp1)
5028 delete arg1;
5029 }
5030 {
5031 if (temp2)
5032 delete arg2;
5033 }
5034 {
5035 if (temp3)
5036 delete arg3;
5037 }
5038 return NULL;
5039 }
5040
5041
5042 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5043 PyObject *resultobj;
5044 wxString *arg1 = 0 ;
5045 wxString const &arg2_defvalue = wxPyEmptyString ;
5046 wxString *arg2 = (wxString *) &arg2_defvalue ;
5047 wxString const &arg3_defvalue = wxPyEmptyString ;
5048 wxString *arg3 = (wxString *) &arg3_defvalue ;
5049 wxWindow *arg4 = (wxWindow *) NULL ;
5050 wxString result;
5051 bool temp1 = false ;
5052 bool temp2 = false ;
5053 bool temp3 = false ;
5054 PyObject * obj0 = 0 ;
5055 PyObject * obj1 = 0 ;
5056 PyObject * obj2 = 0 ;
5057 PyObject * obj3 = 0 ;
5058 char *kwnames[] = {
5059 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5060 };
5061
5062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5063 {
5064 arg1 = wxString_in_helper(obj0);
5065 if (arg1 == NULL) SWIG_fail;
5066 temp1 = true;
5067 }
5068 if (obj1) {
5069 {
5070 arg2 = wxString_in_helper(obj1);
5071 if (arg2 == NULL) SWIG_fail;
5072 temp2 = true;
5073 }
5074 }
5075 if (obj2) {
5076 {
5077 arg3 = wxString_in_helper(obj2);
5078 if (arg3 == NULL) SWIG_fail;
5079 temp3 = true;
5080 }
5081 }
5082 if (obj3) {
5083 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5084 if (SWIG_arg_fail(4)) SWIG_fail;
5085 }
5086 {
5087 if (!wxPyCheckForApp()) SWIG_fail;
5088 PyThreadState* __tstate = wxPyBeginAllowThreads();
5089 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5090
5091 wxPyEndAllowThreads(__tstate);
5092 if (PyErr_Occurred()) SWIG_fail;
5093 }
5094 {
5095 #if wxUSE_UNICODE
5096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5097 #else
5098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5099 #endif
5100 }
5101 {
5102 if (temp1)
5103 delete arg1;
5104 }
5105 {
5106 if (temp2)
5107 delete arg2;
5108 }
5109 {
5110 if (temp3)
5111 delete arg3;
5112 }
5113 return resultobj;
5114 fail:
5115 {
5116 if (temp1)
5117 delete arg1;
5118 }
5119 {
5120 if (temp2)
5121 delete arg2;
5122 }
5123 {
5124 if (temp3)
5125 delete arg3;
5126 }
5127 return NULL;
5128 }
5129
5130
5131 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5132 PyObject *resultobj;
5133 wxString *arg1 = 0 ;
5134 wxString *arg2 = 0 ;
5135 int arg3 ;
5136 wxString *arg4 = (wxString *) 0 ;
5137 wxWindow *arg5 = (wxWindow *) NULL ;
5138 int arg6 = (int) -1 ;
5139 int arg7 = (int) -1 ;
5140 bool arg8 = (bool) true ;
5141 int arg9 = (int) 150 ;
5142 int arg10 = (int) 200 ;
5143 wxString result;
5144 bool temp1 = false ;
5145 bool temp2 = false ;
5146 PyObject * obj0 = 0 ;
5147 PyObject * obj1 = 0 ;
5148 PyObject * obj2 = 0 ;
5149 PyObject * obj3 = 0 ;
5150 PyObject * obj4 = 0 ;
5151 PyObject * obj5 = 0 ;
5152 PyObject * obj6 = 0 ;
5153 PyObject * obj7 = 0 ;
5154 PyObject * obj8 = 0 ;
5155 char *kwnames[] = {
5156 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5157 };
5158
5159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5160 {
5161 arg1 = wxString_in_helper(obj0);
5162 if (arg1 == NULL) SWIG_fail;
5163 temp1 = true;
5164 }
5165 {
5166 arg2 = wxString_in_helper(obj1);
5167 if (arg2 == NULL) SWIG_fail;
5168 temp2 = true;
5169 }
5170 {
5171 arg3 = PyList_Size(obj2);
5172 arg4 = wxString_LIST_helper(obj2);
5173 if (arg4 == NULL) SWIG_fail;
5174 }
5175 if (obj3) {
5176 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5177 if (SWIG_arg_fail(5)) SWIG_fail;
5178 }
5179 if (obj4) {
5180 {
5181 arg6 = (int)(SWIG_As_int(obj4));
5182 if (SWIG_arg_fail(6)) SWIG_fail;
5183 }
5184 }
5185 if (obj5) {
5186 {
5187 arg7 = (int)(SWIG_As_int(obj5));
5188 if (SWIG_arg_fail(7)) SWIG_fail;
5189 }
5190 }
5191 if (obj6) {
5192 {
5193 arg8 = (bool)(SWIG_As_bool(obj6));
5194 if (SWIG_arg_fail(8)) SWIG_fail;
5195 }
5196 }
5197 if (obj7) {
5198 {
5199 arg9 = (int)(SWIG_As_int(obj7));
5200 if (SWIG_arg_fail(9)) SWIG_fail;
5201 }
5202 }
5203 if (obj8) {
5204 {
5205 arg10 = (int)(SWIG_As_int(obj8));
5206 if (SWIG_arg_fail(10)) SWIG_fail;
5207 }
5208 }
5209 {
5210 if (!wxPyCheckForApp()) SWIG_fail;
5211 PyThreadState* __tstate = wxPyBeginAllowThreads();
5212 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5213
5214 wxPyEndAllowThreads(__tstate);
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 {
5218 #if wxUSE_UNICODE
5219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5220 #else
5221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5222 #endif
5223 }
5224 {
5225 if (temp1)
5226 delete arg1;
5227 }
5228 {
5229 if (temp2)
5230 delete arg2;
5231 }
5232 {
5233 if (arg4) delete [] arg4;
5234 }
5235 return resultobj;
5236 fail:
5237 {
5238 if (temp1)
5239 delete arg1;
5240 }
5241 {
5242 if (temp2)
5243 delete arg2;
5244 }
5245 {
5246 if (arg4) delete [] arg4;
5247 }
5248 return NULL;
5249 }
5250
5251
5252 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5253 PyObject *resultobj;
5254 wxString *arg1 = 0 ;
5255 wxString *arg2 = 0 ;
5256 int arg3 ;
5257 wxString *arg4 = (wxString *) 0 ;
5258 wxWindow *arg5 = (wxWindow *) NULL ;
5259 int arg6 = (int) -1 ;
5260 int arg7 = (int) -1 ;
5261 bool arg8 = (bool) true ;
5262 int arg9 = (int) 150 ;
5263 int arg10 = (int) 200 ;
5264 int result;
5265 bool temp1 = false ;
5266 bool temp2 = false ;
5267 PyObject * obj0 = 0 ;
5268 PyObject * obj1 = 0 ;
5269 PyObject * obj2 = 0 ;
5270 PyObject * obj3 = 0 ;
5271 PyObject * obj4 = 0 ;
5272 PyObject * obj5 = 0 ;
5273 PyObject * obj6 = 0 ;
5274 PyObject * obj7 = 0 ;
5275 PyObject * obj8 = 0 ;
5276 char *kwnames[] = {
5277 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5278 };
5279
5280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5281 {
5282 arg1 = wxString_in_helper(obj0);
5283 if (arg1 == NULL) SWIG_fail;
5284 temp1 = true;
5285 }
5286 {
5287 arg2 = wxString_in_helper(obj1);
5288 if (arg2 == NULL) SWIG_fail;
5289 temp2 = true;
5290 }
5291 {
5292 arg3 = PyList_Size(obj2);
5293 arg4 = wxString_LIST_helper(obj2);
5294 if (arg4 == NULL) SWIG_fail;
5295 }
5296 if (obj3) {
5297 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5298 if (SWIG_arg_fail(5)) SWIG_fail;
5299 }
5300 if (obj4) {
5301 {
5302 arg6 = (int)(SWIG_As_int(obj4));
5303 if (SWIG_arg_fail(6)) SWIG_fail;
5304 }
5305 }
5306 if (obj5) {
5307 {
5308 arg7 = (int)(SWIG_As_int(obj5));
5309 if (SWIG_arg_fail(7)) SWIG_fail;
5310 }
5311 }
5312 if (obj6) {
5313 {
5314 arg8 = (bool)(SWIG_As_bool(obj6));
5315 if (SWIG_arg_fail(8)) SWIG_fail;
5316 }
5317 }
5318 if (obj7) {
5319 {
5320 arg9 = (int)(SWIG_As_int(obj7));
5321 if (SWIG_arg_fail(9)) SWIG_fail;
5322 }
5323 }
5324 if (obj8) {
5325 {
5326 arg10 = (int)(SWIG_As_int(obj8));
5327 if (SWIG_arg_fail(10)) SWIG_fail;
5328 }
5329 }
5330 {
5331 if (!wxPyCheckForApp()) SWIG_fail;
5332 PyThreadState* __tstate = wxPyBeginAllowThreads();
5333 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5334
5335 wxPyEndAllowThreads(__tstate);
5336 if (PyErr_Occurred()) SWIG_fail;
5337 }
5338 {
5339 resultobj = SWIG_From_int((int)(result));
5340 }
5341 {
5342 if (temp1)
5343 delete arg1;
5344 }
5345 {
5346 if (temp2)
5347 delete arg2;
5348 }
5349 {
5350 if (arg4) delete [] arg4;
5351 }
5352 return resultobj;
5353 fail:
5354 {
5355 if (temp1)
5356 delete arg1;
5357 }
5358 {
5359 if (temp2)
5360 delete arg2;
5361 }
5362 {
5363 if (arg4) delete [] arg4;
5364 }
5365 return NULL;
5366 }
5367
5368
5369 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5370 PyObject *resultobj;
5371 wxString *arg1 = 0 ;
5372 wxString const &arg2_defvalue = wxPyEmptyString ;
5373 wxString *arg2 = (wxString *) &arg2_defvalue ;
5374 int arg3 = (int) wxOK|wxCENTRE ;
5375 wxWindow *arg4 = (wxWindow *) NULL ;
5376 int arg5 = (int) -1 ;
5377 int arg6 = (int) -1 ;
5378 int result;
5379 bool temp1 = false ;
5380 bool temp2 = false ;
5381 PyObject * obj0 = 0 ;
5382 PyObject * obj1 = 0 ;
5383 PyObject * obj2 = 0 ;
5384 PyObject * obj3 = 0 ;
5385 PyObject * obj4 = 0 ;
5386 PyObject * obj5 = 0 ;
5387 char *kwnames[] = {
5388 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5389 };
5390
5391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5392 {
5393 arg1 = wxString_in_helper(obj0);
5394 if (arg1 == NULL) SWIG_fail;
5395 temp1 = true;
5396 }
5397 if (obj1) {
5398 {
5399 arg2 = wxString_in_helper(obj1);
5400 if (arg2 == NULL) SWIG_fail;
5401 temp2 = true;
5402 }
5403 }
5404 if (obj2) {
5405 {
5406 arg3 = (int)(SWIG_As_int(obj2));
5407 if (SWIG_arg_fail(3)) SWIG_fail;
5408 }
5409 }
5410 if (obj3) {
5411 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5412 if (SWIG_arg_fail(4)) SWIG_fail;
5413 }
5414 if (obj4) {
5415 {
5416 arg5 = (int)(SWIG_As_int(obj4));
5417 if (SWIG_arg_fail(5)) SWIG_fail;
5418 }
5419 }
5420 if (obj5) {
5421 {
5422 arg6 = (int)(SWIG_As_int(obj5));
5423 if (SWIG_arg_fail(6)) SWIG_fail;
5424 }
5425 }
5426 {
5427 if (!wxPyCheckForApp()) SWIG_fail;
5428 PyThreadState* __tstate = wxPyBeginAllowThreads();
5429 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5430
5431 wxPyEndAllowThreads(__tstate);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 {
5435 resultobj = SWIG_From_int((int)(result));
5436 }
5437 {
5438 if (temp1)
5439 delete arg1;
5440 }
5441 {
5442 if (temp2)
5443 delete arg2;
5444 }
5445 return resultobj;
5446 fail:
5447 {
5448 if (temp1)
5449 delete arg1;
5450 }
5451 {
5452 if (temp2)
5453 delete arg2;
5454 }
5455 return NULL;
5456 }
5457
5458
5459 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5460 PyObject *resultobj;
5461 wxString *arg1 = 0 ;
5462 wxString *arg2 = 0 ;
5463 wxString *arg3 = 0 ;
5464 long arg4 ;
5465 long arg5 = (long) 0 ;
5466 long arg6 = (long) 100 ;
5467 wxWindow *arg7 = (wxWindow *) NULL ;
5468 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5469 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5470 long result;
5471 bool temp1 = false ;
5472 bool temp2 = false ;
5473 bool temp3 = false ;
5474 wxPoint temp8 ;
5475 PyObject * obj0 = 0 ;
5476 PyObject * obj1 = 0 ;
5477 PyObject * obj2 = 0 ;
5478 PyObject * obj3 = 0 ;
5479 PyObject * obj4 = 0 ;
5480 PyObject * obj5 = 0 ;
5481 PyObject * obj6 = 0 ;
5482 PyObject * obj7 = 0 ;
5483 char *kwnames[] = {
5484 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5485 };
5486
5487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5488 {
5489 arg1 = wxString_in_helper(obj0);
5490 if (arg1 == NULL) SWIG_fail;
5491 temp1 = true;
5492 }
5493 {
5494 arg2 = wxString_in_helper(obj1);
5495 if (arg2 == NULL) SWIG_fail;
5496 temp2 = true;
5497 }
5498 {
5499 arg3 = wxString_in_helper(obj2);
5500 if (arg3 == NULL) SWIG_fail;
5501 temp3 = true;
5502 }
5503 {
5504 arg4 = (long)(SWIG_As_long(obj3));
5505 if (SWIG_arg_fail(4)) SWIG_fail;
5506 }
5507 if (obj4) {
5508 {
5509 arg5 = (long)(SWIG_As_long(obj4));
5510 if (SWIG_arg_fail(5)) SWIG_fail;
5511 }
5512 }
5513 if (obj5) {
5514 {
5515 arg6 = (long)(SWIG_As_long(obj5));
5516 if (SWIG_arg_fail(6)) SWIG_fail;
5517 }
5518 }
5519 if (obj6) {
5520 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5521 if (SWIG_arg_fail(7)) SWIG_fail;
5522 }
5523 if (obj7) {
5524 {
5525 arg8 = &temp8;
5526 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5527 }
5528 }
5529 {
5530 if (!wxPyCheckForApp()) SWIG_fail;
5531 PyThreadState* __tstate = wxPyBeginAllowThreads();
5532 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5533
5534 wxPyEndAllowThreads(__tstate);
5535 if (PyErr_Occurred()) SWIG_fail;
5536 }
5537 {
5538 resultobj = SWIG_From_long((long)(result));
5539 }
5540 {
5541 if (temp1)
5542 delete arg1;
5543 }
5544 {
5545 if (temp2)
5546 delete arg2;
5547 }
5548 {
5549 if (temp3)
5550 delete arg3;
5551 }
5552 return resultobj;
5553 fail:
5554 {
5555 if (temp1)
5556 delete arg1;
5557 }
5558 {
5559 if (temp2)
5560 delete arg2;
5561 }
5562 {
5563 if (temp3)
5564 delete arg3;
5565 }
5566 return NULL;
5567 }
5568
5569
5570 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5571 PyObject *resultobj;
5572 bool result;
5573 char *kwnames[] = {
5574 NULL
5575 };
5576
5577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5578 {
5579 if (!wxPyCheckForApp()) SWIG_fail;
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (bool)wxColourDisplay();
5582
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 {
5587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5588 }
5589 return resultobj;
5590 fail:
5591 return NULL;
5592 }
5593
5594
5595 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5596 PyObject *resultobj;
5597 int result;
5598 char *kwnames[] = {
5599 NULL
5600 };
5601
5602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5603 {
5604 if (!wxPyCheckForApp()) SWIG_fail;
5605 PyThreadState* __tstate = wxPyBeginAllowThreads();
5606 result = (int)wxDisplayDepth();
5607
5608 wxPyEndAllowThreads(__tstate);
5609 if (PyErr_Occurred()) SWIG_fail;
5610 }
5611 {
5612 resultobj = SWIG_From_int((int)(result));
5613 }
5614 return resultobj;
5615 fail:
5616 return NULL;
5617 }
5618
5619
5620 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5621 PyObject *resultobj;
5622 int result;
5623 char *kwnames[] = {
5624 NULL
5625 };
5626
5627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5628 {
5629 if (!wxPyCheckForApp()) SWIG_fail;
5630 PyThreadState* __tstate = wxPyBeginAllowThreads();
5631 result = (int)wxGetDisplayDepth();
5632
5633 wxPyEndAllowThreads(__tstate);
5634 if (PyErr_Occurred()) SWIG_fail;
5635 }
5636 {
5637 resultobj = SWIG_From_int((int)(result));
5638 }
5639 return resultobj;
5640 fail:
5641 return NULL;
5642 }
5643
5644
5645 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5646 PyObject *resultobj;
5647 int *arg1 = (int *) 0 ;
5648 int *arg2 = (int *) 0 ;
5649 int temp1 ;
5650 int res1 = 0 ;
5651 int temp2 ;
5652 int res2 = 0 ;
5653 char *kwnames[] = {
5654 NULL
5655 };
5656
5657 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5658 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5660 {
5661 if (!wxPyCheckForApp()) SWIG_fail;
5662 PyThreadState* __tstate = wxPyBeginAllowThreads();
5663 wxDisplaySize(arg1,arg2);
5664
5665 wxPyEndAllowThreads(__tstate);
5666 if (PyErr_Occurred()) SWIG_fail;
5667 }
5668 Py_INCREF(Py_None); resultobj = Py_None;
5669 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5670 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5671 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5672 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5673 return resultobj;
5674 fail:
5675 return NULL;
5676 }
5677
5678
5679 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5680 PyObject *resultobj;
5681 wxSize result;
5682 char *kwnames[] = {
5683 NULL
5684 };
5685
5686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5687 {
5688 if (!wxPyCheckForApp()) SWIG_fail;
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 result = wxGetDisplaySize();
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 {
5696 wxSize * resultptr;
5697 resultptr = new wxSize((wxSize &)(result));
5698 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5699 }
5700 return resultobj;
5701 fail:
5702 return NULL;
5703 }
5704
5705
5706 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5707 PyObject *resultobj;
5708 int *arg1 = (int *) 0 ;
5709 int *arg2 = (int *) 0 ;
5710 int temp1 ;
5711 int res1 = 0 ;
5712 int temp2 ;
5713 int res2 = 0 ;
5714 char *kwnames[] = {
5715 NULL
5716 };
5717
5718 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5719 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5721 {
5722 if (!wxPyCheckForApp()) SWIG_fail;
5723 PyThreadState* __tstate = wxPyBeginAllowThreads();
5724 wxDisplaySizeMM(arg1,arg2);
5725
5726 wxPyEndAllowThreads(__tstate);
5727 if (PyErr_Occurred()) SWIG_fail;
5728 }
5729 Py_INCREF(Py_None); resultobj = Py_None;
5730 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5731 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5732 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5733 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5734 return resultobj;
5735 fail:
5736 return NULL;
5737 }
5738
5739
5740 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5741 PyObject *resultobj;
5742 wxSize result;
5743 char *kwnames[] = {
5744 NULL
5745 };
5746
5747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5748 {
5749 if (!wxPyCheckForApp()) SWIG_fail;
5750 PyThreadState* __tstate = wxPyBeginAllowThreads();
5751 result = wxGetDisplaySizeMM();
5752
5753 wxPyEndAllowThreads(__tstate);
5754 if (PyErr_Occurred()) SWIG_fail;
5755 }
5756 {
5757 wxSize * resultptr;
5758 resultptr = new wxSize((wxSize &)(result));
5759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5760 }
5761 return resultobj;
5762 fail:
5763 return NULL;
5764 }
5765
5766
5767 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5768 PyObject *resultobj;
5769 int *arg1 = (int *) 0 ;
5770 int *arg2 = (int *) 0 ;
5771 int *arg3 = (int *) 0 ;
5772 int *arg4 = (int *) 0 ;
5773 int temp1 ;
5774 int res1 = 0 ;
5775 int temp2 ;
5776 int res2 = 0 ;
5777 int temp3 ;
5778 int res3 = 0 ;
5779 int temp4 ;
5780 int res4 = 0 ;
5781 char *kwnames[] = {
5782 NULL
5783 };
5784
5785 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5786 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5787 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5788 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5790 {
5791 if (!wxPyCheckForApp()) SWIG_fail;
5792 PyThreadState* __tstate = wxPyBeginAllowThreads();
5793 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5794
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 Py_INCREF(Py_None); resultobj = Py_None;
5799 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5800 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5801 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5802 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5803 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5804 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5805 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5806 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5807 return resultobj;
5808 fail:
5809 return NULL;
5810 }
5811
5812
5813 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5814 PyObject *resultobj;
5815 wxRect result;
5816 char *kwnames[] = {
5817 NULL
5818 };
5819
5820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5821 {
5822 if (!wxPyCheckForApp()) SWIG_fail;
5823 PyThreadState* __tstate = wxPyBeginAllowThreads();
5824 result = wxGetClientDisplayRect();
5825
5826 wxPyEndAllowThreads(__tstate);
5827 if (PyErr_Occurred()) SWIG_fail;
5828 }
5829 {
5830 wxRect * resultptr;
5831 resultptr = new wxRect((wxRect &)(result));
5832 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5833 }
5834 return resultobj;
5835 fail:
5836 return NULL;
5837 }
5838
5839
5840 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5841 PyObject *resultobj;
5842 wxCursor *arg1 = 0 ;
5843 PyObject * obj0 = 0 ;
5844 char *kwnames[] = {
5845 (char *) "cursor", NULL
5846 };
5847
5848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5849 {
5850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5851 if (SWIG_arg_fail(1)) SWIG_fail;
5852 if (arg1 == NULL) {
5853 SWIG_null_ref("wxCursor");
5854 }
5855 if (SWIG_arg_fail(1)) SWIG_fail;
5856 }
5857 {
5858 if (!wxPyCheckForApp()) SWIG_fail;
5859 PyThreadState* __tstate = wxPyBeginAllowThreads();
5860 wxSetCursor(*arg1);
5861
5862 wxPyEndAllowThreads(__tstate);
5863 if (PyErr_Occurred()) SWIG_fail;
5864 }
5865 Py_INCREF(Py_None); resultobj = Py_None;
5866 return resultobj;
5867 fail:
5868 return NULL;
5869 }
5870
5871
5872 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5873 PyObject *resultobj;
5874 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5875 PyObject * obj0 = 0 ;
5876 char *kwnames[] = {
5877 (char *) "cursor", NULL
5878 };
5879
5880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5881 if (obj0) {
5882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5883 if (SWIG_arg_fail(1)) SWIG_fail;
5884 }
5885 {
5886 if (!wxPyCheckForApp()) SWIG_fail;
5887 PyThreadState* __tstate = wxPyBeginAllowThreads();
5888 wxBeginBusyCursor(arg1);
5889
5890 wxPyEndAllowThreads(__tstate);
5891 if (PyErr_Occurred()) SWIG_fail;
5892 }
5893 Py_INCREF(Py_None); resultobj = Py_None;
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxWindow *result;
5903 char *kwnames[] = {
5904 NULL
5905 };
5906
5907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5908 {
5909 if (!wxPyCheckForApp()) SWIG_fail;
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 result = (wxWindow *)wxGetActiveWindow();
5912
5913 wxPyEndAllowThreads(__tstate);
5914 if (PyErr_Occurred()) SWIG_fail;
5915 }
5916 {
5917 resultobj = wxPyMake_wxObject(result, 0);
5918 }
5919 return resultobj;
5920 fail:
5921 return NULL;
5922 }
5923
5924
5925 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5926 PyObject *resultobj;
5927 wxPoint *arg1 = 0 ;
5928 wxWindow *result;
5929 wxPoint temp1 ;
5930 PyObject * obj0 = 0 ;
5931 char *kwnames[] = {
5932 (char *) "pt", NULL
5933 };
5934
5935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5936 {
5937 arg1 = &temp1;
5938 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5939 }
5940 {
5941 if (!wxPyCheckForApp()) SWIG_fail;
5942 PyThreadState* __tstate = wxPyBeginAllowThreads();
5943 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5944
5945 wxPyEndAllowThreads(__tstate);
5946 if (PyErr_Occurred()) SWIG_fail;
5947 }
5948 {
5949 resultobj = wxPyMake_wxObject(result, 0);
5950 }
5951 return resultobj;
5952 fail:
5953 return NULL;
5954 }
5955
5956
5957 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5958 PyObject *resultobj;
5959 wxPoint *arg1 = 0 ;
5960 wxWindow *result;
5961 wxPoint temp1 ;
5962 PyObject * obj0 = 0 ;
5963 char *kwnames[] = {
5964 (char *) "pt", NULL
5965 };
5966
5967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5968 {
5969 arg1 = &temp1;
5970 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5971 }
5972 {
5973 if (!wxPyCheckForApp()) SWIG_fail;
5974 PyThreadState* __tstate = wxPyBeginAllowThreads();
5975 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5976
5977 wxPyEndAllowThreads(__tstate);
5978 if (PyErr_Occurred()) SWIG_fail;
5979 }
5980 {
5981 resultobj = wxPyMake_wxObject(result, 0);
5982 }
5983 return resultobj;
5984 fail:
5985 return NULL;
5986 }
5987
5988
5989 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5990 PyObject *resultobj;
5991 wxWindow *arg1 = (wxWindow *) 0 ;
5992 wxWindow *result;
5993 PyObject * obj0 = 0 ;
5994 char *kwnames[] = {
5995 (char *) "win", NULL
5996 };
5997
5998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6000 if (SWIG_arg_fail(1)) SWIG_fail;
6001 {
6002 if (!wxPyCheckForApp()) SWIG_fail;
6003 PyThreadState* __tstate = wxPyBeginAllowThreads();
6004 result = (wxWindow *)wxGetTopLevelParent(arg1);
6005
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 {
6010 resultobj = wxPyMake_wxObject(result, 0);
6011 }
6012 return resultobj;
6013 fail:
6014 return NULL;
6015 }
6016
6017
6018 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6019 PyObject *resultobj;
6020 wxKeyCode arg1 ;
6021 bool result;
6022 PyObject * obj0 = 0 ;
6023 char *kwnames[] = {
6024 (char *) "key", NULL
6025 };
6026
6027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6028 {
6029 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6030 if (SWIG_arg_fail(1)) SWIG_fail;
6031 }
6032 {
6033 if (!wxPyCheckForApp()) SWIG_fail;
6034 PyThreadState* __tstate = wxPyBeginAllowThreads();
6035 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6036
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 {
6041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6042 }
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj;
6051 char *kwnames[] = {
6052 NULL
6053 };
6054
6055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6056 {
6057 if (!wxPyCheckForApp()) SWIG_fail;
6058 PyThreadState* __tstate = wxPyBeginAllowThreads();
6059 wxWakeUpMainThread();
6060
6061 wxPyEndAllowThreads(__tstate);
6062 if (PyErr_Occurred()) SWIG_fail;
6063 }
6064 Py_INCREF(Py_None); resultobj = Py_None;
6065 return resultobj;
6066 fail:
6067 return NULL;
6068 }
6069
6070
6071 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj;
6073 char *kwnames[] = {
6074 NULL
6075 };
6076
6077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6078 {
6079 if (!wxPyCheckForApp()) SWIG_fail;
6080 PyThreadState* __tstate = wxPyBeginAllowThreads();
6081 wxMutexGuiEnter();
6082
6083 wxPyEndAllowThreads(__tstate);
6084 if (PyErr_Occurred()) SWIG_fail;
6085 }
6086 Py_INCREF(Py_None); resultobj = Py_None;
6087 return resultobj;
6088 fail:
6089 return NULL;
6090 }
6091
6092
6093 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6094 PyObject *resultobj;
6095 char *kwnames[] = {
6096 NULL
6097 };
6098
6099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6100 {
6101 if (!wxPyCheckForApp()) SWIG_fail;
6102 PyThreadState* __tstate = wxPyBeginAllowThreads();
6103 wxMutexGuiLeave();
6104
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 Py_INCREF(Py_None); resultobj = Py_None;
6109 return resultobj;
6110 fail:
6111 return NULL;
6112 }
6113
6114
6115 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6116 PyObject *resultobj;
6117 wxMutexGuiLocker *result;
6118 char *kwnames[] = {
6119 NULL
6120 };
6121
6122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6123 {
6124 if (!wxPyCheckForApp()) SWIG_fail;
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6127
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6139 PyObject *resultobj;
6140 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6141 PyObject * obj0 = 0 ;
6142 char *kwnames[] = {
6143 (char *) "self", NULL
6144 };
6145
6146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6148 if (SWIG_arg_fail(1)) SWIG_fail;
6149 {
6150 PyThreadState* __tstate = wxPyBeginAllowThreads();
6151 delete arg1;
6152
6153 wxPyEndAllowThreads(__tstate);
6154 if (PyErr_Occurred()) SWIG_fail;
6155 }
6156 Py_INCREF(Py_None); resultobj = Py_None;
6157 return resultobj;
6158 fail:
6159 return NULL;
6160 }
6161
6162
6163 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6164 PyObject *obj;
6165 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6166 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6167 Py_INCREF(obj);
6168 return Py_BuildValue((char *)"");
6169 }
6170 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6171 PyObject *resultobj;
6172 bool result;
6173 char *kwnames[] = {
6174 NULL
6175 };
6176
6177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6178 {
6179 PyThreadState* __tstate = wxPyBeginAllowThreads();
6180 result = (bool)wxThread_IsMain();
6181
6182 wxPyEndAllowThreads(__tstate);
6183 if (PyErr_Occurred()) SWIG_fail;
6184 }
6185 {
6186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6187 }
6188 return resultobj;
6189 fail:
6190 return NULL;
6191 }
6192
6193
6194 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6195 PyObject *resultobj;
6196 wxString *arg1 = 0 ;
6197 wxToolTip *result;
6198 bool temp1 = false ;
6199 PyObject * obj0 = 0 ;
6200 char *kwnames[] = {
6201 (char *) "tip", NULL
6202 };
6203
6204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6205 {
6206 arg1 = wxString_in_helper(obj0);
6207 if (arg1 == NULL) SWIG_fail;
6208 temp1 = true;
6209 }
6210 {
6211 if (!wxPyCheckForApp()) SWIG_fail;
6212 PyThreadState* __tstate = wxPyBeginAllowThreads();
6213 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6214
6215 wxPyEndAllowThreads(__tstate);
6216 if (PyErr_Occurred()) SWIG_fail;
6217 }
6218 {
6219 resultobj = wxPyMake_wxObject(result, 1);
6220 }
6221 {
6222 if (temp1)
6223 delete arg1;
6224 }
6225 return resultobj;
6226 fail:
6227 {
6228 if (temp1)
6229 delete arg1;
6230 }
6231 return NULL;
6232 }
6233
6234
6235 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6236 PyObject *resultobj;
6237 wxToolTip *arg1 = (wxToolTip *) 0 ;
6238 wxString *arg2 = 0 ;
6239 bool temp2 = false ;
6240 PyObject * obj0 = 0 ;
6241 PyObject * obj1 = 0 ;
6242 char *kwnames[] = {
6243 (char *) "self",(char *) "tip", NULL
6244 };
6245
6246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6248 if (SWIG_arg_fail(1)) SWIG_fail;
6249 {
6250 arg2 = wxString_in_helper(obj1);
6251 if (arg2 == NULL) SWIG_fail;
6252 temp2 = true;
6253 }
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 (arg1)->SetTip((wxString const &)*arg2);
6257
6258 wxPyEndAllowThreads(__tstate);
6259 if (PyErr_Occurred()) SWIG_fail;
6260 }
6261 Py_INCREF(Py_None); resultobj = Py_None;
6262 {
6263 if (temp2)
6264 delete arg2;
6265 }
6266 return resultobj;
6267 fail:
6268 {
6269 if (temp2)
6270 delete arg2;
6271 }
6272 return NULL;
6273 }
6274
6275
6276 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6277 PyObject *resultobj;
6278 wxToolTip *arg1 = (wxToolTip *) 0 ;
6279 wxString result;
6280 PyObject * obj0 = 0 ;
6281 char *kwnames[] = {
6282 (char *) "self", NULL
6283 };
6284
6285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6287 if (SWIG_arg_fail(1)) SWIG_fail;
6288 {
6289 PyThreadState* __tstate = wxPyBeginAllowThreads();
6290 result = (arg1)->GetTip();
6291
6292 wxPyEndAllowThreads(__tstate);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 {
6296 #if wxUSE_UNICODE
6297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6298 #else
6299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6300 #endif
6301 }
6302 return resultobj;
6303 fail:
6304 return NULL;
6305 }
6306
6307
6308 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj;
6310 wxToolTip *arg1 = (wxToolTip *) 0 ;
6311 wxWindow *result;
6312 PyObject * obj0 = 0 ;
6313 char *kwnames[] = {
6314 (char *) "self", NULL
6315 };
6316
6317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6319 if (SWIG_arg_fail(1)) SWIG_fail;
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 result = (wxWindow *)(arg1)->GetWindow();
6323
6324 wxPyEndAllowThreads(__tstate);
6325 if (PyErr_Occurred()) SWIG_fail;
6326 }
6327 {
6328 resultobj = wxPyMake_wxObject(result, 0);
6329 }
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6337 PyObject *resultobj;
6338 bool arg1 ;
6339 PyObject * obj0 = 0 ;
6340 char *kwnames[] = {
6341 (char *) "flag", NULL
6342 };
6343
6344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6345 {
6346 arg1 = (bool)(SWIG_As_bool(obj0));
6347 if (SWIG_arg_fail(1)) SWIG_fail;
6348 }
6349 {
6350 PyThreadState* __tstate = wxPyBeginAllowThreads();
6351 wxToolTip::Enable(arg1);
6352
6353 wxPyEndAllowThreads(__tstate);
6354 if (PyErr_Occurred()) SWIG_fail;
6355 }
6356 Py_INCREF(Py_None); resultobj = Py_None;
6357 return resultobj;
6358 fail:
6359 return NULL;
6360 }
6361
6362
6363 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6364 PyObject *resultobj;
6365 long arg1 ;
6366 PyObject * obj0 = 0 ;
6367 char *kwnames[] = {
6368 (char *) "milliseconds", NULL
6369 };
6370
6371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6372 {
6373 arg1 = (long)(SWIG_As_long(obj0));
6374 if (SWIG_arg_fail(1)) SWIG_fail;
6375 }
6376 {
6377 PyThreadState* __tstate = wxPyBeginAllowThreads();
6378 wxToolTip::SetDelay(arg1);
6379
6380 wxPyEndAllowThreads(__tstate);
6381 if (PyErr_Occurred()) SWIG_fail;
6382 }
6383 Py_INCREF(Py_None); resultobj = Py_None;
6384 return resultobj;
6385 fail:
6386 return NULL;
6387 }
6388
6389
6390 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6391 PyObject *obj;
6392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6393 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6394 Py_INCREF(obj);
6395 return Py_BuildValue((char *)"");
6396 }
6397 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6398 PyObject *resultobj;
6399 wxWindow *arg1 = (wxWindow *) 0 ;
6400 wxSize *arg2 = 0 ;
6401 wxCaret *result;
6402 wxSize temp2 ;
6403 PyObject * obj0 = 0 ;
6404 PyObject * obj1 = 0 ;
6405 char *kwnames[] = {
6406 (char *) "window",(char *) "size", NULL
6407 };
6408
6409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6411 if (SWIG_arg_fail(1)) SWIG_fail;
6412 {
6413 arg2 = &temp2;
6414 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6415 }
6416 {
6417 if (!wxPyCheckForApp()) SWIG_fail;
6418 PyThreadState* __tstate = wxPyBeginAllowThreads();
6419 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6420
6421 wxPyEndAllowThreads(__tstate);
6422 if (PyErr_Occurred()) SWIG_fail;
6423 }
6424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6425 return resultobj;
6426 fail:
6427 return NULL;
6428 }
6429
6430
6431 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6432 PyObject *resultobj;
6433 wxCaret *arg1 = (wxCaret *) 0 ;
6434 PyObject * obj0 = 0 ;
6435 char *kwnames[] = {
6436 (char *) "self", NULL
6437 };
6438
6439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6441 if (SWIG_arg_fail(1)) SWIG_fail;
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 wxCaret_Destroy(arg1);
6445
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 Py_INCREF(Py_None); resultobj = Py_None;
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj;
6458 wxCaret *arg1 = (wxCaret *) 0 ;
6459 bool result;
6460 PyObject * obj0 = 0 ;
6461 char *kwnames[] = {
6462 (char *) "self", NULL
6463 };
6464
6465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6467 if (SWIG_arg_fail(1)) SWIG_fail;
6468 {
6469 PyThreadState* __tstate = wxPyBeginAllowThreads();
6470 result = (bool)(arg1)->IsOk();
6471
6472 wxPyEndAllowThreads(__tstate);
6473 if (PyErr_Occurred()) SWIG_fail;
6474 }
6475 {
6476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6477 }
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6485 PyObject *resultobj;
6486 wxCaret *arg1 = (wxCaret *) 0 ;
6487 bool result;
6488 PyObject * obj0 = 0 ;
6489 char *kwnames[] = {
6490 (char *) "self", NULL
6491 };
6492
6493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6495 if (SWIG_arg_fail(1)) SWIG_fail;
6496 {
6497 PyThreadState* __tstate = wxPyBeginAllowThreads();
6498 result = (bool)(arg1)->IsVisible();
6499
6500 wxPyEndAllowThreads(__tstate);
6501 if (PyErr_Occurred()) SWIG_fail;
6502 }
6503 {
6504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6505 }
6506 return resultobj;
6507 fail:
6508 return NULL;
6509 }
6510
6511
6512 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6513 PyObject *resultobj;
6514 wxCaret *arg1 = (wxCaret *) 0 ;
6515 wxPoint result;
6516 PyObject * obj0 = 0 ;
6517 char *kwnames[] = {
6518 (char *) "self", NULL
6519 };
6520
6521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6523 if (SWIG_arg_fail(1)) SWIG_fail;
6524 {
6525 PyThreadState* __tstate = wxPyBeginAllowThreads();
6526 result = (arg1)->GetPosition();
6527
6528 wxPyEndAllowThreads(__tstate);
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 {
6532 wxPoint * resultptr;
6533 resultptr = new wxPoint((wxPoint &)(result));
6534 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6535 }
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6543 PyObject *resultobj;
6544 wxCaret *arg1 = (wxCaret *) 0 ;
6545 int *arg2 = (int *) 0 ;
6546 int *arg3 = (int *) 0 ;
6547 int temp2 ;
6548 int res2 = 0 ;
6549 int temp3 ;
6550 int res3 = 0 ;
6551 PyObject * obj0 = 0 ;
6552 char *kwnames[] = {
6553 (char *) "self", NULL
6554 };
6555
6556 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6557 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6560 if (SWIG_arg_fail(1)) SWIG_fail;
6561 {
6562 PyThreadState* __tstate = wxPyBeginAllowThreads();
6563 (arg1)->GetPosition(arg2,arg3);
6564
6565 wxPyEndAllowThreads(__tstate);
6566 if (PyErr_Occurred()) SWIG_fail;
6567 }
6568 Py_INCREF(Py_None); resultobj = Py_None;
6569 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6570 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6571 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6572 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6573 return resultobj;
6574 fail:
6575 return NULL;
6576 }
6577
6578
6579 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6580 PyObject *resultobj;
6581 wxCaret *arg1 = (wxCaret *) 0 ;
6582 wxSize result;
6583 PyObject * obj0 = 0 ;
6584 char *kwnames[] = {
6585 (char *) "self", NULL
6586 };
6587
6588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6590 if (SWIG_arg_fail(1)) SWIG_fail;
6591 {
6592 PyThreadState* __tstate = wxPyBeginAllowThreads();
6593 result = (arg1)->GetSize();
6594
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 {
6599 wxSize * resultptr;
6600 resultptr = new wxSize((wxSize &)(result));
6601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6602 }
6603 return resultobj;
6604 fail:
6605 return NULL;
6606 }
6607
6608
6609 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6610 PyObject *resultobj;
6611 wxCaret *arg1 = (wxCaret *) 0 ;
6612 int *arg2 = (int *) 0 ;
6613 int *arg3 = (int *) 0 ;
6614 int temp2 ;
6615 int res2 = 0 ;
6616 int temp3 ;
6617 int res3 = 0 ;
6618 PyObject * obj0 = 0 ;
6619 char *kwnames[] = {
6620 (char *) "self", NULL
6621 };
6622
6623 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6624 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6627 if (SWIG_arg_fail(1)) SWIG_fail;
6628 {
6629 PyThreadState* __tstate = wxPyBeginAllowThreads();
6630 (arg1)->GetSize(arg2,arg3);
6631
6632 wxPyEndAllowThreads(__tstate);
6633 if (PyErr_Occurred()) SWIG_fail;
6634 }
6635 Py_INCREF(Py_None); resultobj = Py_None;
6636 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6637 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6638 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6639 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6640 return resultobj;
6641 fail:
6642 return NULL;
6643 }
6644
6645
6646 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6647 PyObject *resultobj;
6648 wxCaret *arg1 = (wxCaret *) 0 ;
6649 wxWindow *result;
6650 PyObject * obj0 = 0 ;
6651 char *kwnames[] = {
6652 (char *) "self", NULL
6653 };
6654
6655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6657 if (SWIG_arg_fail(1)) SWIG_fail;
6658 {
6659 PyThreadState* __tstate = wxPyBeginAllowThreads();
6660 result = (wxWindow *)(arg1)->GetWindow();
6661
6662 wxPyEndAllowThreads(__tstate);
6663 if (PyErr_Occurred()) SWIG_fail;
6664 }
6665 {
6666 resultobj = wxPyMake_wxObject(result, 0);
6667 }
6668 return resultobj;
6669 fail:
6670 return NULL;
6671 }
6672
6673
6674 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6675 PyObject *resultobj;
6676 wxCaret *arg1 = (wxCaret *) 0 ;
6677 int arg2 ;
6678 int arg3 ;
6679 PyObject * obj0 = 0 ;
6680 PyObject * obj1 = 0 ;
6681 PyObject * obj2 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self",(char *) "x",(char *) "y", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 arg2 = (int)(SWIG_As_int(obj1));
6691 if (SWIG_arg_fail(2)) SWIG_fail;
6692 }
6693 {
6694 arg3 = (int)(SWIG_As_int(obj2));
6695 if (SWIG_arg_fail(3)) SWIG_fail;
6696 }
6697 {
6698 PyThreadState* __tstate = wxPyBeginAllowThreads();
6699 (arg1)->Move(arg2,arg3);
6700
6701 wxPyEndAllowThreads(__tstate);
6702 if (PyErr_Occurred()) SWIG_fail;
6703 }
6704 Py_INCREF(Py_None); resultobj = Py_None;
6705 return resultobj;
6706 fail:
6707 return NULL;
6708 }
6709
6710
6711 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6712 PyObject *resultobj;
6713 wxCaret *arg1 = (wxCaret *) 0 ;
6714 wxPoint *arg2 = 0 ;
6715 wxPoint temp2 ;
6716 PyObject * obj0 = 0 ;
6717 PyObject * obj1 = 0 ;
6718 char *kwnames[] = {
6719 (char *) "self",(char *) "pt", NULL
6720 };
6721
6722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6724 if (SWIG_arg_fail(1)) SWIG_fail;
6725 {
6726 arg2 = &temp2;
6727 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6728 }
6729 {
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 (arg1)->Move((wxPoint const &)*arg2);
6732
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 Py_INCREF(Py_None); resultobj = Py_None;
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj;
6745 wxCaret *arg1 = (wxCaret *) 0 ;
6746 int arg2 ;
6747 int arg3 ;
6748 PyObject * obj0 = 0 ;
6749 PyObject * obj1 = 0 ;
6750 PyObject * obj2 = 0 ;
6751 char *kwnames[] = {
6752 (char *) "self",(char *) "width",(char *) "height", NULL
6753 };
6754
6755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6757 if (SWIG_arg_fail(1)) SWIG_fail;
6758 {
6759 arg2 = (int)(SWIG_As_int(obj1));
6760 if (SWIG_arg_fail(2)) SWIG_fail;
6761 }
6762 {
6763 arg3 = (int)(SWIG_As_int(obj2));
6764 if (SWIG_arg_fail(3)) SWIG_fail;
6765 }
6766 {
6767 PyThreadState* __tstate = wxPyBeginAllowThreads();
6768 (arg1)->SetSize(arg2,arg3);
6769
6770 wxPyEndAllowThreads(__tstate);
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 Py_INCREF(Py_None); resultobj = Py_None;
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6781 PyObject *resultobj;
6782 wxCaret *arg1 = (wxCaret *) 0 ;
6783 wxSize *arg2 = 0 ;
6784 wxSize temp2 ;
6785 PyObject * obj0 = 0 ;
6786 PyObject * obj1 = 0 ;
6787 char *kwnames[] = {
6788 (char *) "self",(char *) "size", NULL
6789 };
6790
6791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6793 if (SWIG_arg_fail(1)) SWIG_fail;
6794 {
6795 arg2 = &temp2;
6796 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6797 }
6798 {
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 (arg1)->SetSize((wxSize const &)*arg2);
6801
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 Py_INCREF(Py_None); resultobj = Py_None;
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6813 PyObject *resultobj;
6814 wxCaret *arg1 = (wxCaret *) 0 ;
6815 int arg2 = (int) true ;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 char *kwnames[] = {
6819 (char *) "self",(char *) "show", NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6824 if (SWIG_arg_fail(1)) SWIG_fail;
6825 if (obj1) {
6826 {
6827 arg2 = (int)(SWIG_As_int(obj1));
6828 if (SWIG_arg_fail(2)) SWIG_fail;
6829 }
6830 }
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 (arg1)->Show(arg2);
6834
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 Py_INCREF(Py_None); resultobj = Py_None;
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj;
6847 wxCaret *arg1 = (wxCaret *) 0 ;
6848 PyObject * obj0 = 0 ;
6849 char *kwnames[] = {
6850 (char *) "self", NULL
6851 };
6852
6853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6855 if (SWIG_arg_fail(1)) SWIG_fail;
6856 {
6857 PyThreadState* __tstate = wxPyBeginAllowThreads();
6858 (arg1)->Hide();
6859
6860 wxPyEndAllowThreads(__tstate);
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 Py_INCREF(Py_None); resultobj = Py_None;
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6871 PyObject *resultobj;
6872 int result;
6873 char *kwnames[] = {
6874 NULL
6875 };
6876
6877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6878 {
6879 PyThreadState* __tstate = wxPyBeginAllowThreads();
6880 result = (int)wxCaret::GetBlinkTime();
6881
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 {
6886 resultobj = SWIG_From_int((int)(result));
6887 }
6888 return resultobj;
6889 fail:
6890 return NULL;
6891 }
6892
6893
6894 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6895 PyObject *resultobj;
6896 int arg1 ;
6897 PyObject * obj0 = 0 ;
6898 char *kwnames[] = {
6899 (char *) "milliseconds", NULL
6900 };
6901
6902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6903 {
6904 arg1 = (int)(SWIG_As_int(obj0));
6905 if (SWIG_arg_fail(1)) SWIG_fail;
6906 }
6907 {
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 wxCaret::SetBlinkTime(arg1);
6910
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 Py_INCREF(Py_None); resultobj = Py_None;
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6922 PyObject *obj;
6923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6924 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6925 Py_INCREF(obj);
6926 return Py_BuildValue((char *)"");
6927 }
6928 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6929 PyObject *resultobj;
6930 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6931 wxBusyCursor *result;
6932 PyObject * obj0 = 0 ;
6933 char *kwnames[] = {
6934 (char *) "cursor", NULL
6935 };
6936
6937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6938 if (obj0) {
6939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6940 if (SWIG_arg_fail(1)) SWIG_fail;
6941 }
6942 {
6943 if (!wxPyCheckForApp()) SWIG_fail;
6944 PyThreadState* __tstate = wxPyBeginAllowThreads();
6945 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6946
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6951 return resultobj;
6952 fail:
6953 return NULL;
6954 }
6955
6956
6957 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6958 PyObject *resultobj;
6959 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6960 PyObject * obj0 = 0 ;
6961 char *kwnames[] = {
6962 (char *) "self", NULL
6963 };
6964
6965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6967 if (SWIG_arg_fail(1)) SWIG_fail;
6968 {
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 delete arg1;
6971
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 Py_INCREF(Py_None); resultobj = Py_None;
6976 return resultobj;
6977 fail:
6978 return NULL;
6979 }
6980
6981
6982 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6983 PyObject *obj;
6984 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6985 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6986 Py_INCREF(obj);
6987 return Py_BuildValue((char *)"");
6988 }
6989 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6990 PyObject *resultobj;
6991 wxWindow *arg1 = (wxWindow *) NULL ;
6992 wxWindowDisabler *result;
6993 PyObject * obj0 = 0 ;
6994 char *kwnames[] = {
6995 (char *) "winToSkip", NULL
6996 };
6997
6998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6999 if (obj0) {
7000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7001 if (SWIG_arg_fail(1)) SWIG_fail;
7002 }
7003 {
7004 if (!wxPyCheckForApp()) SWIG_fail;
7005 PyThreadState* __tstate = wxPyBeginAllowThreads();
7006 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7007
7008 wxPyEndAllowThreads(__tstate);
7009 if (PyErr_Occurred()) SWIG_fail;
7010 }
7011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7012 return resultobj;
7013 fail:
7014 return NULL;
7015 }
7016
7017
7018 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7019 PyObject *resultobj;
7020 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7021 PyObject * obj0 = 0 ;
7022 char *kwnames[] = {
7023 (char *) "self", NULL
7024 };
7025
7026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7028 if (SWIG_arg_fail(1)) SWIG_fail;
7029 {
7030 PyThreadState* __tstate = wxPyBeginAllowThreads();
7031 delete arg1;
7032
7033 wxPyEndAllowThreads(__tstate);
7034 if (PyErr_Occurred()) SWIG_fail;
7035 }
7036 Py_INCREF(Py_None); resultobj = Py_None;
7037 return resultobj;
7038 fail:
7039 return NULL;
7040 }
7041
7042
7043 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7044 PyObject *obj;
7045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7046 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7047 Py_INCREF(obj);
7048 return Py_BuildValue((char *)"");
7049 }
7050 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7051 PyObject *resultobj;
7052 wxString *arg1 = 0 ;
7053 wxBusyInfo *result;
7054 bool temp1 = false ;
7055 PyObject * obj0 = 0 ;
7056 char *kwnames[] = {
7057 (char *) "message", NULL
7058 };
7059
7060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7061 {
7062 arg1 = wxString_in_helper(obj0);
7063 if (arg1 == NULL) SWIG_fail;
7064 temp1 = true;
7065 }
7066 {
7067 if (!wxPyCheckForApp()) SWIG_fail;
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7070
7071 wxPyEndAllowThreads(__tstate);
7072 if (PyErr_Occurred()) SWIG_fail;
7073 }
7074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7075 {
7076 if (temp1)
7077 delete arg1;
7078 }
7079 return resultobj;
7080 fail:
7081 {
7082 if (temp1)
7083 delete arg1;
7084 }
7085 return NULL;
7086 }
7087
7088
7089 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj;
7091 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7092 PyObject * obj0 = 0 ;
7093 char *kwnames[] = {
7094 (char *) "self", NULL
7095 };
7096
7097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7099 if (SWIG_arg_fail(1)) SWIG_fail;
7100 {
7101 PyThreadState* __tstate = wxPyBeginAllowThreads();
7102 delete arg1;
7103
7104 wxPyEndAllowThreads(__tstate);
7105 if (PyErr_Occurred()) SWIG_fail;
7106 }
7107 Py_INCREF(Py_None); resultobj = Py_None;
7108 return resultobj;
7109 fail:
7110 return NULL;
7111 }
7112
7113
7114 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7115 PyObject *obj;
7116 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7117 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7118 Py_INCREF(obj);
7119 return Py_BuildValue((char *)"");
7120 }
7121 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj;
7123 wxStopWatch *result;
7124 char *kwnames[] = {
7125 NULL
7126 };
7127
7128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7129 {
7130 PyThreadState* __tstate = wxPyBeginAllowThreads();
7131 result = (wxStopWatch *)new wxStopWatch();
7132
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj;
7145 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7146 long arg2 = (long) 0 ;
7147 PyObject * obj0 = 0 ;
7148 PyObject * obj1 = 0 ;
7149 char *kwnames[] = {
7150 (char *) "self",(char *) "t0", NULL
7151 };
7152
7153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7155 if (SWIG_arg_fail(1)) SWIG_fail;
7156 if (obj1) {
7157 {
7158 arg2 = (long)(SWIG_As_long(obj1));
7159 if (SWIG_arg_fail(2)) SWIG_fail;
7160 }
7161 }
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 (arg1)->Start(arg2);
7165
7166 wxPyEndAllowThreads(__tstate);
7167 if (PyErr_Occurred()) SWIG_fail;
7168 }
7169 Py_INCREF(Py_None); resultobj = Py_None;
7170 return resultobj;
7171 fail:
7172 return NULL;
7173 }
7174
7175
7176 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7177 PyObject *resultobj;
7178 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7179 PyObject * obj0 = 0 ;
7180 char *kwnames[] = {
7181 (char *) "self", NULL
7182 };
7183
7184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7186 if (SWIG_arg_fail(1)) SWIG_fail;
7187 {
7188 PyThreadState* __tstate = wxPyBeginAllowThreads();
7189 (arg1)->Pause();
7190
7191 wxPyEndAllowThreads(__tstate);
7192 if (PyErr_Occurred()) SWIG_fail;
7193 }
7194 Py_INCREF(Py_None); resultobj = Py_None;
7195 return resultobj;
7196 fail:
7197 return NULL;
7198 }
7199
7200
7201 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7202 PyObject *resultobj;
7203 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7204 PyObject * obj0 = 0 ;
7205 char *kwnames[] = {
7206 (char *) "self", NULL
7207 };
7208
7209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7211 if (SWIG_arg_fail(1)) SWIG_fail;
7212 {
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 (arg1)->Resume();
7215
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 Py_INCREF(Py_None); resultobj = Py_None;
7220 return resultobj;
7221 fail:
7222 return NULL;
7223 }
7224
7225
7226 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7227 PyObject *resultobj;
7228 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7229 long result;
7230 PyObject * obj0 = 0 ;
7231 char *kwnames[] = {
7232 (char *) "self", NULL
7233 };
7234
7235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7237 if (SWIG_arg_fail(1)) SWIG_fail;
7238 {
7239 PyThreadState* __tstate = wxPyBeginAllowThreads();
7240 result = (long)((wxStopWatch const *)arg1)->Time();
7241
7242 wxPyEndAllowThreads(__tstate);
7243 if (PyErr_Occurred()) SWIG_fail;
7244 }
7245 {
7246 resultobj = SWIG_From_long((long)(result));
7247 }
7248 return resultobj;
7249 fail:
7250 return NULL;
7251 }
7252
7253
7254 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7255 PyObject *obj;
7256 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7257 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7258 Py_INCREF(obj);
7259 return Py_BuildValue((char *)"");
7260 }
7261 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj;
7263 int arg1 = (int) 9 ;
7264 int arg2 = (int) wxID_FILE1 ;
7265 wxFileHistory *result;
7266 PyObject * obj0 = 0 ;
7267 PyObject * obj1 = 0 ;
7268 char *kwnames[] = {
7269 (char *) "maxFiles",(char *) "idBase", NULL
7270 };
7271
7272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7273 if (obj0) {
7274 {
7275 arg1 = (int)(SWIG_As_int(obj0));
7276 if (SWIG_arg_fail(1)) SWIG_fail;
7277 }
7278 }
7279 if (obj1) {
7280 {
7281 arg2 = (int)(SWIG_As_int(obj1));
7282 if (SWIG_arg_fail(2)) SWIG_fail;
7283 }
7284 }
7285 {
7286 PyThreadState* __tstate = wxPyBeginAllowThreads();
7287 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7288
7289 wxPyEndAllowThreads(__tstate);
7290 if (PyErr_Occurred()) SWIG_fail;
7291 }
7292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7293 return resultobj;
7294 fail:
7295 return NULL;
7296 }
7297
7298
7299 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj;
7301 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7302 PyObject * obj0 = 0 ;
7303 char *kwnames[] = {
7304 (char *) "self", NULL
7305 };
7306
7307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7309 if (SWIG_arg_fail(1)) SWIG_fail;
7310 {
7311 PyThreadState* __tstate = wxPyBeginAllowThreads();
7312 delete arg1;
7313
7314 wxPyEndAllowThreads(__tstate);
7315 if (PyErr_Occurred()) SWIG_fail;
7316 }
7317 Py_INCREF(Py_None); resultobj = Py_None;
7318 return resultobj;
7319 fail:
7320 return NULL;
7321 }
7322
7323
7324 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7325 PyObject *resultobj;
7326 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7327 wxString *arg2 = 0 ;
7328 bool temp2 = false ;
7329 PyObject * obj0 = 0 ;
7330 PyObject * obj1 = 0 ;
7331 char *kwnames[] = {
7332 (char *) "self",(char *) "file", NULL
7333 };
7334
7335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7337 if (SWIG_arg_fail(1)) SWIG_fail;
7338 {
7339 arg2 = wxString_in_helper(obj1);
7340 if (arg2 == NULL) SWIG_fail;
7341 temp2 = true;
7342 }
7343 {
7344 PyThreadState* __tstate = wxPyBeginAllowThreads();
7345 (arg1)->AddFileToHistory((wxString const &)*arg2);
7346
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 Py_INCREF(Py_None); resultobj = Py_None;
7351 {
7352 if (temp2)
7353 delete arg2;
7354 }
7355 return resultobj;
7356 fail:
7357 {
7358 if (temp2)
7359 delete arg2;
7360 }
7361 return NULL;
7362 }
7363
7364
7365 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7366 PyObject *resultobj;
7367 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7368 int arg2 ;
7369 PyObject * obj0 = 0 ;
7370 PyObject * obj1 = 0 ;
7371 char *kwnames[] = {
7372 (char *) "self",(char *) "i", NULL
7373 };
7374
7375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7377 if (SWIG_arg_fail(1)) SWIG_fail;
7378 {
7379 arg2 = (int)(SWIG_As_int(obj1));
7380 if (SWIG_arg_fail(2)) SWIG_fail;
7381 }
7382 {
7383 PyThreadState* __tstate = wxPyBeginAllowThreads();
7384 (arg1)->RemoveFileFromHistory(arg2);
7385
7386 wxPyEndAllowThreads(__tstate);
7387 if (PyErr_Occurred()) SWIG_fail;
7388 }
7389 Py_INCREF(Py_None); resultobj = Py_None;
7390 return resultobj;
7391 fail:
7392 return NULL;
7393 }
7394
7395
7396 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7397 PyObject *resultobj;
7398 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7399 int result;
7400 PyObject * obj0 = 0 ;
7401 char *kwnames[] = {
7402 (char *) "self", NULL
7403 };
7404
7405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7407 if (SWIG_arg_fail(1)) SWIG_fail;
7408 {
7409 PyThreadState* __tstate = wxPyBeginAllowThreads();
7410 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7411
7412 wxPyEndAllowThreads(__tstate);
7413 if (PyErr_Occurred()) SWIG_fail;
7414 }
7415 {
7416 resultobj = SWIG_From_int((int)(result));
7417 }
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj;
7426 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7427 wxMenu *arg2 = (wxMenu *) 0 ;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 char *kwnames[] = {
7431 (char *) "self",(char *) "menu", NULL
7432 };
7433
7434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7436 if (SWIG_arg_fail(1)) SWIG_fail;
7437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7438 if (SWIG_arg_fail(2)) SWIG_fail;
7439 {
7440 PyThreadState* __tstate = wxPyBeginAllowThreads();
7441 (arg1)->UseMenu(arg2);
7442
7443 wxPyEndAllowThreads(__tstate);
7444 if (PyErr_Occurred()) SWIG_fail;
7445 }
7446 Py_INCREF(Py_None); resultobj = Py_None;
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj;
7455 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7456 wxMenu *arg2 = (wxMenu *) 0 ;
7457 PyObject * obj0 = 0 ;
7458 PyObject * obj1 = 0 ;
7459 char *kwnames[] = {
7460 (char *) "self",(char *) "menu", NULL
7461 };
7462
7463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7465 if (SWIG_arg_fail(1)) SWIG_fail;
7466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7467 if (SWIG_arg_fail(2)) SWIG_fail;
7468 {
7469 PyThreadState* __tstate = wxPyBeginAllowThreads();
7470 (arg1)->RemoveMenu(arg2);
7471
7472 wxPyEndAllowThreads(__tstate);
7473 if (PyErr_Occurred()) SWIG_fail;
7474 }
7475 Py_INCREF(Py_None); resultobj = Py_None;
7476 return resultobj;
7477 fail:
7478 return NULL;
7479 }
7480
7481
7482 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7483 PyObject *resultobj;
7484 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7485 wxConfigBase *arg2 = 0 ;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 char *kwnames[] = {
7489 (char *) "self",(char *) "config", NULL
7490 };
7491
7492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7494 if (SWIG_arg_fail(1)) SWIG_fail;
7495 {
7496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7497 if (SWIG_arg_fail(2)) SWIG_fail;
7498 if (arg2 == NULL) {
7499 SWIG_null_ref("wxConfigBase");
7500 }
7501 if (SWIG_arg_fail(2)) SWIG_fail;
7502 }
7503 {
7504 PyThreadState* __tstate = wxPyBeginAllowThreads();
7505 (arg1)->Load(*arg2);
7506
7507 wxPyEndAllowThreads(__tstate);
7508 if (PyErr_Occurred()) SWIG_fail;
7509 }
7510 Py_INCREF(Py_None); resultobj = Py_None;
7511 return resultobj;
7512 fail:
7513 return NULL;
7514 }
7515
7516
7517 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7518 PyObject *resultobj;
7519 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7520 wxConfigBase *arg2 = 0 ;
7521 PyObject * obj0 = 0 ;
7522 PyObject * obj1 = 0 ;
7523 char *kwnames[] = {
7524 (char *) "self",(char *) "config", NULL
7525 };
7526
7527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7529 if (SWIG_arg_fail(1)) SWIG_fail;
7530 {
7531 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7532 if (SWIG_arg_fail(2)) SWIG_fail;
7533 if (arg2 == NULL) {
7534 SWIG_null_ref("wxConfigBase");
7535 }
7536 if (SWIG_arg_fail(2)) SWIG_fail;
7537 }
7538 {
7539 PyThreadState* __tstate = wxPyBeginAllowThreads();
7540 (arg1)->Save(*arg2);
7541
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 Py_INCREF(Py_None); resultobj = Py_None;
7546 return resultobj;
7547 fail:
7548 return NULL;
7549 }
7550
7551
7552 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7553 PyObject *resultobj;
7554 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7555 PyObject * obj0 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 {
7564 PyThreadState* __tstate = wxPyBeginAllowThreads();
7565 (arg1)->AddFilesToMenu();
7566
7567 wxPyEndAllowThreads(__tstate);
7568 if (PyErr_Occurred()) SWIG_fail;
7569 }
7570 Py_INCREF(Py_None); resultobj = Py_None;
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7578 PyObject *resultobj;
7579 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7580 wxMenu *arg2 = (wxMenu *) 0 ;
7581 PyObject * obj0 = 0 ;
7582 PyObject * obj1 = 0 ;
7583 char *kwnames[] = {
7584 (char *) "self",(char *) "menu", NULL
7585 };
7586
7587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7589 if (SWIG_arg_fail(1)) SWIG_fail;
7590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7591 if (SWIG_arg_fail(2)) SWIG_fail;
7592 {
7593 PyThreadState* __tstate = wxPyBeginAllowThreads();
7594 (arg1)->AddFilesToMenu(arg2);
7595
7596 wxPyEndAllowThreads(__tstate);
7597 if (PyErr_Occurred()) SWIG_fail;
7598 }
7599 Py_INCREF(Py_None); resultobj = Py_None;
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7607 PyObject *resultobj;
7608 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7609 int arg2 ;
7610 wxString result;
7611 PyObject * obj0 = 0 ;
7612 PyObject * obj1 = 0 ;
7613 char *kwnames[] = {
7614 (char *) "self",(char *) "i", NULL
7615 };
7616
7617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7619 if (SWIG_arg_fail(1)) SWIG_fail;
7620 {
7621 arg2 = (int)(SWIG_As_int(obj1));
7622 if (SWIG_arg_fail(2)) SWIG_fail;
7623 }
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7627
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 {
7632 #if wxUSE_UNICODE
7633 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7634 #else
7635 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7636 #endif
7637 }
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7645 PyObject *resultobj;
7646 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7647 int result;
7648 PyObject * obj0 = 0 ;
7649 char *kwnames[] = {
7650 (char *) "self", NULL
7651 };
7652
7653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7655 if (SWIG_arg_fail(1)) SWIG_fail;
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 result = (int)((wxFileHistory const *)arg1)->GetCount();
7659
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 {
7664 resultobj = SWIG_From_int((int)(result));
7665 }
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7673 PyObject *obj;
7674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7675 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7676 Py_INCREF(obj);
7677 return Py_BuildValue((char *)"");
7678 }
7679 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7680 PyObject *resultobj;
7681 wxString *arg1 = 0 ;
7682 wxString const &arg2_defvalue = wxPyEmptyString ;
7683 wxString *arg2 = (wxString *) &arg2_defvalue ;
7684 wxSingleInstanceChecker *result;
7685 bool temp1 = false ;
7686 bool temp2 = false ;
7687 PyObject * obj0 = 0 ;
7688 PyObject * obj1 = 0 ;
7689 char *kwnames[] = {
7690 (char *) "name",(char *) "path", NULL
7691 };
7692
7693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7694 {
7695 arg1 = wxString_in_helper(obj0);
7696 if (arg1 == NULL) SWIG_fail;
7697 temp1 = true;
7698 }
7699 if (obj1) {
7700 {
7701 arg2 = wxString_in_helper(obj1);
7702 if (arg2 == NULL) SWIG_fail;
7703 temp2 = true;
7704 }
7705 }
7706 {
7707 PyThreadState* __tstate = wxPyBeginAllowThreads();
7708 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7709
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7714 {
7715 if (temp1)
7716 delete arg1;
7717 }
7718 {
7719 if (temp2)
7720 delete arg2;
7721 }
7722 return resultobj;
7723 fail:
7724 {
7725 if (temp1)
7726 delete arg1;
7727 }
7728 {
7729 if (temp2)
7730 delete arg2;
7731 }
7732 return NULL;
7733 }
7734
7735
7736 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7737 PyObject *resultobj;
7738 wxSingleInstanceChecker *result;
7739 char *kwnames[] = {
7740 NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7744 {
7745 PyThreadState* __tstate = wxPyBeginAllowThreads();
7746 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7747
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7759 PyObject *resultobj;
7760 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7761 PyObject * obj0 = 0 ;
7762 char *kwnames[] = {
7763 (char *) "self", NULL
7764 };
7765
7766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7768 if (SWIG_arg_fail(1)) SWIG_fail;
7769 {
7770 PyThreadState* __tstate = wxPyBeginAllowThreads();
7771 delete arg1;
7772
7773 wxPyEndAllowThreads(__tstate);
7774 if (PyErr_Occurred()) SWIG_fail;
7775 }
7776 Py_INCREF(Py_None); resultobj = Py_None;
7777 return resultobj;
7778 fail:
7779 return NULL;
7780 }
7781
7782
7783 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7784 PyObject *resultobj;
7785 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7786 wxString *arg2 = 0 ;
7787 wxString const &arg3_defvalue = wxPyEmptyString ;
7788 wxString *arg3 = (wxString *) &arg3_defvalue ;
7789 bool result;
7790 bool temp2 = false ;
7791 bool temp3 = false ;
7792 PyObject * obj0 = 0 ;
7793 PyObject * obj1 = 0 ;
7794 PyObject * obj2 = 0 ;
7795 char *kwnames[] = {
7796 (char *) "self",(char *) "name",(char *) "path", NULL
7797 };
7798
7799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7801 if (SWIG_arg_fail(1)) SWIG_fail;
7802 {
7803 arg2 = wxString_in_helper(obj1);
7804 if (arg2 == NULL) SWIG_fail;
7805 temp2 = true;
7806 }
7807 if (obj2) {
7808 {
7809 arg3 = wxString_in_helper(obj2);
7810 if (arg3 == NULL) SWIG_fail;
7811 temp3 = true;
7812 }
7813 }
7814 {
7815 PyThreadState* __tstate = wxPyBeginAllowThreads();
7816 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7817
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 {
7822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7823 }
7824 {
7825 if (temp2)
7826 delete arg2;
7827 }
7828 {
7829 if (temp3)
7830 delete arg3;
7831 }
7832 return resultobj;
7833 fail:
7834 {
7835 if (temp2)
7836 delete arg2;
7837 }
7838 {
7839 if (temp3)
7840 delete arg3;
7841 }
7842 return NULL;
7843 }
7844
7845
7846 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj;
7848 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7849 bool result;
7850 PyObject * obj0 = 0 ;
7851 char *kwnames[] = {
7852 (char *) "self", NULL
7853 };
7854
7855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7857 if (SWIG_arg_fail(1)) SWIG_fail;
7858 {
7859 PyThreadState* __tstate = wxPyBeginAllowThreads();
7860 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7861
7862 wxPyEndAllowThreads(__tstate);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 {
7866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7867 }
7868 return resultobj;
7869 fail:
7870 return NULL;
7871 }
7872
7873
7874 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7875 PyObject *obj;
7876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7877 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7878 Py_INCREF(obj);
7879 return Py_BuildValue((char *)"");
7880 }
7881 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7882 PyObject *resultobj;
7883 wxWindow *arg1 = (wxWindow *) 0 ;
7884 wxDC *arg2 = 0 ;
7885 bool result;
7886 PyObject * obj0 = 0 ;
7887 PyObject * obj1 = 0 ;
7888 char *kwnames[] = {
7889 (char *) "window",(char *) "dc", NULL
7890 };
7891
7892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7894 if (SWIG_arg_fail(1)) SWIG_fail;
7895 {
7896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7897 if (SWIG_arg_fail(2)) SWIG_fail;
7898 if (arg2 == NULL) {
7899 SWIG_null_ref("wxDC");
7900 }
7901 if (SWIG_arg_fail(2)) SWIG_fail;
7902 }
7903 {
7904 PyThreadState* __tstate = wxPyBeginAllowThreads();
7905 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7906
7907 wxPyEndAllowThreads(__tstate);
7908 if (PyErr_Occurred()) SWIG_fail;
7909 }
7910 {
7911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7912 }
7913 return resultobj;
7914 fail:
7915 return NULL;
7916 }
7917
7918
7919 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7920 PyObject *resultobj;
7921 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7922 PyObject * obj0 = 0 ;
7923 char *kwnames[] = {
7924 (char *) "self", NULL
7925 };
7926
7927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7929 if (SWIG_arg_fail(1)) SWIG_fail;
7930 {
7931 PyThreadState* __tstate = wxPyBeginAllowThreads();
7932 delete arg1;
7933
7934 wxPyEndAllowThreads(__tstate);
7935 if (PyErr_Occurred()) SWIG_fail;
7936 }
7937 Py_INCREF(Py_None); resultobj = Py_None;
7938 return resultobj;
7939 fail:
7940 return NULL;
7941 }
7942
7943
7944 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7945 PyObject *resultobj;
7946 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7947 wxString result;
7948 PyObject * obj0 = 0 ;
7949 char *kwnames[] = {
7950 (char *) "self", NULL
7951 };
7952
7953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7955 if (SWIG_arg_fail(1)) SWIG_fail;
7956 {
7957 PyThreadState* __tstate = wxPyBeginAllowThreads();
7958 result = (arg1)->GetTip();
7959
7960 wxPyEndAllowThreads(__tstate);
7961 if (PyErr_Occurred()) SWIG_fail;
7962 }
7963 {
7964 #if wxUSE_UNICODE
7965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7966 #else
7967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7968 #endif
7969 }
7970 return resultobj;
7971 fail:
7972 return NULL;
7973 }
7974
7975
7976 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7977 PyObject *resultobj;
7978 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7979 size_t result;
7980 PyObject * obj0 = 0 ;
7981 char *kwnames[] = {
7982 (char *) "self", NULL
7983 };
7984
7985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7987 if (SWIG_arg_fail(1)) SWIG_fail;
7988 {
7989 PyThreadState* __tstate = wxPyBeginAllowThreads();
7990 result = (size_t)(arg1)->GetCurrentTip();
7991
7992 wxPyEndAllowThreads(__tstate);
7993 if (PyErr_Occurred()) SWIG_fail;
7994 }
7995 {
7996 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7997 }
7998 return resultobj;
7999 fail:
8000 return NULL;
8001 }
8002
8003
8004 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8005 PyObject *resultobj;
8006 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8007 wxString *arg2 = 0 ;
8008 wxString result;
8009 bool temp2 = false ;
8010 PyObject * obj0 = 0 ;
8011 PyObject * obj1 = 0 ;
8012 char *kwnames[] = {
8013 (char *) "self",(char *) "tip", NULL
8014 };
8015
8016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8018 if (SWIG_arg_fail(1)) SWIG_fail;
8019 {
8020 arg2 = wxString_in_helper(obj1);
8021 if (arg2 == NULL) SWIG_fail;
8022 temp2 = true;
8023 }
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8027
8028 wxPyEndAllowThreads(__tstate);
8029 if (PyErr_Occurred()) SWIG_fail;
8030 }
8031 {
8032 #if wxUSE_UNICODE
8033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8034 #else
8035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8036 #endif
8037 }
8038 {
8039 if (temp2)
8040 delete arg2;
8041 }
8042 return resultobj;
8043 fail:
8044 {
8045 if (temp2)
8046 delete arg2;
8047 }
8048 return NULL;
8049 }
8050
8051
8052 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8053 PyObject *obj;
8054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8055 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8056 Py_INCREF(obj);
8057 return Py_BuildValue((char *)"");
8058 }
8059 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj;
8061 size_t arg1 ;
8062 wxPyTipProvider *result;
8063 PyObject * obj0 = 0 ;
8064 char *kwnames[] = {
8065 (char *) "currentTip", NULL
8066 };
8067
8068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8069 {
8070 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8071 if (SWIG_arg_fail(1)) SWIG_fail;
8072 }
8073 {
8074 PyThreadState* __tstate = wxPyBeginAllowThreads();
8075 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8076
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8088 PyObject *resultobj;
8089 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8090 PyObject *arg2 = (PyObject *) 0 ;
8091 PyObject *arg3 = (PyObject *) 0 ;
8092 PyObject * obj0 = 0 ;
8093 PyObject * obj1 = 0 ;
8094 PyObject * obj2 = 0 ;
8095 char *kwnames[] = {
8096 (char *) "self",(char *) "self",(char *) "_class", NULL
8097 };
8098
8099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8101 if (SWIG_arg_fail(1)) SWIG_fail;
8102 arg2 = obj1;
8103 arg3 = obj2;
8104 {
8105 PyThreadState* __tstate = wxPyBeginAllowThreads();
8106 (arg1)->_setCallbackInfo(arg2,arg3);
8107
8108 wxPyEndAllowThreads(__tstate);
8109 if (PyErr_Occurred()) SWIG_fail;
8110 }
8111 Py_INCREF(Py_None); resultobj = Py_None;
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8119 PyObject *obj;
8120 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8121 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8122 Py_INCREF(obj);
8123 return Py_BuildValue((char *)"");
8124 }
8125 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8126 PyObject *resultobj;
8127 wxWindow *arg1 = (wxWindow *) 0 ;
8128 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8129 bool arg3 = (bool) true ;
8130 bool result;
8131 PyObject * obj0 = 0 ;
8132 PyObject * obj1 = 0 ;
8133 PyObject * obj2 = 0 ;
8134 char *kwnames[] = {
8135 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8136 };
8137
8138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8140 if (SWIG_arg_fail(1)) SWIG_fail;
8141 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8142 if (SWIG_arg_fail(2)) SWIG_fail;
8143 if (obj2) {
8144 {
8145 arg3 = (bool)(SWIG_As_bool(obj2));
8146 if (SWIG_arg_fail(3)) SWIG_fail;
8147 }
8148 }
8149 {
8150 if (!wxPyCheckForApp()) SWIG_fail;
8151 PyThreadState* __tstate = wxPyBeginAllowThreads();
8152 result = (bool)wxShowTip(arg1,arg2,arg3);
8153
8154 wxPyEndAllowThreads(__tstate);
8155 if (PyErr_Occurred()) SWIG_fail;
8156 }
8157 {
8158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8159 }
8160 return resultobj;
8161 fail:
8162 return NULL;
8163 }
8164
8165
8166 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8167 PyObject *resultobj;
8168 wxString *arg1 = 0 ;
8169 size_t arg2 ;
8170 wxTipProvider *result;
8171 bool temp1 = false ;
8172 PyObject * obj0 = 0 ;
8173 PyObject * obj1 = 0 ;
8174 char *kwnames[] = {
8175 (char *) "filename",(char *) "currentTip", NULL
8176 };
8177
8178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8179 {
8180 arg1 = wxString_in_helper(obj0);
8181 if (arg1 == NULL) SWIG_fail;
8182 temp1 = true;
8183 }
8184 {
8185 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8186 if (SWIG_arg_fail(2)) SWIG_fail;
8187 }
8188 {
8189 if (!wxPyCheckForApp()) SWIG_fail;
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8192
8193 wxPyEndAllowThreads(__tstate);
8194 if (PyErr_Occurred()) SWIG_fail;
8195 }
8196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8197 {
8198 if (temp1)
8199 delete arg1;
8200 }
8201 return resultobj;
8202 fail:
8203 {
8204 if (temp1)
8205 delete arg1;
8206 }
8207 return NULL;
8208 }
8209
8210
8211 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8212 PyObject *resultobj;
8213 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8214 int arg2 = (int) -1 ;
8215 wxPyTimer *result;
8216 PyObject * obj0 = 0 ;
8217 PyObject * obj1 = 0 ;
8218 char *kwnames[] = {
8219 (char *) "owner",(char *) "id", NULL
8220 };
8221
8222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8223 if (obj0) {
8224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8225 if (SWIG_arg_fail(1)) SWIG_fail;
8226 }
8227 if (obj1) {
8228 {
8229 arg2 = (int)(SWIG_As_int(obj1));
8230 if (SWIG_arg_fail(2)) SWIG_fail;
8231 }
8232 }
8233 {
8234 if (!wxPyCheckForApp()) SWIG_fail;
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8237
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj;
8250 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8251 PyObject * obj0 = 0 ;
8252 char *kwnames[] = {
8253 (char *) "self", NULL
8254 };
8255
8256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8258 if (SWIG_arg_fail(1)) SWIG_fail;
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 delete arg1;
8262
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 Py_INCREF(Py_None); resultobj = Py_None;
8267 return resultobj;
8268 fail:
8269 return NULL;
8270 }
8271
8272
8273 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8274 PyObject *resultobj;
8275 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8276 PyObject *arg2 = (PyObject *) 0 ;
8277 PyObject *arg3 = (PyObject *) 0 ;
8278 int arg4 = (int) 1 ;
8279 PyObject * obj0 = 0 ;
8280 PyObject * obj1 = 0 ;
8281 PyObject * obj2 = 0 ;
8282 PyObject * obj3 = 0 ;
8283 char *kwnames[] = {
8284 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8285 };
8286
8287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8289 if (SWIG_arg_fail(1)) SWIG_fail;
8290 arg2 = obj1;
8291 arg3 = obj2;
8292 if (obj3) {
8293 {
8294 arg4 = (int)(SWIG_As_int(obj3));
8295 if (SWIG_arg_fail(4)) SWIG_fail;
8296 }
8297 }
8298 {
8299 PyThreadState* __tstate = wxPyBeginAllowThreads();
8300 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8301
8302 wxPyEndAllowThreads(__tstate);
8303 if (PyErr_Occurred()) SWIG_fail;
8304 }
8305 Py_INCREF(Py_None); resultobj = Py_None;
8306 return resultobj;
8307 fail:
8308 return NULL;
8309 }
8310
8311
8312 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8313 PyObject *resultobj;
8314 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8315 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8316 int arg3 = (int) -1 ;
8317 PyObject * obj0 = 0 ;
8318 PyObject * obj1 = 0 ;
8319 PyObject * obj2 = 0 ;
8320 char *kwnames[] = {
8321 (char *) "self",(char *) "owner",(char *) "id", NULL
8322 };
8323
8324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8326 if (SWIG_arg_fail(1)) SWIG_fail;
8327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8328 if (SWIG_arg_fail(2)) SWIG_fail;
8329 if (obj2) {
8330 {
8331 arg3 = (int)(SWIG_As_int(obj2));
8332 if (SWIG_arg_fail(3)) SWIG_fail;
8333 }
8334 }
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 (arg1)->SetOwner(arg2,arg3);
8338
8339 wxPyEndAllowThreads(__tstate);
8340 if (PyErr_Occurred()) SWIG_fail;
8341 }
8342 Py_INCREF(Py_None); resultobj = Py_None;
8343 return resultobj;
8344 fail:
8345 return NULL;
8346 }
8347
8348
8349 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8350 PyObject *resultobj;
8351 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8352 wxEvtHandler *result;
8353 PyObject * obj0 = 0 ;
8354 char *kwnames[] = {
8355 (char *) "self", NULL
8356 };
8357
8358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8360 if (SWIG_arg_fail(1)) SWIG_fail;
8361 {
8362 PyThreadState* __tstate = wxPyBeginAllowThreads();
8363 result = (wxEvtHandler *)(arg1)->GetOwner();
8364
8365 wxPyEndAllowThreads(__tstate);
8366 if (PyErr_Occurred()) SWIG_fail;
8367 }
8368 {
8369 resultobj = wxPyMake_wxObject(result, 0);
8370 }
8371 return resultobj;
8372 fail:
8373 return NULL;
8374 }
8375
8376
8377 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj;
8379 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8380 int arg2 = (int) -1 ;
8381 bool arg3 = (bool) false ;
8382 bool result;
8383 PyObject * obj0 = 0 ;
8384 PyObject * obj1 = 0 ;
8385 PyObject * obj2 = 0 ;
8386 char *kwnames[] = {
8387 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8388 };
8389
8390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8392 if (SWIG_arg_fail(1)) SWIG_fail;
8393 if (obj1) {
8394 {
8395 arg2 = (int)(SWIG_As_int(obj1));
8396 if (SWIG_arg_fail(2)) SWIG_fail;
8397 }
8398 }
8399 if (obj2) {
8400 {
8401 arg3 = (bool)(SWIG_As_bool(obj2));
8402 if (SWIG_arg_fail(3)) SWIG_fail;
8403 }
8404 }
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 result = (bool)(arg1)->Start(arg2,arg3);
8408
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 {
8413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8414 }
8415 return resultobj;
8416 fail:
8417 return NULL;
8418 }
8419
8420
8421 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8422 PyObject *resultobj;
8423 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8424 PyObject * obj0 = 0 ;
8425 char *kwnames[] = {
8426 (char *) "self", NULL
8427 };
8428
8429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8431 if (SWIG_arg_fail(1)) SWIG_fail;
8432 {
8433 PyThreadState* __tstate = wxPyBeginAllowThreads();
8434 (arg1)->Stop();
8435
8436 wxPyEndAllowThreads(__tstate);
8437 if (PyErr_Occurred()) SWIG_fail;
8438 }
8439 Py_INCREF(Py_None); resultobj = Py_None;
8440 return resultobj;
8441 fail:
8442 return NULL;
8443 }
8444
8445
8446 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8447 PyObject *resultobj;
8448 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8449 bool result;
8450 PyObject * obj0 = 0 ;
8451 char *kwnames[] = {
8452 (char *) "self", NULL
8453 };
8454
8455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8457 if (SWIG_arg_fail(1)) SWIG_fail;
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8461
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 {
8466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8467 }
8468 return resultobj;
8469 fail:
8470 return NULL;
8471 }
8472
8473
8474 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8475 PyObject *resultobj;
8476 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8477 int result;
8478 PyObject * obj0 = 0 ;
8479 char *kwnames[] = {
8480 (char *) "self", NULL
8481 };
8482
8483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8485 if (SWIG_arg_fail(1)) SWIG_fail;
8486 {
8487 PyThreadState* __tstate = wxPyBeginAllowThreads();
8488 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8489
8490 wxPyEndAllowThreads(__tstate);
8491 if (PyErr_Occurred()) SWIG_fail;
8492 }
8493 {
8494 resultobj = SWIG_From_int((int)(result));
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8503 PyObject *resultobj;
8504 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8505 bool result;
8506 PyObject * obj0 = 0 ;
8507 char *kwnames[] = {
8508 (char *) "self", NULL
8509 };
8510
8511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8513 if (SWIG_arg_fail(1)) SWIG_fail;
8514 {
8515 PyThreadState* __tstate = wxPyBeginAllowThreads();
8516 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8517
8518 wxPyEndAllowThreads(__tstate);
8519 if (PyErr_Occurred()) SWIG_fail;
8520 }
8521 {
8522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8523 }
8524 return resultobj;
8525 fail:
8526 return NULL;
8527 }
8528
8529
8530 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8531 PyObject *resultobj;
8532 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8533 int result;
8534 PyObject * obj0 = 0 ;
8535 char *kwnames[] = {
8536 (char *) "self", NULL
8537 };
8538
8539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8541 if (SWIG_arg_fail(1)) SWIG_fail;
8542 {
8543 PyThreadState* __tstate = wxPyBeginAllowThreads();
8544 result = (int)((wxPyTimer const *)arg1)->GetId();
8545
8546 wxPyEndAllowThreads(__tstate);
8547 if (PyErr_Occurred()) SWIG_fail;
8548 }
8549 {
8550 resultobj = SWIG_From_int((int)(result));
8551 }
8552 return resultobj;
8553 fail:
8554 return NULL;
8555 }
8556
8557
8558 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8559 PyObject *obj;
8560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8561 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8562 Py_INCREF(obj);
8563 return Py_BuildValue((char *)"");
8564 }
8565 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8566 PyObject *resultobj;
8567 int arg1 = (int) 0 ;
8568 int arg2 = (int) 0 ;
8569 wxTimerEvent *result;
8570 PyObject * obj0 = 0 ;
8571 PyObject * obj1 = 0 ;
8572 char *kwnames[] = {
8573 (char *) "timerid",(char *) "interval", NULL
8574 };
8575
8576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8577 if (obj0) {
8578 {
8579 arg1 = (int)(SWIG_As_int(obj0));
8580 if (SWIG_arg_fail(1)) SWIG_fail;
8581 }
8582 }
8583 if (obj1) {
8584 {
8585 arg2 = (int)(SWIG_As_int(obj1));
8586 if (SWIG_arg_fail(2)) SWIG_fail;
8587 }
8588 }
8589 {
8590 PyThreadState* __tstate = wxPyBeginAllowThreads();
8591 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8592
8593 wxPyEndAllowThreads(__tstate);
8594 if (PyErr_Occurred()) SWIG_fail;
8595 }
8596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8597 return resultobj;
8598 fail:
8599 return NULL;
8600 }
8601
8602
8603 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8604 PyObject *resultobj;
8605 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8606 int result;
8607 PyObject * obj0 = 0 ;
8608 char *kwnames[] = {
8609 (char *) "self", NULL
8610 };
8611
8612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8614 if (SWIG_arg_fail(1)) SWIG_fail;
8615 {
8616 PyThreadState* __tstate = wxPyBeginAllowThreads();
8617 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8618
8619 wxPyEndAllowThreads(__tstate);
8620 if (PyErr_Occurred()) SWIG_fail;
8621 }
8622 {
8623 resultobj = SWIG_From_int((int)(result));
8624 }
8625 return resultobj;
8626 fail:
8627 return NULL;
8628 }
8629
8630
8631 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8632 PyObject *obj;
8633 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8634 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8635 Py_INCREF(obj);
8636 return Py_BuildValue((char *)"");
8637 }
8638 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8639 PyObject *resultobj;
8640 wxTimer *arg1 = 0 ;
8641 wxTimerRunner *result;
8642 PyObject * obj0 = 0 ;
8643
8644 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8645 {
8646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8647 if (SWIG_arg_fail(1)) SWIG_fail;
8648 if (arg1 == NULL) {
8649 SWIG_null_ref("wxTimer");
8650 }
8651 if (SWIG_arg_fail(1)) SWIG_fail;
8652 }
8653 {
8654 if (!wxPyCheckForApp()) SWIG_fail;
8655 PyThreadState* __tstate = wxPyBeginAllowThreads();
8656 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8657
8658 wxPyEndAllowThreads(__tstate);
8659 if (PyErr_Occurred()) SWIG_fail;
8660 }
8661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8662 return resultobj;
8663 fail:
8664 return NULL;
8665 }
8666
8667
8668 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8669 PyObject *resultobj;
8670 wxTimer *arg1 = 0 ;
8671 int arg2 ;
8672 bool arg3 = (bool) false ;
8673 wxTimerRunner *result;
8674 PyObject * obj0 = 0 ;
8675 PyObject * obj1 = 0 ;
8676 PyObject * obj2 = 0 ;
8677
8678 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8679 {
8680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8681 if (SWIG_arg_fail(1)) SWIG_fail;
8682 if (arg1 == NULL) {
8683 SWIG_null_ref("wxTimer");
8684 }
8685 if (SWIG_arg_fail(1)) SWIG_fail;
8686 }
8687 {
8688 arg2 = (int)(SWIG_As_int(obj1));
8689 if (SWIG_arg_fail(2)) SWIG_fail;
8690 }
8691 if (obj2) {
8692 {
8693 arg3 = (bool)(SWIG_As_bool(obj2));
8694 if (SWIG_arg_fail(3)) SWIG_fail;
8695 }
8696 }
8697 {
8698 if (!wxPyCheckForApp()) SWIG_fail;
8699 PyThreadState* __tstate = wxPyBeginAllowThreads();
8700 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8701
8702 wxPyEndAllowThreads(__tstate);
8703 if (PyErr_Occurred()) SWIG_fail;
8704 }
8705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8706 return resultobj;
8707 fail:
8708 return NULL;
8709 }
8710
8711
8712 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8713 int argc;
8714 PyObject *argv[4];
8715 int ii;
8716
8717 argc = PyObject_Length(args);
8718 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8719 argv[ii] = PyTuple_GetItem(args,ii);
8720 }
8721 if (argc == 1) {
8722 int _v;
8723 {
8724 void *ptr = 0;
8725 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8726 _v = 0;
8727 PyErr_Clear();
8728 } else {
8729 _v = (ptr != 0);
8730 }
8731 }
8732 if (_v) {
8733 return _wrap_new_TimerRunner__SWIG_0(self,args);
8734 }
8735 }
8736 if ((argc >= 2) && (argc <= 3)) {
8737 int _v;
8738 {
8739 void *ptr = 0;
8740 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8741 _v = 0;
8742 PyErr_Clear();
8743 } else {
8744 _v = (ptr != 0);
8745 }
8746 }
8747 if (_v) {
8748 _v = SWIG_Check_int(argv[1]);
8749 if (_v) {
8750 if (argc <= 2) {
8751 return _wrap_new_TimerRunner__SWIG_1(self,args);
8752 }
8753 _v = SWIG_Check_bool(argv[2]);
8754 if (_v) {
8755 return _wrap_new_TimerRunner__SWIG_1(self,args);
8756 }
8757 }
8758 }
8759 }
8760
8761 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8762 return NULL;
8763 }
8764
8765
8766 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8767 PyObject *resultobj;
8768 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8769 PyObject * obj0 = 0 ;
8770 char *kwnames[] = {
8771 (char *) "self", NULL
8772 };
8773
8774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8776 if (SWIG_arg_fail(1)) SWIG_fail;
8777 {
8778 PyThreadState* __tstate = wxPyBeginAllowThreads();
8779 delete arg1;
8780
8781 wxPyEndAllowThreads(__tstate);
8782 if (PyErr_Occurred()) SWIG_fail;
8783 }
8784 Py_INCREF(Py_None); resultobj = Py_None;
8785 return resultobj;
8786 fail:
8787 return NULL;
8788 }
8789
8790
8791 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8792 PyObject *resultobj;
8793 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8794 int arg2 ;
8795 bool arg3 = (bool) false ;
8796 PyObject * obj0 = 0 ;
8797 PyObject * obj1 = 0 ;
8798 PyObject * obj2 = 0 ;
8799 char *kwnames[] = {
8800 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8801 };
8802
8803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8805 if (SWIG_arg_fail(1)) SWIG_fail;
8806 {
8807 arg2 = (int)(SWIG_As_int(obj1));
8808 if (SWIG_arg_fail(2)) SWIG_fail;
8809 }
8810 if (obj2) {
8811 {
8812 arg3 = (bool)(SWIG_As_bool(obj2));
8813 if (SWIG_arg_fail(3)) SWIG_fail;
8814 }
8815 }
8816 {
8817 PyThreadState* __tstate = wxPyBeginAllowThreads();
8818 (arg1)->Start(arg2,arg3);
8819
8820 wxPyEndAllowThreads(__tstate);
8821 if (PyErr_Occurred()) SWIG_fail;
8822 }
8823 Py_INCREF(Py_None); resultobj = Py_None;
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8831 PyObject *obj;
8832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8833 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8834 Py_INCREF(obj);
8835 return Py_BuildValue((char *)"");
8836 }
8837 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8838 PyObject *resultobj;
8839 wxLog *result;
8840 char *kwnames[] = {
8841 NULL
8842 };
8843
8844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8845 {
8846 PyThreadState* __tstate = wxPyBeginAllowThreads();
8847 result = (wxLog *)new wxLog();
8848
8849 wxPyEndAllowThreads(__tstate);
8850 if (PyErr_Occurred()) SWIG_fail;
8851 }
8852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8853 return resultobj;
8854 fail:
8855 return NULL;
8856 }
8857
8858
8859 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8860 PyObject *resultobj;
8861 bool result;
8862 char *kwnames[] = {
8863 NULL
8864 };
8865
8866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8867 {
8868 PyThreadState* __tstate = wxPyBeginAllowThreads();
8869 result = (bool)wxLog::IsEnabled();
8870
8871 wxPyEndAllowThreads(__tstate);
8872 if (PyErr_Occurred()) SWIG_fail;
8873 }
8874 {
8875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8876 }
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8884 PyObject *resultobj;
8885 bool arg1 = (bool) true ;
8886 bool result;
8887 PyObject * obj0 = 0 ;
8888 char *kwnames[] = {
8889 (char *) "doIt", NULL
8890 };
8891
8892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8893 if (obj0) {
8894 {
8895 arg1 = (bool)(SWIG_As_bool(obj0));
8896 if (SWIG_arg_fail(1)) SWIG_fail;
8897 }
8898 }
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 result = (bool)wxLog::EnableLogging(arg1);
8902
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 {
8907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8908 }
8909 return resultobj;
8910 fail:
8911 return NULL;
8912 }
8913
8914
8915 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8916 PyObject *resultobj;
8917 wxLogLevel arg1 ;
8918 wxChar *arg2 = (wxChar *) 0 ;
8919 time_t arg3 ;
8920 PyObject * obj0 = 0 ;
8921 PyObject * obj1 = 0 ;
8922 PyObject * obj2 = 0 ;
8923 char *kwnames[] = {
8924 (char *) "level",(char *) "szString",(char *) "t", NULL
8925 };
8926
8927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8928 {
8929 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8930 if (SWIG_arg_fail(1)) SWIG_fail;
8931 }
8932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8933 if (SWIG_arg_fail(2)) SWIG_fail;
8934 {
8935 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8936 if (SWIG_arg_fail(3)) SWIG_fail;
8937 }
8938 {
8939 PyThreadState* __tstate = wxPyBeginAllowThreads();
8940 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8941
8942 wxPyEndAllowThreads(__tstate);
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 Py_INCREF(Py_None); resultobj = Py_None;
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8953 PyObject *resultobj;
8954 wxLog *arg1 = (wxLog *) 0 ;
8955 PyObject * obj0 = 0 ;
8956 char *kwnames[] = {
8957 (char *) "self", NULL
8958 };
8959
8960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8962 if (SWIG_arg_fail(1)) SWIG_fail;
8963 {
8964 PyThreadState* __tstate = wxPyBeginAllowThreads();
8965 (arg1)->Flush();
8966
8967 wxPyEndAllowThreads(__tstate);
8968 if (PyErr_Occurred()) SWIG_fail;
8969 }
8970 Py_INCREF(Py_None); resultobj = Py_None;
8971 return resultobj;
8972 fail:
8973 return NULL;
8974 }
8975
8976
8977 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8978 PyObject *resultobj;
8979 char *kwnames[] = {
8980 NULL
8981 };
8982
8983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8984 {
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 wxLog::FlushActive();
8987
8988 wxPyEndAllowThreads(__tstate);
8989 if (PyErr_Occurred()) SWIG_fail;
8990 }
8991 Py_INCREF(Py_None); resultobj = Py_None;
8992 return resultobj;
8993 fail:
8994 return NULL;
8995 }
8996
8997
8998 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8999 PyObject *resultobj;
9000 wxLog *result;
9001 char *kwnames[] = {
9002 NULL
9003 };
9004
9005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 result = (wxLog *)wxLog::GetActiveTarget();
9009
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9021 PyObject *resultobj;
9022 wxLog *arg1 = (wxLog *) 0 ;
9023 wxLog *result;
9024 PyObject * obj0 = 0 ;
9025 char *kwnames[] = {
9026 (char *) "pLogger", NULL
9027 };
9028
9029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9031 if (SWIG_arg_fail(1)) SWIG_fail;
9032 {
9033 PyThreadState* __tstate = wxPyBeginAllowThreads();
9034 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9035
9036 wxPyEndAllowThreads(__tstate);
9037 if (PyErr_Occurred()) SWIG_fail;
9038 }
9039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9040 return resultobj;
9041 fail:
9042 return NULL;
9043 }
9044
9045
9046 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj;
9048 char *kwnames[] = {
9049 NULL
9050 };
9051
9052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9053 {
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 wxLog::Suspend();
9056
9057 wxPyEndAllowThreads(__tstate);
9058 if (PyErr_Occurred()) SWIG_fail;
9059 }
9060 Py_INCREF(Py_None); resultobj = Py_None;
9061 return resultobj;
9062 fail:
9063 return NULL;
9064 }
9065
9066
9067 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9068 PyObject *resultobj;
9069 char *kwnames[] = {
9070 NULL
9071 };
9072
9073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 wxLog::Resume();
9077
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 Py_INCREF(Py_None); resultobj = Py_None;
9082 return resultobj;
9083 fail:
9084 return NULL;
9085 }
9086
9087
9088 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9089 PyObject *resultobj;
9090 bool arg1 = (bool) true ;
9091 PyObject * obj0 = 0 ;
9092 char *kwnames[] = {
9093 (char *) "bVerbose", NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9097 if (obj0) {
9098 {
9099 arg1 = (bool)(SWIG_As_bool(obj0));
9100 if (SWIG_arg_fail(1)) SWIG_fail;
9101 }
9102 }
9103 {
9104 PyThreadState* __tstate = wxPyBeginAllowThreads();
9105 wxLog::SetVerbose(arg1);
9106
9107 wxPyEndAllowThreads(__tstate);
9108 if (PyErr_Occurred()) SWIG_fail;
9109 }
9110 Py_INCREF(Py_None); resultobj = Py_None;
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj;
9119 wxLogLevel arg1 ;
9120 PyObject * obj0 = 0 ;
9121 char *kwnames[] = {
9122 (char *) "logLevel", NULL
9123 };
9124
9125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9126 {
9127 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9128 if (SWIG_arg_fail(1)) SWIG_fail;
9129 }
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 wxLog::SetLogLevel(arg1);
9133
9134 wxPyEndAllowThreads(__tstate);
9135 if (PyErr_Occurred()) SWIG_fail;
9136 }
9137 Py_INCREF(Py_None); resultobj = Py_None;
9138 return resultobj;
9139 fail:
9140 return NULL;
9141 }
9142
9143
9144 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9145 PyObject *resultobj;
9146 char *kwnames[] = {
9147 NULL
9148 };
9149
9150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9151 {
9152 PyThreadState* __tstate = wxPyBeginAllowThreads();
9153 wxLog::DontCreateOnDemand();
9154
9155 wxPyEndAllowThreads(__tstate);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 Py_INCREF(Py_None); resultobj = Py_None;
9159 return resultobj;
9160 fail:
9161 return NULL;
9162 }
9163
9164
9165 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9166 PyObject *resultobj;
9167 wxTraceMask arg1 ;
9168 PyObject * obj0 = 0 ;
9169 char *kwnames[] = {
9170 (char *) "ulMask", NULL
9171 };
9172
9173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9174 {
9175 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9176 if (SWIG_arg_fail(1)) SWIG_fail;
9177 }
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 wxLog::SetTraceMask(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_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9193 PyObject *resultobj;
9194 wxString *arg1 = 0 ;
9195 bool temp1 = false ;
9196 PyObject * obj0 = 0 ;
9197 char *kwnames[] = {
9198 (char *) "str", NULL
9199 };
9200
9201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9202 {
9203 arg1 = wxString_in_helper(obj0);
9204 if (arg1 == NULL) SWIG_fail;
9205 temp1 = true;
9206 }
9207 {
9208 PyThreadState* __tstate = wxPyBeginAllowThreads();
9209 wxLog::AddTraceMask((wxString const &)*arg1);
9210
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 Py_INCREF(Py_None); resultobj = Py_None;
9215 {
9216 if (temp1)
9217 delete arg1;
9218 }
9219 return resultobj;
9220 fail:
9221 {
9222 if (temp1)
9223 delete arg1;
9224 }
9225 return NULL;
9226 }
9227
9228
9229 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9230 PyObject *resultobj;
9231 wxString *arg1 = 0 ;
9232 bool temp1 = false ;
9233 PyObject * obj0 = 0 ;
9234 char *kwnames[] = {
9235 (char *) "str", NULL
9236 };
9237
9238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9239 {
9240 arg1 = wxString_in_helper(obj0);
9241 if (arg1 == NULL) SWIG_fail;
9242 temp1 = true;
9243 }
9244 {
9245 PyThreadState* __tstate = wxPyBeginAllowThreads();
9246 wxLog::RemoveTraceMask((wxString const &)*arg1);
9247
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 Py_INCREF(Py_None); resultobj = Py_None;
9252 {
9253 if (temp1)
9254 delete arg1;
9255 }
9256 return resultobj;
9257 fail:
9258 {
9259 if (temp1)
9260 delete arg1;
9261 }
9262 return NULL;
9263 }
9264
9265
9266 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9267 PyObject *resultobj;
9268 char *kwnames[] = {
9269 NULL
9270 };
9271
9272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 wxLog::ClearTraceMasks();
9276
9277 wxPyEndAllowThreads(__tstate);
9278 if (PyErr_Occurred()) SWIG_fail;
9279 }
9280 Py_INCREF(Py_None); resultobj = Py_None;
9281 return resultobj;
9282 fail:
9283 return NULL;
9284 }
9285
9286
9287 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9288 PyObject *resultobj;
9289 wxArrayString *result;
9290 char *kwnames[] = {
9291 NULL
9292 };
9293
9294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9295 {
9296 PyThreadState* __tstate = wxPyBeginAllowThreads();
9297 {
9298 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9299 result = (wxArrayString *) &_result_ref;
9300 }
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 {
9306 resultobj = wxArrayString2PyList_helper(*result);
9307 }
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj;
9316 wxChar *arg1 = (wxChar *) 0 ;
9317 PyObject * obj0 = 0 ;
9318 char *kwnames[] = {
9319 (char *) "ts", NULL
9320 };
9321
9322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9324 if (SWIG_arg_fail(1)) SWIG_fail;
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 wxLog::SetTimestamp((wxChar const *)arg1);
9328
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 Py_INCREF(Py_None); resultobj = Py_None;
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9340 PyObject *resultobj;
9341 bool result;
9342 char *kwnames[] = {
9343 NULL
9344 };
9345
9346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 result = (bool)wxLog::GetVerbose();
9350
9351 wxPyEndAllowThreads(__tstate);
9352 if (PyErr_Occurred()) SWIG_fail;
9353 }
9354 {
9355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9356 }
9357 return resultobj;
9358 fail:
9359 return NULL;
9360 }
9361
9362
9363 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9364 PyObject *resultobj;
9365 wxTraceMask result;
9366 char *kwnames[] = {
9367 NULL
9368 };
9369
9370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 result = (wxTraceMask)wxLog::GetTraceMask();
9374
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 {
9379 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9380 }
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj;
9389 wxChar *arg1 = (wxChar *) 0 ;
9390 bool result;
9391 PyObject * obj0 = 0 ;
9392 char *kwnames[] = {
9393 (char *) "mask", NULL
9394 };
9395
9396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9398 if (SWIG_arg_fail(1)) SWIG_fail;
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9402
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 {
9407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9408 }
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9416 PyObject *resultobj;
9417 wxLogLevel result;
9418 char *kwnames[] = {
9419 NULL
9420 };
9421
9422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9423 {
9424 PyThreadState* __tstate = wxPyBeginAllowThreads();
9425 result = (wxLogLevel)wxLog::GetLogLevel();
9426
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 {
9431 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9432 }
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj;
9441 wxChar *result;
9442 char *kwnames[] = {
9443 NULL
9444 };
9445
9446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9447 {
9448 PyThreadState* __tstate = wxPyBeginAllowThreads();
9449 result = (wxChar *)wxLog::GetTimestamp();
9450
9451 wxPyEndAllowThreads(__tstate);
9452 if (PyErr_Occurred()) SWIG_fail;
9453 }
9454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9455 return resultobj;
9456 fail:
9457 return NULL;
9458 }
9459
9460
9461 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9462 PyObject *resultobj;
9463 wxString result;
9464 char *kwnames[] = {
9465 NULL
9466 };
9467
9468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9469 {
9470 PyThreadState* __tstate = wxPyBeginAllowThreads();
9471 result = Log_TimeStamp();
9472
9473 wxPyEndAllowThreads(__tstate);
9474 if (PyErr_Occurred()) SWIG_fail;
9475 }
9476 {
9477 #if wxUSE_UNICODE
9478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9479 #else
9480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9481 #endif
9482 }
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj;
9491 wxLog *arg1 = (wxLog *) 0 ;
9492 PyObject * obj0 = 0 ;
9493 char *kwnames[] = {
9494 (char *) "self", NULL
9495 };
9496
9497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9499 if (SWIG_arg_fail(1)) SWIG_fail;
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 wxLog_Destroy(arg1);
9503
9504 wxPyEndAllowThreads(__tstate);
9505 if (PyErr_Occurred()) SWIG_fail;
9506 }
9507 Py_INCREF(Py_None); resultobj = Py_None;
9508 return resultobj;
9509 fail:
9510 return NULL;
9511 }
9512
9513
9514 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9515 PyObject *obj;
9516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9517 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9518 Py_INCREF(obj);
9519 return Py_BuildValue((char *)"");
9520 }
9521 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9522 PyObject *resultobj;
9523 wxLogStderr *result;
9524 char *kwnames[] = {
9525 NULL
9526 };
9527
9528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9529 {
9530 PyThreadState* __tstate = wxPyBeginAllowThreads();
9531 result = (wxLogStderr *)new wxLogStderr();
9532
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9537 return resultobj;
9538 fail:
9539 return NULL;
9540 }
9541
9542
9543 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9544 PyObject *obj;
9545 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9546 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9547 Py_INCREF(obj);
9548 return Py_BuildValue((char *)"");
9549 }
9550 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9551 PyObject *resultobj;
9552 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9553 wxLogTextCtrl *result;
9554 PyObject * obj0 = 0 ;
9555 char *kwnames[] = {
9556 (char *) "pTextCtrl", NULL
9557 };
9558
9559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9561 if (SWIG_arg_fail(1)) SWIG_fail;
9562 {
9563 PyThreadState* __tstate = wxPyBeginAllowThreads();
9564 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9565
9566 wxPyEndAllowThreads(__tstate);
9567 if (PyErr_Occurred()) SWIG_fail;
9568 }
9569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9570 return resultobj;
9571 fail:
9572 return NULL;
9573 }
9574
9575
9576 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9577 PyObject *obj;
9578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9579 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9580 Py_INCREF(obj);
9581 return Py_BuildValue((char *)"");
9582 }
9583 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj;
9585 wxLogGui *result;
9586 char *kwnames[] = {
9587 NULL
9588 };
9589
9590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9591 {
9592 PyThreadState* __tstate = wxPyBeginAllowThreads();
9593 result = (wxLogGui *)new wxLogGui();
9594
9595 wxPyEndAllowThreads(__tstate);
9596 if (PyErr_Occurred()) SWIG_fail;
9597 }
9598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9599 return resultobj;
9600 fail:
9601 return NULL;
9602 }
9603
9604
9605 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9606 PyObject *obj;
9607 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9608 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9609 Py_INCREF(obj);
9610 return Py_BuildValue((char *)"");
9611 }
9612 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9613 PyObject *resultobj;
9614 wxFrame *arg1 = (wxFrame *) 0 ;
9615 wxString *arg2 = 0 ;
9616 bool arg3 = (bool) true ;
9617 bool arg4 = (bool) true ;
9618 wxLogWindow *result;
9619 bool temp2 = false ;
9620 PyObject * obj0 = 0 ;
9621 PyObject * obj1 = 0 ;
9622 PyObject * obj2 = 0 ;
9623 PyObject * obj3 = 0 ;
9624 char *kwnames[] = {
9625 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9626 };
9627
9628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9630 if (SWIG_arg_fail(1)) SWIG_fail;
9631 {
9632 arg2 = wxString_in_helper(obj1);
9633 if (arg2 == NULL) SWIG_fail;
9634 temp2 = true;
9635 }
9636 if (obj2) {
9637 {
9638 arg3 = (bool)(SWIG_As_bool(obj2));
9639 if (SWIG_arg_fail(3)) SWIG_fail;
9640 }
9641 }
9642 if (obj3) {
9643 {
9644 arg4 = (bool)(SWIG_As_bool(obj3));
9645 if (SWIG_arg_fail(4)) SWIG_fail;
9646 }
9647 }
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9651
9652 wxPyEndAllowThreads(__tstate);
9653 if (PyErr_Occurred()) SWIG_fail;
9654 }
9655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9656 {
9657 if (temp2)
9658 delete arg2;
9659 }
9660 return resultobj;
9661 fail:
9662 {
9663 if (temp2)
9664 delete arg2;
9665 }
9666 return NULL;
9667 }
9668
9669
9670 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9671 PyObject *resultobj;
9672 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9673 bool arg2 = (bool) true ;
9674 PyObject * obj0 = 0 ;
9675 PyObject * obj1 = 0 ;
9676 char *kwnames[] = {
9677 (char *) "self",(char *) "bShow", NULL
9678 };
9679
9680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9682 if (SWIG_arg_fail(1)) SWIG_fail;
9683 if (obj1) {
9684 {
9685 arg2 = (bool)(SWIG_As_bool(obj1));
9686 if (SWIG_arg_fail(2)) SWIG_fail;
9687 }
9688 }
9689 {
9690 PyThreadState* __tstate = wxPyBeginAllowThreads();
9691 (arg1)->Show(arg2);
9692
9693 wxPyEndAllowThreads(__tstate);
9694 if (PyErr_Occurred()) SWIG_fail;
9695 }
9696 Py_INCREF(Py_None); resultobj = Py_None;
9697 return resultobj;
9698 fail:
9699 return NULL;
9700 }
9701
9702
9703 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9704 PyObject *resultobj;
9705 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9706 wxFrame *result;
9707 PyObject * obj0 = 0 ;
9708 char *kwnames[] = {
9709 (char *) "self", NULL
9710 };
9711
9712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9714 if (SWIG_arg_fail(1)) SWIG_fail;
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9718
9719 wxPyEndAllowThreads(__tstate);
9720 if (PyErr_Occurred()) SWIG_fail;
9721 }
9722 {
9723 resultobj = wxPyMake_wxObject(result, 0);
9724 }
9725 return resultobj;
9726 fail:
9727 return NULL;
9728 }
9729
9730
9731 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj;
9733 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9734 wxLog *result;
9735 PyObject * obj0 = 0 ;
9736 char *kwnames[] = {
9737 (char *) "self", NULL
9738 };
9739
9740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9742 if (SWIG_arg_fail(1)) SWIG_fail;
9743 {
9744 PyThreadState* __tstate = wxPyBeginAllowThreads();
9745 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9746
9747 wxPyEndAllowThreads(__tstate);
9748 if (PyErr_Occurred()) SWIG_fail;
9749 }
9750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9758 PyObject *resultobj;
9759 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9760 bool result;
9761 PyObject * obj0 = 0 ;
9762 char *kwnames[] = {
9763 (char *) "self", NULL
9764 };
9765
9766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9768 if (SWIG_arg_fail(1)) SWIG_fail;
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9772
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 {
9777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9778 }
9779 return resultobj;
9780 fail:
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj;
9787 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9788 bool arg2 ;
9789 PyObject * obj0 = 0 ;
9790 PyObject * obj1 = 0 ;
9791 char *kwnames[] = {
9792 (char *) "self",(char *) "bDoPass", NULL
9793 };
9794
9795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9797 if (SWIG_arg_fail(1)) SWIG_fail;
9798 {
9799 arg2 = (bool)(SWIG_As_bool(obj1));
9800 if (SWIG_arg_fail(2)) SWIG_fail;
9801 }
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 (arg1)->PassMessages(arg2);
9805
9806 wxPyEndAllowThreads(__tstate);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 Py_INCREF(Py_None); resultobj = Py_None;
9810 return resultobj;
9811 fail:
9812 return NULL;
9813 }
9814
9815
9816 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9817 PyObject *obj;
9818 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9819 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9820 Py_INCREF(obj);
9821 return Py_BuildValue((char *)"");
9822 }
9823 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9824 PyObject *resultobj;
9825 wxLog *arg1 = (wxLog *) 0 ;
9826 wxLogChain *result;
9827 PyObject * obj0 = 0 ;
9828 char *kwnames[] = {
9829 (char *) "logger", NULL
9830 };
9831
9832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9834 if (SWIG_arg_fail(1)) SWIG_fail;
9835 {
9836 PyThreadState* __tstate = wxPyBeginAllowThreads();
9837 result = (wxLogChain *)new wxLogChain(arg1);
9838
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9843 return resultobj;
9844 fail:
9845 return NULL;
9846 }
9847
9848
9849 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9850 PyObject *resultobj;
9851 wxLogChain *arg1 = (wxLogChain *) 0 ;
9852 wxLog *arg2 = (wxLog *) 0 ;
9853 PyObject * obj0 = 0 ;
9854 PyObject * obj1 = 0 ;
9855 char *kwnames[] = {
9856 (char *) "self",(char *) "logger", NULL
9857 };
9858
9859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9861 if (SWIG_arg_fail(1)) SWIG_fail;
9862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9863 if (SWIG_arg_fail(2)) SWIG_fail;
9864 {
9865 PyThreadState* __tstate = wxPyBeginAllowThreads();
9866 (arg1)->SetLog(arg2);
9867
9868 wxPyEndAllowThreads(__tstate);
9869 if (PyErr_Occurred()) SWIG_fail;
9870 }
9871 Py_INCREF(Py_None); resultobj = Py_None;
9872 return resultobj;
9873 fail:
9874 return NULL;
9875 }
9876
9877
9878 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9879 PyObject *resultobj;
9880 wxLogChain *arg1 = (wxLogChain *) 0 ;
9881 bool arg2 ;
9882 PyObject * obj0 = 0 ;
9883 PyObject * obj1 = 0 ;
9884 char *kwnames[] = {
9885 (char *) "self",(char *) "bDoPass", NULL
9886 };
9887
9888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9890 if (SWIG_arg_fail(1)) SWIG_fail;
9891 {
9892 arg2 = (bool)(SWIG_As_bool(obj1));
9893 if (SWIG_arg_fail(2)) SWIG_fail;
9894 }
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 (arg1)->PassMessages(arg2);
9898
9899 wxPyEndAllowThreads(__tstate);
9900 if (PyErr_Occurred()) SWIG_fail;
9901 }
9902 Py_INCREF(Py_None); resultobj = Py_None;
9903 return resultobj;
9904 fail:
9905 return NULL;
9906 }
9907
9908
9909 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9910 PyObject *resultobj;
9911 wxLogChain *arg1 = (wxLogChain *) 0 ;
9912 bool result;
9913 PyObject * obj0 = 0 ;
9914 char *kwnames[] = {
9915 (char *) "self", NULL
9916 };
9917
9918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9920 if (SWIG_arg_fail(1)) SWIG_fail;
9921 {
9922 PyThreadState* __tstate = wxPyBeginAllowThreads();
9923 result = (bool)(arg1)->IsPassingMessages();
9924
9925 wxPyEndAllowThreads(__tstate);
9926 if (PyErr_Occurred()) SWIG_fail;
9927 }
9928 {
9929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9930 }
9931 return resultobj;
9932 fail:
9933 return NULL;
9934 }
9935
9936
9937 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj;
9939 wxLogChain *arg1 = (wxLogChain *) 0 ;
9940 wxLog *result;
9941 PyObject * obj0 = 0 ;
9942 char *kwnames[] = {
9943 (char *) "self", NULL
9944 };
9945
9946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9948 if (SWIG_arg_fail(1)) SWIG_fail;
9949 {
9950 PyThreadState* __tstate = wxPyBeginAllowThreads();
9951 result = (wxLog *)(arg1)->GetOldLog();
9952
9953 wxPyEndAllowThreads(__tstate);
9954 if (PyErr_Occurred()) SWIG_fail;
9955 }
9956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9957 return resultobj;
9958 fail:
9959 return NULL;
9960 }
9961
9962
9963 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9964 PyObject *obj;
9965 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9966 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9967 Py_INCREF(obj);
9968 return Py_BuildValue((char *)"");
9969 }
9970 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9971 PyObject *resultobj;
9972 unsigned long result;
9973 char *kwnames[] = {
9974 NULL
9975 };
9976
9977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 result = (unsigned long)wxSysErrorCode();
9981
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 {
9986 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9987 }
9988 return resultobj;
9989 fail:
9990 return NULL;
9991 }
9992
9993
9994 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9995 PyObject *resultobj;
9996 unsigned long arg1 = (unsigned long) 0 ;
9997 wxString result;
9998 PyObject * obj0 = 0 ;
9999 char *kwnames[] = {
10000 (char *) "nErrCode", NULL
10001 };
10002
10003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10004 if (obj0) {
10005 {
10006 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10007 if (SWIG_arg_fail(1)) SWIG_fail;
10008 }
10009 }
10010 {
10011 PyThreadState* __tstate = wxPyBeginAllowThreads();
10012 result = wxSysErrorMsg(arg1);
10013
10014 wxPyEndAllowThreads(__tstate);
10015 if (PyErr_Occurred()) SWIG_fail;
10016 }
10017 {
10018 #if wxUSE_UNICODE
10019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10020 #else
10021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10022 #endif
10023 }
10024 return resultobj;
10025 fail:
10026 return NULL;
10027 }
10028
10029
10030 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10031 PyObject *resultobj;
10032 wxString *arg1 = 0 ;
10033 bool temp1 = false ;
10034 PyObject * obj0 = 0 ;
10035 char *kwnames[] = {
10036 (char *) "msg", NULL
10037 };
10038
10039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10040 {
10041 arg1 = wxString_in_helper(obj0);
10042 if (arg1 == NULL) SWIG_fail;
10043 temp1 = true;
10044 }
10045 {
10046 PyThreadState* __tstate = wxPyBeginAllowThreads();
10047 wxPyLogFatalError((wxString const &)*arg1);
10048
10049 wxPyEndAllowThreads(__tstate);
10050 if (PyErr_Occurred()) SWIG_fail;
10051 }
10052 Py_INCREF(Py_None); resultobj = Py_None;
10053 {
10054 if (temp1)
10055 delete arg1;
10056 }
10057 return resultobj;
10058 fail:
10059 {
10060 if (temp1)
10061 delete arg1;
10062 }
10063 return NULL;
10064 }
10065
10066
10067 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10068 PyObject *resultobj;
10069 wxString *arg1 = 0 ;
10070 bool temp1 = false ;
10071 PyObject * obj0 = 0 ;
10072 char *kwnames[] = {
10073 (char *) "msg", NULL
10074 };
10075
10076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10077 {
10078 arg1 = wxString_in_helper(obj0);
10079 if (arg1 == NULL) SWIG_fail;
10080 temp1 = true;
10081 }
10082 {
10083 PyThreadState* __tstate = wxPyBeginAllowThreads();
10084 wxPyLogError((wxString const &)*arg1);
10085
10086 wxPyEndAllowThreads(__tstate);
10087 if (PyErr_Occurred()) SWIG_fail;
10088 }
10089 Py_INCREF(Py_None); resultobj = Py_None;
10090 {
10091 if (temp1)
10092 delete arg1;
10093 }
10094 return resultobj;
10095 fail:
10096 {
10097 if (temp1)
10098 delete arg1;
10099 }
10100 return NULL;
10101 }
10102
10103
10104 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10105 PyObject *resultobj;
10106 wxString *arg1 = 0 ;
10107 bool temp1 = false ;
10108 PyObject * obj0 = 0 ;
10109 char *kwnames[] = {
10110 (char *) "msg", NULL
10111 };
10112
10113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10114 {
10115 arg1 = wxString_in_helper(obj0);
10116 if (arg1 == NULL) SWIG_fail;
10117 temp1 = true;
10118 }
10119 {
10120 PyThreadState* __tstate = wxPyBeginAllowThreads();
10121 wxPyLogWarning((wxString const &)*arg1);
10122
10123 wxPyEndAllowThreads(__tstate);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 Py_INCREF(Py_None); resultobj = Py_None;
10127 {
10128 if (temp1)
10129 delete arg1;
10130 }
10131 return resultobj;
10132 fail:
10133 {
10134 if (temp1)
10135 delete arg1;
10136 }
10137 return NULL;
10138 }
10139
10140
10141 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10142 PyObject *resultobj;
10143 wxString *arg1 = 0 ;
10144 bool temp1 = false ;
10145 PyObject * obj0 = 0 ;
10146 char *kwnames[] = {
10147 (char *) "msg", NULL
10148 };
10149
10150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10151 {
10152 arg1 = wxString_in_helper(obj0);
10153 if (arg1 == NULL) SWIG_fail;
10154 temp1 = true;
10155 }
10156 {
10157 PyThreadState* __tstate = wxPyBeginAllowThreads();
10158 wxPyLogMessage((wxString const &)*arg1);
10159
10160 wxPyEndAllowThreads(__tstate);
10161 if (PyErr_Occurred()) SWIG_fail;
10162 }
10163 Py_INCREF(Py_None); resultobj = Py_None;
10164 {
10165 if (temp1)
10166 delete arg1;
10167 }
10168 return resultobj;
10169 fail:
10170 {
10171 if (temp1)
10172 delete arg1;
10173 }
10174 return NULL;
10175 }
10176
10177
10178 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj;
10180 wxString *arg1 = 0 ;
10181 bool temp1 = false ;
10182 PyObject * obj0 = 0 ;
10183 char *kwnames[] = {
10184 (char *) "msg", NULL
10185 };
10186
10187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10188 {
10189 arg1 = wxString_in_helper(obj0);
10190 if (arg1 == NULL) SWIG_fail;
10191 temp1 = true;
10192 }
10193 {
10194 PyThreadState* __tstate = wxPyBeginAllowThreads();
10195 wxPyLogInfo((wxString const &)*arg1);
10196
10197 wxPyEndAllowThreads(__tstate);
10198 if (PyErr_Occurred()) SWIG_fail;
10199 }
10200 Py_INCREF(Py_None); resultobj = Py_None;
10201 {
10202 if (temp1)
10203 delete arg1;
10204 }
10205 return resultobj;
10206 fail:
10207 {
10208 if (temp1)
10209 delete arg1;
10210 }
10211 return NULL;
10212 }
10213
10214
10215 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10216 PyObject *resultobj;
10217 wxString *arg1 = 0 ;
10218 bool temp1 = false ;
10219 PyObject * obj0 = 0 ;
10220 char *kwnames[] = {
10221 (char *) "msg", NULL
10222 };
10223
10224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10225 {
10226 arg1 = wxString_in_helper(obj0);
10227 if (arg1 == NULL) SWIG_fail;
10228 temp1 = true;
10229 }
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 wxPyLogDebug((wxString const &)*arg1);
10233
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 Py_INCREF(Py_None); resultobj = Py_None;
10238 {
10239 if (temp1)
10240 delete arg1;
10241 }
10242 return resultobj;
10243 fail:
10244 {
10245 if (temp1)
10246 delete arg1;
10247 }
10248 return NULL;
10249 }
10250
10251
10252 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10253 PyObject *resultobj;
10254 wxString *arg1 = 0 ;
10255 bool temp1 = false ;
10256 PyObject * obj0 = 0 ;
10257 char *kwnames[] = {
10258 (char *) "msg", NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10262 {
10263 arg1 = wxString_in_helper(obj0);
10264 if (arg1 == NULL) SWIG_fail;
10265 temp1 = true;
10266 }
10267 {
10268 PyThreadState* __tstate = wxPyBeginAllowThreads();
10269 wxPyLogVerbose((wxString const &)*arg1);
10270
10271 wxPyEndAllowThreads(__tstate);
10272 if (PyErr_Occurred()) SWIG_fail;
10273 }
10274 Py_INCREF(Py_None); resultobj = Py_None;
10275 {
10276 if (temp1)
10277 delete arg1;
10278 }
10279 return resultobj;
10280 fail:
10281 {
10282 if (temp1)
10283 delete arg1;
10284 }
10285 return NULL;
10286 }
10287
10288
10289 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10290 PyObject *resultobj;
10291 wxString *arg1 = 0 ;
10292 bool temp1 = false ;
10293 PyObject * obj0 = 0 ;
10294 char *kwnames[] = {
10295 (char *) "msg", NULL
10296 };
10297
10298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10299 {
10300 arg1 = wxString_in_helper(obj0);
10301 if (arg1 == NULL) SWIG_fail;
10302 temp1 = true;
10303 }
10304 {
10305 PyThreadState* __tstate = wxPyBeginAllowThreads();
10306 wxPyLogStatus((wxString const &)*arg1);
10307
10308 wxPyEndAllowThreads(__tstate);
10309 if (PyErr_Occurred()) SWIG_fail;
10310 }
10311 Py_INCREF(Py_None); resultobj = Py_None;
10312 {
10313 if (temp1)
10314 delete arg1;
10315 }
10316 return resultobj;
10317 fail:
10318 {
10319 if (temp1)
10320 delete arg1;
10321 }
10322 return NULL;
10323 }
10324
10325
10326 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10327 PyObject *resultobj;
10328 wxFrame *arg1 = (wxFrame *) 0 ;
10329 wxString *arg2 = 0 ;
10330 bool temp2 = false ;
10331 PyObject * obj0 = 0 ;
10332 PyObject * obj1 = 0 ;
10333 char *kwnames[] = {
10334 (char *) "pFrame",(char *) "msg", NULL
10335 };
10336
10337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10339 if (SWIG_arg_fail(1)) SWIG_fail;
10340 {
10341 arg2 = wxString_in_helper(obj1);
10342 if (arg2 == NULL) SWIG_fail;
10343 temp2 = true;
10344 }
10345 {
10346 PyThreadState* __tstate = wxPyBeginAllowThreads();
10347 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10348
10349 wxPyEndAllowThreads(__tstate);
10350 if (PyErr_Occurred()) SWIG_fail;
10351 }
10352 Py_INCREF(Py_None); resultobj = Py_None;
10353 {
10354 if (temp2)
10355 delete arg2;
10356 }
10357 return resultobj;
10358 fail:
10359 {
10360 if (temp2)
10361 delete arg2;
10362 }
10363 return NULL;
10364 }
10365
10366
10367 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10368 PyObject *resultobj;
10369 wxString *arg1 = 0 ;
10370 bool temp1 = false ;
10371 PyObject * obj0 = 0 ;
10372 char *kwnames[] = {
10373 (char *) "msg", NULL
10374 };
10375
10376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10377 {
10378 arg1 = wxString_in_helper(obj0);
10379 if (arg1 == NULL) SWIG_fail;
10380 temp1 = true;
10381 }
10382 {
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 wxPyLogSysError((wxString const &)*arg1);
10385
10386 wxPyEndAllowThreads(__tstate);
10387 if (PyErr_Occurred()) SWIG_fail;
10388 }
10389 Py_INCREF(Py_None); resultobj = Py_None;
10390 {
10391 if (temp1)
10392 delete arg1;
10393 }
10394 return resultobj;
10395 fail:
10396 {
10397 if (temp1)
10398 delete arg1;
10399 }
10400 return NULL;
10401 }
10402
10403
10404 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10405 PyObject *resultobj;
10406 unsigned long arg1 ;
10407 wxString *arg2 = 0 ;
10408 bool temp2 = false ;
10409 PyObject * obj0 = 0 ;
10410 PyObject * obj1 = 0 ;
10411 char *kwnames[] = {
10412 (char *) "level",(char *) "msg", NULL
10413 };
10414
10415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10416 {
10417 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10418 if (SWIG_arg_fail(1)) SWIG_fail;
10419 }
10420 {
10421 arg2 = wxString_in_helper(obj1);
10422 if (arg2 == NULL) SWIG_fail;
10423 temp2 = true;
10424 }
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10428
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 Py_INCREF(Py_None); resultobj = Py_None;
10433 {
10434 if (temp2)
10435 delete arg2;
10436 }
10437 return resultobj;
10438 fail:
10439 {
10440 if (temp2)
10441 delete arg2;
10442 }
10443 return NULL;
10444 }
10445
10446
10447 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10448 PyObject *resultobj;
10449 unsigned long arg1 ;
10450 wxString *arg2 = 0 ;
10451 bool temp2 = false ;
10452 PyObject * obj0 = 0 ;
10453 PyObject * obj1 = 0 ;
10454
10455 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10456 {
10457 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10458 if (SWIG_arg_fail(1)) SWIG_fail;
10459 }
10460 {
10461 arg2 = wxString_in_helper(obj1);
10462 if (arg2 == NULL) SWIG_fail;
10463 temp2 = true;
10464 }
10465 {
10466 PyThreadState* __tstate = wxPyBeginAllowThreads();
10467 wxPyLogTrace(arg1,(wxString const &)*arg2);
10468
10469 wxPyEndAllowThreads(__tstate);
10470 if (PyErr_Occurred()) SWIG_fail;
10471 }
10472 Py_INCREF(Py_None); resultobj = Py_None;
10473 {
10474 if (temp2)
10475 delete arg2;
10476 }
10477 return resultobj;
10478 fail:
10479 {
10480 if (temp2)
10481 delete arg2;
10482 }
10483 return NULL;
10484 }
10485
10486
10487 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10488 PyObject *resultobj;
10489 wxString *arg1 = 0 ;
10490 wxString *arg2 = 0 ;
10491 bool temp1 = false ;
10492 bool temp2 = false ;
10493 PyObject * obj0 = 0 ;
10494 PyObject * obj1 = 0 ;
10495
10496 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10497 {
10498 arg1 = wxString_in_helper(obj0);
10499 if (arg1 == NULL) SWIG_fail;
10500 temp1 = true;
10501 }
10502 {
10503 arg2 = wxString_in_helper(obj1);
10504 if (arg2 == NULL) SWIG_fail;
10505 temp2 = true;
10506 }
10507 {
10508 PyThreadState* __tstate = wxPyBeginAllowThreads();
10509 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10510
10511 wxPyEndAllowThreads(__tstate);
10512 if (PyErr_Occurred()) SWIG_fail;
10513 }
10514 Py_INCREF(Py_None); resultobj = Py_None;
10515 {
10516 if (temp1)
10517 delete arg1;
10518 }
10519 {
10520 if (temp2)
10521 delete arg2;
10522 }
10523 return resultobj;
10524 fail:
10525 {
10526 if (temp1)
10527 delete arg1;
10528 }
10529 {
10530 if (temp2)
10531 delete arg2;
10532 }
10533 return NULL;
10534 }
10535
10536
10537 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10538 int argc;
10539 PyObject *argv[3];
10540 int ii;
10541
10542 argc = PyObject_Length(args);
10543 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10544 argv[ii] = PyTuple_GetItem(args,ii);
10545 }
10546 if (argc == 2) {
10547 int _v;
10548 {
10549 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10550 }
10551 if (_v) {
10552 {
10553 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10554 }
10555 if (_v) {
10556 return _wrap_LogTrace__SWIG_1(self,args);
10557 }
10558 }
10559 }
10560 if (argc == 2) {
10561 int _v;
10562 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10563 if (_v) {
10564 {
10565 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10566 }
10567 if (_v) {
10568 return _wrap_LogTrace__SWIG_0(self,args);
10569 }
10570 }
10571 }
10572
10573 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10574 return NULL;
10575 }
10576
10577
10578 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10579 PyObject *resultobj;
10580 wxString *arg1 = 0 ;
10581 wxString *arg2 = 0 ;
10582 bool temp1 = false ;
10583 bool temp2 = false ;
10584 PyObject * obj0 = 0 ;
10585 PyObject * obj1 = 0 ;
10586 char *kwnames[] = {
10587 (char *) "title",(char *) "text", NULL
10588 };
10589
10590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10591 {
10592 arg1 = wxString_in_helper(obj0);
10593 if (arg1 == NULL) SWIG_fail;
10594 temp1 = true;
10595 }
10596 {
10597 arg2 = wxString_in_helper(obj1);
10598 if (arg2 == NULL) SWIG_fail;
10599 temp2 = true;
10600 }
10601 {
10602 PyThreadState* __tstate = wxPyBeginAllowThreads();
10603 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10604
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 Py_INCREF(Py_None); resultobj = Py_None;
10609 {
10610 if (temp1)
10611 delete arg1;
10612 }
10613 {
10614 if (temp2)
10615 delete arg2;
10616 }
10617 return resultobj;
10618 fail:
10619 {
10620 if (temp1)
10621 delete arg1;
10622 }
10623 {
10624 if (temp2)
10625 delete arg2;
10626 }
10627 return NULL;
10628 }
10629
10630
10631 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10632 PyObject *resultobj;
10633 wxLogNull *result;
10634 char *kwnames[] = {
10635 NULL
10636 };
10637
10638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (wxLogNull *)new wxLogNull();
10642
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10647 return resultobj;
10648 fail:
10649 return NULL;
10650 }
10651
10652
10653 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10654 PyObject *resultobj;
10655 wxLogNull *arg1 = (wxLogNull *) 0 ;
10656 PyObject * obj0 = 0 ;
10657 char *kwnames[] = {
10658 (char *) "self", NULL
10659 };
10660
10661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10663 if (SWIG_arg_fail(1)) SWIG_fail;
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 delete arg1;
10667
10668 wxPyEndAllowThreads(__tstate);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 Py_INCREF(Py_None); resultobj = Py_None;
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10679 PyObject *obj;
10680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10681 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10682 Py_INCREF(obj);
10683 return Py_BuildValue((char *)"");
10684 }
10685 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10686 PyObject *resultobj;
10687 wxPyLog *result;
10688 char *kwnames[] = {
10689 NULL
10690 };
10691
10692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10693 {
10694 PyThreadState* __tstate = wxPyBeginAllowThreads();
10695 result = (wxPyLog *)new wxPyLog();
10696
10697 wxPyEndAllowThreads(__tstate);
10698 if (PyErr_Occurred()) SWIG_fail;
10699 }
10700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10701 return resultobj;
10702 fail:
10703 return NULL;
10704 }
10705
10706
10707 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10708 PyObject *resultobj;
10709 wxPyLog *arg1 = (wxPyLog *) 0 ;
10710 PyObject *arg2 = (PyObject *) 0 ;
10711 PyObject *arg3 = (PyObject *) 0 ;
10712 PyObject * obj0 = 0 ;
10713 PyObject * obj1 = 0 ;
10714 PyObject * obj2 = 0 ;
10715 char *kwnames[] = {
10716 (char *) "self",(char *) "self",(char *) "_class", NULL
10717 };
10718
10719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10721 if (SWIG_arg_fail(1)) SWIG_fail;
10722 arg2 = obj1;
10723 arg3 = obj2;
10724 {
10725 PyThreadState* __tstate = wxPyBeginAllowThreads();
10726 (arg1)->_setCallbackInfo(arg2,arg3);
10727
10728 wxPyEndAllowThreads(__tstate);
10729 if (PyErr_Occurred()) SWIG_fail;
10730 }
10731 Py_INCREF(Py_None); resultobj = Py_None;
10732 return resultobj;
10733 fail:
10734 return NULL;
10735 }
10736
10737
10738 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10739 PyObject *obj;
10740 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10741 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10742 Py_INCREF(obj);
10743 return Py_BuildValue((char *)"");
10744 }
10745 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10746 PyObject *resultobj;
10747 int arg1 ;
10748 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10749 int arg3 = (int) wxKILL_NOCHILDREN ;
10750 wxKillError result;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 PyObject * obj2 = 0 ;
10754 char *kwnames[] = {
10755 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10759 {
10760 arg1 = (int)(SWIG_As_int(obj0));
10761 if (SWIG_arg_fail(1)) SWIG_fail;
10762 }
10763 if (obj1) {
10764 {
10765 arg2 = (wxSignal)(SWIG_As_int(obj1));
10766 if (SWIG_arg_fail(2)) SWIG_fail;
10767 }
10768 }
10769 if (obj2) {
10770 {
10771 arg3 = (int)(SWIG_As_int(obj2));
10772 if (SWIG_arg_fail(3)) SWIG_fail;
10773 }
10774 }
10775 {
10776 PyThreadState* __tstate = wxPyBeginAllowThreads();
10777 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10778
10779 wxPyEndAllowThreads(__tstate);
10780 if (PyErr_Occurred()) SWIG_fail;
10781 }
10782 resultobj = SWIG_From_int((result));
10783 return resultobj;
10784 fail:
10785 return NULL;
10786 }
10787
10788
10789 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10790 PyObject *resultobj;
10791 int arg1 ;
10792 bool result;
10793 PyObject * obj0 = 0 ;
10794 char *kwnames[] = {
10795 (char *) "pid", NULL
10796 };
10797
10798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10799 {
10800 arg1 = (int)(SWIG_As_int(obj0));
10801 if (SWIG_arg_fail(1)) SWIG_fail;
10802 }
10803 {
10804 PyThreadState* __tstate = wxPyBeginAllowThreads();
10805 result = (bool)wxPyProcess::Exists(arg1);
10806
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 {
10811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10812 }
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj;
10821 wxString *arg1 = 0 ;
10822 int arg2 = (int) wxEXEC_ASYNC ;
10823 wxPyProcess *result;
10824 bool temp1 = false ;
10825 PyObject * obj0 = 0 ;
10826 PyObject * obj1 = 0 ;
10827 char *kwnames[] = {
10828 (char *) "cmd",(char *) "flags", NULL
10829 };
10830
10831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10832 {
10833 arg1 = wxString_in_helper(obj0);
10834 if (arg1 == NULL) SWIG_fail;
10835 temp1 = true;
10836 }
10837 if (obj1) {
10838 {
10839 arg2 = (int)(SWIG_As_int(obj1));
10840 if (SWIG_arg_fail(2)) SWIG_fail;
10841 }
10842 }
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10846
10847 wxPyEndAllowThreads(__tstate);
10848 if (PyErr_Occurred()) SWIG_fail;
10849 }
10850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10851 {
10852 if (temp1)
10853 delete arg1;
10854 }
10855 return resultobj;
10856 fail:
10857 {
10858 if (temp1)
10859 delete arg1;
10860 }
10861 return NULL;
10862 }
10863
10864
10865 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10866 PyObject *resultobj;
10867 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10868 int arg2 = (int) -1 ;
10869 wxPyProcess *result;
10870 PyObject * obj0 = 0 ;
10871 PyObject * obj1 = 0 ;
10872 char *kwnames[] = {
10873 (char *) "parent",(char *) "id", NULL
10874 };
10875
10876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10877 if (obj0) {
10878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10879 if (SWIG_arg_fail(1)) SWIG_fail;
10880 }
10881 if (obj1) {
10882 {
10883 arg2 = (int)(SWIG_As_int(obj1));
10884 if (SWIG_arg_fail(2)) SWIG_fail;
10885 }
10886 }
10887 {
10888 PyThreadState* __tstate = wxPyBeginAllowThreads();
10889 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10890
10891 wxPyEndAllowThreads(__tstate);
10892 if (PyErr_Occurred()) SWIG_fail;
10893 }
10894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10895 return resultobj;
10896 fail:
10897 return NULL;
10898 }
10899
10900
10901 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10902 PyObject *resultobj;
10903 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10904 PyObject *arg2 = (PyObject *) 0 ;
10905 PyObject *arg3 = (PyObject *) 0 ;
10906 PyObject * obj0 = 0 ;
10907 PyObject * obj1 = 0 ;
10908 PyObject * obj2 = 0 ;
10909 char *kwnames[] = {
10910 (char *) "self",(char *) "self",(char *) "_class", NULL
10911 };
10912
10913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10915 if (SWIG_arg_fail(1)) SWIG_fail;
10916 arg2 = obj1;
10917 arg3 = obj2;
10918 {
10919 PyThreadState* __tstate = wxPyBeginAllowThreads();
10920 (arg1)->_setCallbackInfo(arg2,arg3);
10921
10922 wxPyEndAllowThreads(__tstate);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 Py_INCREF(Py_None); resultobj = Py_None;
10926 return resultobj;
10927 fail:
10928 return NULL;
10929 }
10930
10931
10932 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10933 PyObject *resultobj;
10934 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10935 int arg2 ;
10936 int arg3 ;
10937 PyObject * obj0 = 0 ;
10938 PyObject * obj1 = 0 ;
10939 PyObject * obj2 = 0 ;
10940 char *kwnames[] = {
10941 (char *) "self",(char *) "pid",(char *) "status", NULL
10942 };
10943
10944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10946 if (SWIG_arg_fail(1)) SWIG_fail;
10947 {
10948 arg2 = (int)(SWIG_As_int(obj1));
10949 if (SWIG_arg_fail(2)) SWIG_fail;
10950 }
10951 {
10952 arg3 = (int)(SWIG_As_int(obj2));
10953 if (SWIG_arg_fail(3)) SWIG_fail;
10954 }
10955 {
10956 PyThreadState* __tstate = wxPyBeginAllowThreads();
10957 (arg1)->base_OnTerminate(arg2,arg3);
10958
10959 wxPyEndAllowThreads(__tstate);
10960 if (PyErr_Occurred()) SWIG_fail;
10961 }
10962 Py_INCREF(Py_None); resultobj = Py_None;
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj;
10971 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10972 PyObject * obj0 = 0 ;
10973 char *kwnames[] = {
10974 (char *) "self", NULL
10975 };
10976
10977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10979 if (SWIG_arg_fail(1)) SWIG_fail;
10980 {
10981 PyThreadState* __tstate = wxPyBeginAllowThreads();
10982 (arg1)->Redirect();
10983
10984 wxPyEndAllowThreads(__tstate);
10985 if (PyErr_Occurred()) SWIG_fail;
10986 }
10987 Py_INCREF(Py_None); resultobj = Py_None;
10988 return resultobj;
10989 fail:
10990 return NULL;
10991 }
10992
10993
10994 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10995 PyObject *resultobj;
10996 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10997 bool result;
10998 PyObject * obj0 = 0 ;
10999 char *kwnames[] = {
11000 (char *) "self", NULL
11001 };
11002
11003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11005 if (SWIG_arg_fail(1)) SWIG_fail;
11006 {
11007 PyThreadState* __tstate = wxPyBeginAllowThreads();
11008 result = (bool)(arg1)->IsRedirected();
11009
11010 wxPyEndAllowThreads(__tstate);
11011 if (PyErr_Occurred()) SWIG_fail;
11012 }
11013 {
11014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11015 }
11016 return resultobj;
11017 fail:
11018 return NULL;
11019 }
11020
11021
11022 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11023 PyObject *resultobj;
11024 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11025 PyObject * obj0 = 0 ;
11026 char *kwnames[] = {
11027 (char *) "self", NULL
11028 };
11029
11030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11032 if (SWIG_arg_fail(1)) SWIG_fail;
11033 {
11034 PyThreadState* __tstate = wxPyBeginAllowThreads();
11035 (arg1)->Detach();
11036
11037 wxPyEndAllowThreads(__tstate);
11038 if (PyErr_Occurred()) SWIG_fail;
11039 }
11040 Py_INCREF(Py_None); resultobj = Py_None;
11041 return resultobj;
11042 fail:
11043 return NULL;
11044 }
11045
11046
11047 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11048 PyObject *resultobj;
11049 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11050 wxInputStream *result;
11051 PyObject * obj0 = 0 ;
11052 char *kwnames[] = {
11053 (char *) "self", NULL
11054 };
11055
11056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11058 if (SWIG_arg_fail(1)) SWIG_fail;
11059 {
11060 PyThreadState* __tstate = wxPyBeginAllowThreads();
11061 result = (wxInputStream *)(arg1)->GetInputStream();
11062
11063 wxPyEndAllowThreads(__tstate);
11064 if (PyErr_Occurred()) SWIG_fail;
11065 }
11066 {
11067 wxPyInputStream * _ptr = NULL;
11068
11069 if (result) {
11070 _ptr = new wxPyInputStream(result);
11071 }
11072 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11073 }
11074 return resultobj;
11075 fail:
11076 return NULL;
11077 }
11078
11079
11080 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11081 PyObject *resultobj;
11082 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11083 wxInputStream *result;
11084 PyObject * obj0 = 0 ;
11085 char *kwnames[] = {
11086 (char *) "self", NULL
11087 };
11088
11089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11091 if (SWIG_arg_fail(1)) SWIG_fail;
11092 {
11093 PyThreadState* __tstate = wxPyBeginAllowThreads();
11094 result = (wxInputStream *)(arg1)->GetErrorStream();
11095
11096 wxPyEndAllowThreads(__tstate);
11097 if (PyErr_Occurred()) SWIG_fail;
11098 }
11099 {
11100 wxPyInputStream * _ptr = NULL;
11101
11102 if (result) {
11103 _ptr = new wxPyInputStream(result);
11104 }
11105 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11106 }
11107 return resultobj;
11108 fail:
11109 return NULL;
11110 }
11111
11112
11113 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11114 PyObject *resultobj;
11115 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11116 wxOutputStream *result;
11117 PyObject * obj0 = 0 ;
11118 char *kwnames[] = {
11119 (char *) "self", NULL
11120 };
11121
11122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11124 if (SWIG_arg_fail(1)) SWIG_fail;
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (wxOutputStream *)(arg1)->GetOutputStream();
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11140 PyObject *resultobj;
11141 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11142 PyObject * obj0 = 0 ;
11143 char *kwnames[] = {
11144 (char *) "self", NULL
11145 };
11146
11147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11149 if (SWIG_arg_fail(1)) SWIG_fail;
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 (arg1)->CloseOutput();
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 Py_INCREF(Py_None); resultobj = Py_None;
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj;
11166 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11167 bool result;
11168 PyObject * obj0 = 0 ;
11169 char *kwnames[] = {
11170 (char *) "self", NULL
11171 };
11172
11173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11175 if (SWIG_arg_fail(1)) SWIG_fail;
11176 {
11177 PyThreadState* __tstate = wxPyBeginAllowThreads();
11178 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11179
11180 wxPyEndAllowThreads(__tstate);
11181 if (PyErr_Occurred()) SWIG_fail;
11182 }
11183 {
11184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11185 }
11186 return resultobj;
11187 fail:
11188 return NULL;
11189 }
11190
11191
11192 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11193 PyObject *resultobj;
11194 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11195 bool result;
11196 PyObject * obj0 = 0 ;
11197 char *kwnames[] = {
11198 (char *) "self", NULL
11199 };
11200
11201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11203 if (SWIG_arg_fail(1)) SWIG_fail;
11204 {
11205 PyThreadState* __tstate = wxPyBeginAllowThreads();
11206 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11207
11208 wxPyEndAllowThreads(__tstate);
11209 if (PyErr_Occurred()) SWIG_fail;
11210 }
11211 {
11212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11213 }
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11221 PyObject *resultobj;
11222 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11223 bool result;
11224 PyObject * obj0 = 0 ;
11225 char *kwnames[] = {
11226 (char *) "self", NULL
11227 };
11228
11229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11231 if (SWIG_arg_fail(1)) SWIG_fail;
11232 {
11233 PyThreadState* __tstate = wxPyBeginAllowThreads();
11234 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11235
11236 wxPyEndAllowThreads(__tstate);
11237 if (PyErr_Occurred()) SWIG_fail;
11238 }
11239 {
11240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11241 }
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11249 PyObject *obj;
11250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11251 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11252 Py_INCREF(obj);
11253 return Py_BuildValue((char *)"");
11254 }
11255 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11256 PyObject *resultobj;
11257 int arg1 = (int) 0 ;
11258 int arg2 = (int) 0 ;
11259 int arg3 = (int) 0 ;
11260 wxProcessEvent *result;
11261 PyObject * obj0 = 0 ;
11262 PyObject * obj1 = 0 ;
11263 PyObject * obj2 = 0 ;
11264 char *kwnames[] = {
11265 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11266 };
11267
11268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11269 if (obj0) {
11270 {
11271 arg1 = (int)(SWIG_As_int(obj0));
11272 if (SWIG_arg_fail(1)) SWIG_fail;
11273 }
11274 }
11275 if (obj1) {
11276 {
11277 arg2 = (int)(SWIG_As_int(obj1));
11278 if (SWIG_arg_fail(2)) SWIG_fail;
11279 }
11280 }
11281 if (obj2) {
11282 {
11283 arg3 = (int)(SWIG_As_int(obj2));
11284 if (SWIG_arg_fail(3)) SWIG_fail;
11285 }
11286 }
11287 {
11288 PyThreadState* __tstate = wxPyBeginAllowThreads();
11289 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11290
11291 wxPyEndAllowThreads(__tstate);
11292 if (PyErr_Occurred()) SWIG_fail;
11293 }
11294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11295 return resultobj;
11296 fail:
11297 return NULL;
11298 }
11299
11300
11301 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11302 PyObject *resultobj;
11303 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11304 int result;
11305 PyObject * obj0 = 0 ;
11306 char *kwnames[] = {
11307 (char *) "self", NULL
11308 };
11309
11310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11312 if (SWIG_arg_fail(1)) SWIG_fail;
11313 {
11314 PyThreadState* __tstate = wxPyBeginAllowThreads();
11315 result = (int)(arg1)->GetPid();
11316
11317 wxPyEndAllowThreads(__tstate);
11318 if (PyErr_Occurred()) SWIG_fail;
11319 }
11320 {
11321 resultobj = SWIG_From_int((int)(result));
11322 }
11323 return resultobj;
11324 fail:
11325 return NULL;
11326 }
11327
11328
11329 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11330 PyObject *resultobj;
11331 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11332 int result;
11333 PyObject * obj0 = 0 ;
11334 char *kwnames[] = {
11335 (char *) "self", NULL
11336 };
11337
11338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11340 if (SWIG_arg_fail(1)) SWIG_fail;
11341 {
11342 PyThreadState* __tstate = wxPyBeginAllowThreads();
11343 result = (int)(arg1)->GetExitCode();
11344
11345 wxPyEndAllowThreads(__tstate);
11346 if (PyErr_Occurred()) SWIG_fail;
11347 }
11348 {
11349 resultobj = SWIG_From_int((int)(result));
11350 }
11351 return resultobj;
11352 fail:
11353 return NULL;
11354 }
11355
11356
11357 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj;
11359 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11360 int arg2 ;
11361 PyObject * obj0 = 0 ;
11362 PyObject * obj1 = 0 ;
11363 char *kwnames[] = {
11364 (char *) "self",(char *) "m_pid", NULL
11365 };
11366
11367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11369 if (SWIG_arg_fail(1)) SWIG_fail;
11370 {
11371 arg2 = (int)(SWIG_As_int(obj1));
11372 if (SWIG_arg_fail(2)) SWIG_fail;
11373 }
11374 if (arg1) (arg1)->m_pid = arg2;
11375
11376 Py_INCREF(Py_None); resultobj = Py_None;
11377 return resultobj;
11378 fail:
11379 return NULL;
11380 }
11381
11382
11383 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11384 PyObject *resultobj;
11385 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11386 int result;
11387 PyObject * obj0 = 0 ;
11388 char *kwnames[] = {
11389 (char *) "self", NULL
11390 };
11391
11392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11394 if (SWIG_arg_fail(1)) SWIG_fail;
11395 result = (int) ((arg1)->m_pid);
11396
11397 {
11398 resultobj = SWIG_From_int((int)(result));
11399 }
11400 return resultobj;
11401 fail:
11402 return NULL;
11403 }
11404
11405
11406 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11407 PyObject *resultobj;
11408 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11409 int arg2 ;
11410 PyObject * obj0 = 0 ;
11411 PyObject * obj1 = 0 ;
11412 char *kwnames[] = {
11413 (char *) "self",(char *) "m_exitcode", NULL
11414 };
11415
11416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11418 if (SWIG_arg_fail(1)) SWIG_fail;
11419 {
11420 arg2 = (int)(SWIG_As_int(obj1));
11421 if (SWIG_arg_fail(2)) SWIG_fail;
11422 }
11423 if (arg1) (arg1)->m_exitcode = arg2;
11424
11425 Py_INCREF(Py_None); resultobj = Py_None;
11426 return resultobj;
11427 fail:
11428 return NULL;
11429 }
11430
11431
11432 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11433 PyObject *resultobj;
11434 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11435 int result;
11436 PyObject * obj0 = 0 ;
11437 char *kwnames[] = {
11438 (char *) "self", NULL
11439 };
11440
11441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11443 if (SWIG_arg_fail(1)) SWIG_fail;
11444 result = (int) ((arg1)->m_exitcode);
11445
11446 {
11447 resultobj = SWIG_From_int((int)(result));
11448 }
11449 return resultobj;
11450 fail:
11451 return NULL;
11452 }
11453
11454
11455 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11456 PyObject *obj;
11457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11458 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11459 Py_INCREF(obj);
11460 return Py_BuildValue((char *)"");
11461 }
11462 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11463 PyObject *resultobj;
11464 wxString *arg1 = 0 ;
11465 int arg2 = (int) wxEXEC_ASYNC ;
11466 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11467 long result;
11468 bool temp1 = false ;
11469 PyObject * obj0 = 0 ;
11470 PyObject * obj1 = 0 ;
11471 PyObject * obj2 = 0 ;
11472 char *kwnames[] = {
11473 (char *) "command",(char *) "flags",(char *) "process", NULL
11474 };
11475
11476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11477 {
11478 arg1 = wxString_in_helper(obj0);
11479 if (arg1 == NULL) SWIG_fail;
11480 temp1 = true;
11481 }
11482 if (obj1) {
11483 {
11484 arg2 = (int)(SWIG_As_int(obj1));
11485 if (SWIG_arg_fail(2)) SWIG_fail;
11486 }
11487 }
11488 if (obj2) {
11489 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11490 if (SWIG_arg_fail(3)) SWIG_fail;
11491 }
11492 {
11493 if (!wxPyCheckForApp()) SWIG_fail;
11494 PyThreadState* __tstate = wxPyBeginAllowThreads();
11495 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11496
11497 wxPyEndAllowThreads(__tstate);
11498 if (PyErr_Occurred()) SWIG_fail;
11499 }
11500 {
11501 resultobj = SWIG_From_long((long)(result));
11502 }
11503 {
11504 if (temp1)
11505 delete arg1;
11506 }
11507 return resultobj;
11508 fail:
11509 {
11510 if (temp1)
11511 delete arg1;
11512 }
11513 return NULL;
11514 }
11515
11516
11517 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11518 PyObject *resultobj;
11519 long arg1 ;
11520 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11521 wxKillError *arg3 = (wxKillError *) 0 ;
11522 int arg4 = (int) wxKILL_NOCHILDREN ;
11523 int result;
11524 wxKillError temp3 ;
11525 PyObject * obj0 = 0 ;
11526 PyObject * obj1 = 0 ;
11527 PyObject * obj2 = 0 ;
11528 char *kwnames[] = {
11529 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11530 };
11531
11532 {
11533 arg3 = &temp3;
11534 }
11535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11536 {
11537 arg1 = (long)(SWIG_As_long(obj0));
11538 if (SWIG_arg_fail(1)) SWIG_fail;
11539 }
11540 if (obj1) {
11541 {
11542 arg2 = (wxSignal)(SWIG_As_int(obj1));
11543 if (SWIG_arg_fail(2)) SWIG_fail;
11544 }
11545 }
11546 if (obj2) {
11547 {
11548 arg4 = (int)(SWIG_As_int(obj2));
11549 if (SWIG_arg_fail(4)) SWIG_fail;
11550 }
11551 }
11552 {
11553 PyThreadState* __tstate = wxPyBeginAllowThreads();
11554 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11555
11556 wxPyEndAllowThreads(__tstate);
11557 if (PyErr_Occurred()) SWIG_fail;
11558 }
11559 {
11560 resultobj = SWIG_From_int((int)(result));
11561 }
11562 {
11563 PyObject* o;
11564 o = PyInt_FromLong((long) (*arg3));
11565 resultobj = t_output_helper(resultobj, o);
11566 }
11567 return resultobj;
11568 fail:
11569 return NULL;
11570 }
11571
11572
11573 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11574 PyObject *resultobj;
11575 int arg1 = (int) wxJOYSTICK1 ;
11576 wxJoystick *result;
11577 PyObject * obj0 = 0 ;
11578 char *kwnames[] = {
11579 (char *) "joystick", NULL
11580 };
11581
11582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11583 if (obj0) {
11584 {
11585 arg1 = (int)(SWIG_As_int(obj0));
11586 if (SWIG_arg_fail(1)) SWIG_fail;
11587 }
11588 }
11589 {
11590 if (!wxPyCheckForApp()) SWIG_fail;
11591 PyThreadState* __tstate = wxPyBeginAllowThreads();
11592 result = (wxJoystick *)new wxJoystick(arg1);
11593
11594 wxPyEndAllowThreads(__tstate);
11595 if (PyErr_Occurred()) SWIG_fail;
11596 }
11597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11598 return resultobj;
11599 fail:
11600 return NULL;
11601 }
11602
11603
11604 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11605 PyObject *resultobj;
11606 wxJoystick *arg1 = (wxJoystick *) 0 ;
11607 PyObject * obj0 = 0 ;
11608 char *kwnames[] = {
11609 (char *) "self", NULL
11610 };
11611
11612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11614 if (SWIG_arg_fail(1)) SWIG_fail;
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 delete arg1;
11618
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 Py_INCREF(Py_None); resultobj = Py_None;
11623 return resultobj;
11624 fail:
11625 return NULL;
11626 }
11627
11628
11629 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11630 PyObject *resultobj;
11631 wxJoystick *arg1 = (wxJoystick *) 0 ;
11632 wxPoint result;
11633 PyObject * obj0 = 0 ;
11634 char *kwnames[] = {
11635 (char *) "self", NULL
11636 };
11637
11638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11640 if (SWIG_arg_fail(1)) SWIG_fail;
11641 {
11642 PyThreadState* __tstate = wxPyBeginAllowThreads();
11643 result = (arg1)->GetPosition();
11644
11645 wxPyEndAllowThreads(__tstate);
11646 if (PyErr_Occurred()) SWIG_fail;
11647 }
11648 {
11649 wxPoint * resultptr;
11650 resultptr = new wxPoint((wxPoint &)(result));
11651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11652 }
11653 return resultobj;
11654 fail:
11655 return NULL;
11656 }
11657
11658
11659 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11660 PyObject *resultobj;
11661 wxJoystick *arg1 = (wxJoystick *) 0 ;
11662 int result;
11663 PyObject * obj0 = 0 ;
11664 char *kwnames[] = {
11665 (char *) "self", NULL
11666 };
11667
11668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11670 if (SWIG_arg_fail(1)) SWIG_fail;
11671 {
11672 PyThreadState* __tstate = wxPyBeginAllowThreads();
11673 result = (int)(arg1)->GetZPosition();
11674
11675 wxPyEndAllowThreads(__tstate);
11676 if (PyErr_Occurred()) SWIG_fail;
11677 }
11678 {
11679 resultobj = SWIG_From_int((int)(result));
11680 }
11681 return resultobj;
11682 fail:
11683 return NULL;
11684 }
11685
11686
11687 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11688 PyObject *resultobj;
11689 wxJoystick *arg1 = (wxJoystick *) 0 ;
11690 int result;
11691 PyObject * obj0 = 0 ;
11692 char *kwnames[] = {
11693 (char *) "self", NULL
11694 };
11695
11696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11698 if (SWIG_arg_fail(1)) SWIG_fail;
11699 {
11700 PyThreadState* __tstate = wxPyBeginAllowThreads();
11701 result = (int)(arg1)->GetButtonState();
11702
11703 wxPyEndAllowThreads(__tstate);
11704 if (PyErr_Occurred()) SWIG_fail;
11705 }
11706 {
11707 resultobj = SWIG_From_int((int)(result));
11708 }
11709 return resultobj;
11710 fail:
11711 return NULL;
11712 }
11713
11714
11715 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11716 PyObject *resultobj;
11717 wxJoystick *arg1 = (wxJoystick *) 0 ;
11718 int result;
11719 PyObject * obj0 = 0 ;
11720 char *kwnames[] = {
11721 (char *) "self", NULL
11722 };
11723
11724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11726 if (SWIG_arg_fail(1)) SWIG_fail;
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 result = (int)(arg1)->GetPOVPosition();
11730
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 {
11735 resultobj = SWIG_From_int((int)(result));
11736 }
11737 return resultobj;
11738 fail:
11739 return NULL;
11740 }
11741
11742
11743 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11744 PyObject *resultobj;
11745 wxJoystick *arg1 = (wxJoystick *) 0 ;
11746 int result;
11747 PyObject * obj0 = 0 ;
11748 char *kwnames[] = {
11749 (char *) "self", NULL
11750 };
11751
11752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11754 if (SWIG_arg_fail(1)) SWIG_fail;
11755 {
11756 PyThreadState* __tstate = wxPyBeginAllowThreads();
11757 result = (int)(arg1)->GetPOVCTSPosition();
11758
11759 wxPyEndAllowThreads(__tstate);
11760 if (PyErr_Occurred()) SWIG_fail;
11761 }
11762 {
11763 resultobj = SWIG_From_int((int)(result));
11764 }
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11772 PyObject *resultobj;
11773 wxJoystick *arg1 = (wxJoystick *) 0 ;
11774 int result;
11775 PyObject * obj0 = 0 ;
11776 char *kwnames[] = {
11777 (char *) "self", NULL
11778 };
11779
11780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11782 if (SWIG_arg_fail(1)) SWIG_fail;
11783 {
11784 PyThreadState* __tstate = wxPyBeginAllowThreads();
11785 result = (int)(arg1)->GetRudderPosition();
11786
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 resultobj = SWIG_From_int((int)(result));
11792 }
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11800 PyObject *resultobj;
11801 wxJoystick *arg1 = (wxJoystick *) 0 ;
11802 int result;
11803 PyObject * obj0 = 0 ;
11804 char *kwnames[] = {
11805 (char *) "self", NULL
11806 };
11807
11808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11810 if (SWIG_arg_fail(1)) SWIG_fail;
11811 {
11812 PyThreadState* __tstate = wxPyBeginAllowThreads();
11813 result = (int)(arg1)->GetUPosition();
11814
11815 wxPyEndAllowThreads(__tstate);
11816 if (PyErr_Occurred()) SWIG_fail;
11817 }
11818 {
11819 resultobj = SWIG_From_int((int)(result));
11820 }
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11828 PyObject *resultobj;
11829 wxJoystick *arg1 = (wxJoystick *) 0 ;
11830 int result;
11831 PyObject * obj0 = 0 ;
11832 char *kwnames[] = {
11833 (char *) "self", NULL
11834 };
11835
11836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11838 if (SWIG_arg_fail(1)) SWIG_fail;
11839 {
11840 PyThreadState* __tstate = wxPyBeginAllowThreads();
11841 result = (int)(arg1)->GetVPosition();
11842
11843 wxPyEndAllowThreads(__tstate);
11844 if (PyErr_Occurred()) SWIG_fail;
11845 }
11846 {
11847 resultobj = SWIG_From_int((int)(result));
11848 }
11849 return resultobj;
11850 fail:
11851 return NULL;
11852 }
11853
11854
11855 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11856 PyObject *resultobj;
11857 wxJoystick *arg1 = (wxJoystick *) 0 ;
11858 int result;
11859 PyObject * obj0 = 0 ;
11860 char *kwnames[] = {
11861 (char *) "self", NULL
11862 };
11863
11864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11866 if (SWIG_arg_fail(1)) SWIG_fail;
11867 {
11868 PyThreadState* __tstate = wxPyBeginAllowThreads();
11869 result = (int)(arg1)->GetMovementThreshold();
11870
11871 wxPyEndAllowThreads(__tstate);
11872 if (PyErr_Occurred()) SWIG_fail;
11873 }
11874 {
11875 resultobj = SWIG_From_int((int)(result));
11876 }
11877 return resultobj;
11878 fail:
11879 return NULL;
11880 }
11881
11882
11883 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11884 PyObject *resultobj;
11885 wxJoystick *arg1 = (wxJoystick *) 0 ;
11886 int arg2 ;
11887 PyObject * obj0 = 0 ;
11888 PyObject * obj1 = 0 ;
11889 char *kwnames[] = {
11890 (char *) "self",(char *) "threshold", NULL
11891 };
11892
11893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11895 if (SWIG_arg_fail(1)) SWIG_fail;
11896 {
11897 arg2 = (int)(SWIG_As_int(obj1));
11898 if (SWIG_arg_fail(2)) SWIG_fail;
11899 }
11900 {
11901 PyThreadState* __tstate = wxPyBeginAllowThreads();
11902 (arg1)->SetMovementThreshold(arg2);
11903
11904 wxPyEndAllowThreads(__tstate);
11905 if (PyErr_Occurred()) SWIG_fail;
11906 }
11907 Py_INCREF(Py_None); resultobj = Py_None;
11908 return resultobj;
11909 fail:
11910 return NULL;
11911 }
11912
11913
11914 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11915 PyObject *resultobj;
11916 wxJoystick *arg1 = (wxJoystick *) 0 ;
11917 bool result;
11918 PyObject * obj0 = 0 ;
11919 char *kwnames[] = {
11920 (char *) "self", NULL
11921 };
11922
11923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11925 if (SWIG_arg_fail(1)) SWIG_fail;
11926 {
11927 PyThreadState* __tstate = wxPyBeginAllowThreads();
11928 result = (bool)(arg1)->IsOk();
11929
11930 wxPyEndAllowThreads(__tstate);
11931 if (PyErr_Occurred()) SWIG_fail;
11932 }
11933 {
11934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11935 }
11936 return resultobj;
11937 fail:
11938 return NULL;
11939 }
11940
11941
11942 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11943 PyObject *resultobj;
11944 wxJoystick *arg1 = (wxJoystick *) 0 ;
11945 int result;
11946 PyObject * obj0 = 0 ;
11947 char *kwnames[] = {
11948 (char *) "self", NULL
11949 };
11950
11951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11953 if (SWIG_arg_fail(1)) SWIG_fail;
11954 {
11955 PyThreadState* __tstate = wxPyBeginAllowThreads();
11956 result = (int)(arg1)->GetNumberJoysticks();
11957
11958 wxPyEndAllowThreads(__tstate);
11959 if (PyErr_Occurred()) SWIG_fail;
11960 }
11961 {
11962 resultobj = SWIG_From_int((int)(result));
11963 }
11964 return resultobj;
11965 fail:
11966 return NULL;
11967 }
11968
11969
11970 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11971 PyObject *resultobj;
11972 wxJoystick *arg1 = (wxJoystick *) 0 ;
11973 int result;
11974 PyObject * obj0 = 0 ;
11975 char *kwnames[] = {
11976 (char *) "self", NULL
11977 };
11978
11979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11981 if (SWIG_arg_fail(1)) SWIG_fail;
11982 {
11983 PyThreadState* __tstate = wxPyBeginAllowThreads();
11984 result = (int)(arg1)->GetManufacturerId();
11985
11986 wxPyEndAllowThreads(__tstate);
11987 if (PyErr_Occurred()) SWIG_fail;
11988 }
11989 {
11990 resultobj = SWIG_From_int((int)(result));
11991 }
11992 return resultobj;
11993 fail:
11994 return NULL;
11995 }
11996
11997
11998 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11999 PyObject *resultobj;
12000 wxJoystick *arg1 = (wxJoystick *) 0 ;
12001 int result;
12002 PyObject * obj0 = 0 ;
12003 char *kwnames[] = {
12004 (char *) "self", NULL
12005 };
12006
12007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12009 if (SWIG_arg_fail(1)) SWIG_fail;
12010 {
12011 PyThreadState* __tstate = wxPyBeginAllowThreads();
12012 result = (int)(arg1)->GetProductId();
12013
12014 wxPyEndAllowThreads(__tstate);
12015 if (PyErr_Occurred()) SWIG_fail;
12016 }
12017 {
12018 resultobj = SWIG_From_int((int)(result));
12019 }
12020 return resultobj;
12021 fail:
12022 return NULL;
12023 }
12024
12025
12026 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12027 PyObject *resultobj;
12028 wxJoystick *arg1 = (wxJoystick *) 0 ;
12029 wxString result;
12030 PyObject * obj0 = 0 ;
12031 char *kwnames[] = {
12032 (char *) "self", NULL
12033 };
12034
12035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12037 if (SWIG_arg_fail(1)) SWIG_fail;
12038 {
12039 PyThreadState* __tstate = wxPyBeginAllowThreads();
12040 result = (arg1)->GetProductName();
12041
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 {
12046 #if wxUSE_UNICODE
12047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12048 #else
12049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12050 #endif
12051 }
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12059 PyObject *resultobj;
12060 wxJoystick *arg1 = (wxJoystick *) 0 ;
12061 int result;
12062 PyObject * obj0 = 0 ;
12063 char *kwnames[] = {
12064 (char *) "self", NULL
12065 };
12066
12067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12069 if (SWIG_arg_fail(1)) SWIG_fail;
12070 {
12071 PyThreadState* __tstate = wxPyBeginAllowThreads();
12072 result = (int)(arg1)->GetXMin();
12073
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 {
12078 resultobj = SWIG_From_int((int)(result));
12079 }
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj;
12088 wxJoystick *arg1 = (wxJoystick *) 0 ;
12089 int result;
12090 PyObject * obj0 = 0 ;
12091 char *kwnames[] = {
12092 (char *) "self", NULL
12093 };
12094
12095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12097 if (SWIG_arg_fail(1)) SWIG_fail;
12098 {
12099 PyThreadState* __tstate = wxPyBeginAllowThreads();
12100 result = (int)(arg1)->GetYMin();
12101
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 {
12106 resultobj = SWIG_From_int((int)(result));
12107 }
12108 return resultobj;
12109 fail:
12110 return NULL;
12111 }
12112
12113
12114 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12115 PyObject *resultobj;
12116 wxJoystick *arg1 = (wxJoystick *) 0 ;
12117 int result;
12118 PyObject * obj0 = 0 ;
12119 char *kwnames[] = {
12120 (char *) "self", NULL
12121 };
12122
12123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12125 if (SWIG_arg_fail(1)) SWIG_fail;
12126 {
12127 PyThreadState* __tstate = wxPyBeginAllowThreads();
12128 result = (int)(arg1)->GetZMin();
12129
12130 wxPyEndAllowThreads(__tstate);
12131 if (PyErr_Occurred()) SWIG_fail;
12132 }
12133 {
12134 resultobj = SWIG_From_int((int)(result));
12135 }
12136 return resultobj;
12137 fail:
12138 return NULL;
12139 }
12140
12141
12142 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12143 PyObject *resultobj;
12144 wxJoystick *arg1 = (wxJoystick *) 0 ;
12145 int result;
12146 PyObject * obj0 = 0 ;
12147 char *kwnames[] = {
12148 (char *) "self", NULL
12149 };
12150
12151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12153 if (SWIG_arg_fail(1)) SWIG_fail;
12154 {
12155 PyThreadState* __tstate = wxPyBeginAllowThreads();
12156 result = (int)(arg1)->GetXMax();
12157
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 {
12162 resultobj = SWIG_From_int((int)(result));
12163 }
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj;
12172 wxJoystick *arg1 = (wxJoystick *) 0 ;
12173 int result;
12174 PyObject * obj0 = 0 ;
12175 char *kwnames[] = {
12176 (char *) "self", NULL
12177 };
12178
12179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12181 if (SWIG_arg_fail(1)) SWIG_fail;
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 result = (int)(arg1)->GetYMax();
12185
12186 wxPyEndAllowThreads(__tstate);
12187 if (PyErr_Occurred()) SWIG_fail;
12188 }
12189 {
12190 resultobj = SWIG_From_int((int)(result));
12191 }
12192 return resultobj;
12193 fail:
12194 return NULL;
12195 }
12196
12197
12198 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12199 PyObject *resultobj;
12200 wxJoystick *arg1 = (wxJoystick *) 0 ;
12201 int result;
12202 PyObject * obj0 = 0 ;
12203 char *kwnames[] = {
12204 (char *) "self", NULL
12205 };
12206
12207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12209 if (SWIG_arg_fail(1)) SWIG_fail;
12210 {
12211 PyThreadState* __tstate = wxPyBeginAllowThreads();
12212 result = (int)(arg1)->GetZMax();
12213
12214 wxPyEndAllowThreads(__tstate);
12215 if (PyErr_Occurred()) SWIG_fail;
12216 }
12217 {
12218 resultobj = SWIG_From_int((int)(result));
12219 }
12220 return resultobj;
12221 fail:
12222 return NULL;
12223 }
12224
12225
12226 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12227 PyObject *resultobj;
12228 wxJoystick *arg1 = (wxJoystick *) 0 ;
12229 int result;
12230 PyObject * obj0 = 0 ;
12231 char *kwnames[] = {
12232 (char *) "self", NULL
12233 };
12234
12235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12237 if (SWIG_arg_fail(1)) SWIG_fail;
12238 {
12239 PyThreadState* __tstate = wxPyBeginAllowThreads();
12240 result = (int)(arg1)->GetNumberButtons();
12241
12242 wxPyEndAllowThreads(__tstate);
12243 if (PyErr_Occurred()) SWIG_fail;
12244 }
12245 {
12246 resultobj = SWIG_From_int((int)(result));
12247 }
12248 return resultobj;
12249 fail:
12250 return NULL;
12251 }
12252
12253
12254 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12255 PyObject *resultobj;
12256 wxJoystick *arg1 = (wxJoystick *) 0 ;
12257 int result;
12258 PyObject * obj0 = 0 ;
12259 char *kwnames[] = {
12260 (char *) "self", NULL
12261 };
12262
12263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12265 if (SWIG_arg_fail(1)) SWIG_fail;
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (int)(arg1)->GetNumberAxes();
12269
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 {
12274 resultobj = SWIG_From_int((int)(result));
12275 }
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12283 PyObject *resultobj;
12284 wxJoystick *arg1 = (wxJoystick *) 0 ;
12285 int result;
12286 PyObject * obj0 = 0 ;
12287 char *kwnames[] = {
12288 (char *) "self", NULL
12289 };
12290
12291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12293 if (SWIG_arg_fail(1)) SWIG_fail;
12294 {
12295 PyThreadState* __tstate = wxPyBeginAllowThreads();
12296 result = (int)(arg1)->GetMaxButtons();
12297
12298 wxPyEndAllowThreads(__tstate);
12299 if (PyErr_Occurred()) SWIG_fail;
12300 }
12301 {
12302 resultobj = SWIG_From_int((int)(result));
12303 }
12304 return resultobj;
12305 fail:
12306 return NULL;
12307 }
12308
12309
12310 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12311 PyObject *resultobj;
12312 wxJoystick *arg1 = (wxJoystick *) 0 ;
12313 int result;
12314 PyObject * obj0 = 0 ;
12315 char *kwnames[] = {
12316 (char *) "self", NULL
12317 };
12318
12319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12321 if (SWIG_arg_fail(1)) SWIG_fail;
12322 {
12323 PyThreadState* __tstate = wxPyBeginAllowThreads();
12324 result = (int)(arg1)->GetMaxAxes();
12325
12326 wxPyEndAllowThreads(__tstate);
12327 if (PyErr_Occurred()) SWIG_fail;
12328 }
12329 {
12330 resultobj = SWIG_From_int((int)(result));
12331 }
12332 return resultobj;
12333 fail:
12334 return NULL;
12335 }
12336
12337
12338 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12339 PyObject *resultobj;
12340 wxJoystick *arg1 = (wxJoystick *) 0 ;
12341 int result;
12342 PyObject * obj0 = 0 ;
12343 char *kwnames[] = {
12344 (char *) "self", NULL
12345 };
12346
12347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12349 if (SWIG_arg_fail(1)) SWIG_fail;
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 result = (int)(arg1)->GetPollingMin();
12353
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 {
12358 resultobj = SWIG_From_int((int)(result));
12359 }
12360 return resultobj;
12361 fail:
12362 return NULL;
12363 }
12364
12365
12366 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12367 PyObject *resultobj;
12368 wxJoystick *arg1 = (wxJoystick *) 0 ;
12369 int result;
12370 PyObject * obj0 = 0 ;
12371 char *kwnames[] = {
12372 (char *) "self", NULL
12373 };
12374
12375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12377 if (SWIG_arg_fail(1)) SWIG_fail;
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 result = (int)(arg1)->GetPollingMax();
12381
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 {
12386 resultobj = SWIG_From_int((int)(result));
12387 }
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12395 PyObject *resultobj;
12396 wxJoystick *arg1 = (wxJoystick *) 0 ;
12397 int result;
12398 PyObject * obj0 = 0 ;
12399 char *kwnames[] = {
12400 (char *) "self", NULL
12401 };
12402
12403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12405 if (SWIG_arg_fail(1)) SWIG_fail;
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 result = (int)(arg1)->GetRudderMin();
12409
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 {
12414 resultobj = SWIG_From_int((int)(result));
12415 }
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj;
12424 wxJoystick *arg1 = (wxJoystick *) 0 ;
12425 int result;
12426 PyObject * obj0 = 0 ;
12427 char *kwnames[] = {
12428 (char *) "self", NULL
12429 };
12430
12431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12433 if (SWIG_arg_fail(1)) SWIG_fail;
12434 {
12435 PyThreadState* __tstate = wxPyBeginAllowThreads();
12436 result = (int)(arg1)->GetRudderMax();
12437
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 {
12442 resultobj = SWIG_From_int((int)(result));
12443 }
12444 return resultobj;
12445 fail:
12446 return NULL;
12447 }
12448
12449
12450 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj;
12452 wxJoystick *arg1 = (wxJoystick *) 0 ;
12453 int result;
12454 PyObject * obj0 = 0 ;
12455 char *kwnames[] = {
12456 (char *) "self", NULL
12457 };
12458
12459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12461 if (SWIG_arg_fail(1)) SWIG_fail;
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 result = (int)(arg1)->GetUMin();
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 {
12470 resultobj = SWIG_From_int((int)(result));
12471 }
12472 return resultobj;
12473 fail:
12474 return NULL;
12475 }
12476
12477
12478 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12479 PyObject *resultobj;
12480 wxJoystick *arg1 = (wxJoystick *) 0 ;
12481 int result;
12482 PyObject * obj0 = 0 ;
12483 char *kwnames[] = {
12484 (char *) "self", NULL
12485 };
12486
12487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12489 if (SWIG_arg_fail(1)) SWIG_fail;
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 result = (int)(arg1)->GetUMax();
12493
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 {
12498 resultobj = SWIG_From_int((int)(result));
12499 }
12500 return resultobj;
12501 fail:
12502 return NULL;
12503 }
12504
12505
12506 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12507 PyObject *resultobj;
12508 wxJoystick *arg1 = (wxJoystick *) 0 ;
12509 int result;
12510 PyObject * obj0 = 0 ;
12511 char *kwnames[] = {
12512 (char *) "self", NULL
12513 };
12514
12515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12517 if (SWIG_arg_fail(1)) SWIG_fail;
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 result = (int)(arg1)->GetVMin();
12521
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 {
12526 resultobj = SWIG_From_int((int)(result));
12527 }
12528 return resultobj;
12529 fail:
12530 return NULL;
12531 }
12532
12533
12534 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12535 PyObject *resultobj;
12536 wxJoystick *arg1 = (wxJoystick *) 0 ;
12537 int result;
12538 PyObject * obj0 = 0 ;
12539 char *kwnames[] = {
12540 (char *) "self", NULL
12541 };
12542
12543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12545 if (SWIG_arg_fail(1)) SWIG_fail;
12546 {
12547 PyThreadState* __tstate = wxPyBeginAllowThreads();
12548 result = (int)(arg1)->GetVMax();
12549
12550 wxPyEndAllowThreads(__tstate);
12551 if (PyErr_Occurred()) SWIG_fail;
12552 }
12553 {
12554 resultobj = SWIG_From_int((int)(result));
12555 }
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj;
12564 wxJoystick *arg1 = (wxJoystick *) 0 ;
12565 bool result;
12566 PyObject * obj0 = 0 ;
12567 char *kwnames[] = {
12568 (char *) "self", NULL
12569 };
12570
12571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12573 if (SWIG_arg_fail(1)) SWIG_fail;
12574 {
12575 PyThreadState* __tstate = wxPyBeginAllowThreads();
12576 result = (bool)(arg1)->HasRudder();
12577
12578 wxPyEndAllowThreads(__tstate);
12579 if (PyErr_Occurred()) SWIG_fail;
12580 }
12581 {
12582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12583 }
12584 return resultobj;
12585 fail:
12586 return NULL;
12587 }
12588
12589
12590 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12591 PyObject *resultobj;
12592 wxJoystick *arg1 = (wxJoystick *) 0 ;
12593 bool result;
12594 PyObject * obj0 = 0 ;
12595 char *kwnames[] = {
12596 (char *) "self", NULL
12597 };
12598
12599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12601 if (SWIG_arg_fail(1)) SWIG_fail;
12602 {
12603 PyThreadState* __tstate = wxPyBeginAllowThreads();
12604 result = (bool)(arg1)->HasZ();
12605
12606 wxPyEndAllowThreads(__tstate);
12607 if (PyErr_Occurred()) SWIG_fail;
12608 }
12609 {
12610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12611 }
12612 return resultobj;
12613 fail:
12614 return NULL;
12615 }
12616
12617
12618 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12619 PyObject *resultobj;
12620 wxJoystick *arg1 = (wxJoystick *) 0 ;
12621 bool result;
12622 PyObject * obj0 = 0 ;
12623 char *kwnames[] = {
12624 (char *) "self", NULL
12625 };
12626
12627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12629 if (SWIG_arg_fail(1)) SWIG_fail;
12630 {
12631 PyThreadState* __tstate = wxPyBeginAllowThreads();
12632 result = (bool)(arg1)->HasU();
12633
12634 wxPyEndAllowThreads(__tstate);
12635 if (PyErr_Occurred()) SWIG_fail;
12636 }
12637 {
12638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12639 }
12640 return resultobj;
12641 fail:
12642 return NULL;
12643 }
12644
12645
12646 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12647 PyObject *resultobj;
12648 wxJoystick *arg1 = (wxJoystick *) 0 ;
12649 bool result;
12650 PyObject * obj0 = 0 ;
12651 char *kwnames[] = {
12652 (char *) "self", NULL
12653 };
12654
12655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12657 if (SWIG_arg_fail(1)) SWIG_fail;
12658 {
12659 PyThreadState* __tstate = wxPyBeginAllowThreads();
12660 result = (bool)(arg1)->HasV();
12661
12662 wxPyEndAllowThreads(__tstate);
12663 if (PyErr_Occurred()) SWIG_fail;
12664 }
12665 {
12666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12667 }
12668 return resultobj;
12669 fail:
12670 return NULL;
12671 }
12672
12673
12674 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12675 PyObject *resultobj;
12676 wxJoystick *arg1 = (wxJoystick *) 0 ;
12677 bool result;
12678 PyObject * obj0 = 0 ;
12679 char *kwnames[] = {
12680 (char *) "self", NULL
12681 };
12682
12683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12685 if (SWIG_arg_fail(1)) SWIG_fail;
12686 {
12687 PyThreadState* __tstate = wxPyBeginAllowThreads();
12688 result = (bool)(arg1)->HasPOV();
12689
12690 wxPyEndAllowThreads(__tstate);
12691 if (PyErr_Occurred()) SWIG_fail;
12692 }
12693 {
12694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12695 }
12696 return resultobj;
12697 fail:
12698 return NULL;
12699 }
12700
12701
12702 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12703 PyObject *resultobj;
12704 wxJoystick *arg1 = (wxJoystick *) 0 ;
12705 bool result;
12706 PyObject * obj0 = 0 ;
12707 char *kwnames[] = {
12708 (char *) "self", NULL
12709 };
12710
12711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12713 if (SWIG_arg_fail(1)) SWIG_fail;
12714 {
12715 PyThreadState* __tstate = wxPyBeginAllowThreads();
12716 result = (bool)(arg1)->HasPOV4Dir();
12717
12718 wxPyEndAllowThreads(__tstate);
12719 if (PyErr_Occurred()) SWIG_fail;
12720 }
12721 {
12722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12723 }
12724 return resultobj;
12725 fail:
12726 return NULL;
12727 }
12728
12729
12730 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12731 PyObject *resultobj;
12732 wxJoystick *arg1 = (wxJoystick *) 0 ;
12733 bool result;
12734 PyObject * obj0 = 0 ;
12735 char *kwnames[] = {
12736 (char *) "self", NULL
12737 };
12738
12739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12741 if (SWIG_arg_fail(1)) SWIG_fail;
12742 {
12743 PyThreadState* __tstate = wxPyBeginAllowThreads();
12744 result = (bool)(arg1)->HasPOVCTS();
12745
12746 wxPyEndAllowThreads(__tstate);
12747 if (PyErr_Occurred()) SWIG_fail;
12748 }
12749 {
12750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12751 }
12752 return resultobj;
12753 fail:
12754 return NULL;
12755 }
12756
12757
12758 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12759 PyObject *resultobj;
12760 wxJoystick *arg1 = (wxJoystick *) 0 ;
12761 wxWindow *arg2 = (wxWindow *) 0 ;
12762 int arg3 = (int) 0 ;
12763 bool result;
12764 PyObject * obj0 = 0 ;
12765 PyObject * obj1 = 0 ;
12766 PyObject * obj2 = 0 ;
12767 char *kwnames[] = {
12768 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12769 };
12770
12771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12773 if (SWIG_arg_fail(1)) SWIG_fail;
12774 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12775 if (SWIG_arg_fail(2)) SWIG_fail;
12776 if (obj2) {
12777 {
12778 arg3 = (int)(SWIG_As_int(obj2));
12779 if (SWIG_arg_fail(3)) SWIG_fail;
12780 }
12781 }
12782 {
12783 PyThreadState* __tstate = wxPyBeginAllowThreads();
12784 result = (bool)(arg1)->SetCapture(arg2,arg3);
12785
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 {
12790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12791 }
12792 return resultobj;
12793 fail:
12794 return NULL;
12795 }
12796
12797
12798 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12799 PyObject *resultobj;
12800 wxJoystick *arg1 = (wxJoystick *) 0 ;
12801 bool result;
12802 PyObject * obj0 = 0 ;
12803 char *kwnames[] = {
12804 (char *) "self", NULL
12805 };
12806
12807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12809 if (SWIG_arg_fail(1)) SWIG_fail;
12810 {
12811 PyThreadState* __tstate = wxPyBeginAllowThreads();
12812 result = (bool)(arg1)->ReleaseCapture();
12813
12814 wxPyEndAllowThreads(__tstate);
12815 if (PyErr_Occurred()) SWIG_fail;
12816 }
12817 {
12818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12819 }
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12827 PyObject *obj;
12828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12829 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12830 Py_INCREF(obj);
12831 return Py_BuildValue((char *)"");
12832 }
12833 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12834 PyObject *resultobj;
12835 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12836 int arg2 = (int) 0 ;
12837 int arg3 = (int) wxJOYSTICK1 ;
12838 int arg4 = (int) 0 ;
12839 wxJoystickEvent *result;
12840 PyObject * obj0 = 0 ;
12841 PyObject * obj1 = 0 ;
12842 PyObject * obj2 = 0 ;
12843 PyObject * obj3 = 0 ;
12844 char *kwnames[] = {
12845 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12846 };
12847
12848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12849 if (obj0) {
12850 {
12851 arg1 = (wxEventType)(SWIG_As_int(obj0));
12852 if (SWIG_arg_fail(1)) SWIG_fail;
12853 }
12854 }
12855 if (obj1) {
12856 {
12857 arg2 = (int)(SWIG_As_int(obj1));
12858 if (SWIG_arg_fail(2)) SWIG_fail;
12859 }
12860 }
12861 if (obj2) {
12862 {
12863 arg3 = (int)(SWIG_As_int(obj2));
12864 if (SWIG_arg_fail(3)) SWIG_fail;
12865 }
12866 }
12867 if (obj3) {
12868 {
12869 arg4 = (int)(SWIG_As_int(obj3));
12870 if (SWIG_arg_fail(4)) SWIG_fail;
12871 }
12872 }
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12876
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12881 return resultobj;
12882 fail:
12883 return NULL;
12884 }
12885
12886
12887 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12888 PyObject *resultobj;
12889 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12890 wxPoint result;
12891 PyObject * obj0 = 0 ;
12892 char *kwnames[] = {
12893 (char *) "self", NULL
12894 };
12895
12896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12898 if (SWIG_arg_fail(1)) SWIG_fail;
12899 {
12900 PyThreadState* __tstate = wxPyBeginAllowThreads();
12901 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12902
12903 wxPyEndAllowThreads(__tstate);
12904 if (PyErr_Occurred()) SWIG_fail;
12905 }
12906 {
12907 wxPoint * resultptr;
12908 resultptr = new wxPoint((wxPoint &)(result));
12909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12910 }
12911 return resultobj;
12912 fail:
12913 return NULL;
12914 }
12915
12916
12917 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12918 PyObject *resultobj;
12919 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12920 int result;
12921 PyObject * obj0 = 0 ;
12922 char *kwnames[] = {
12923 (char *) "self", NULL
12924 };
12925
12926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12928 if (SWIG_arg_fail(1)) SWIG_fail;
12929 {
12930 PyThreadState* __tstate = wxPyBeginAllowThreads();
12931 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12932
12933 wxPyEndAllowThreads(__tstate);
12934 if (PyErr_Occurred()) SWIG_fail;
12935 }
12936 {
12937 resultobj = SWIG_From_int((int)(result));
12938 }
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12946 PyObject *resultobj;
12947 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12948 int result;
12949 PyObject * obj0 = 0 ;
12950 char *kwnames[] = {
12951 (char *) "self", NULL
12952 };
12953
12954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12956 if (SWIG_arg_fail(1)) SWIG_fail;
12957 {
12958 PyThreadState* __tstate = wxPyBeginAllowThreads();
12959 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12960
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 {
12965 resultobj = SWIG_From_int((int)(result));
12966 }
12967 return resultobj;
12968 fail:
12969 return NULL;
12970 }
12971
12972
12973 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12974 PyObject *resultobj;
12975 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12976 int result;
12977 PyObject * obj0 = 0 ;
12978 char *kwnames[] = {
12979 (char *) "self", NULL
12980 };
12981
12982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12984 if (SWIG_arg_fail(1)) SWIG_fail;
12985 {
12986 PyThreadState* __tstate = wxPyBeginAllowThreads();
12987 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12988
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 {
12993 resultobj = SWIG_From_int((int)(result));
12994 }
12995 return resultobj;
12996 fail:
12997 return NULL;
12998 }
12999
13000
13001 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13002 PyObject *resultobj;
13003 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13004 int result;
13005 PyObject * obj0 = 0 ;
13006 char *kwnames[] = {
13007 (char *) "self", NULL
13008 };
13009
13010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13012 if (SWIG_arg_fail(1)) SWIG_fail;
13013 {
13014 PyThreadState* __tstate = wxPyBeginAllowThreads();
13015 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13016
13017 wxPyEndAllowThreads(__tstate);
13018 if (PyErr_Occurred()) SWIG_fail;
13019 }
13020 {
13021 resultobj = SWIG_From_int((int)(result));
13022 }
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13030 PyObject *resultobj;
13031 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13032 int arg2 ;
13033 PyObject * obj0 = 0 ;
13034 PyObject * obj1 = 0 ;
13035 char *kwnames[] = {
13036 (char *) "self",(char *) "stick", NULL
13037 };
13038
13039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13041 if (SWIG_arg_fail(1)) SWIG_fail;
13042 {
13043 arg2 = (int)(SWIG_As_int(obj1));
13044 if (SWIG_arg_fail(2)) SWIG_fail;
13045 }
13046 {
13047 PyThreadState* __tstate = wxPyBeginAllowThreads();
13048 (arg1)->SetJoystick(arg2);
13049
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 Py_INCREF(Py_None); resultobj = Py_None;
13054 return resultobj;
13055 fail:
13056 return NULL;
13057 }
13058
13059
13060 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13061 PyObject *resultobj;
13062 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13063 int arg2 ;
13064 PyObject * obj0 = 0 ;
13065 PyObject * obj1 = 0 ;
13066 char *kwnames[] = {
13067 (char *) "self",(char *) "state", NULL
13068 };
13069
13070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13072 if (SWIG_arg_fail(1)) SWIG_fail;
13073 {
13074 arg2 = (int)(SWIG_As_int(obj1));
13075 if (SWIG_arg_fail(2)) SWIG_fail;
13076 }
13077 {
13078 PyThreadState* __tstate = wxPyBeginAllowThreads();
13079 (arg1)->SetButtonState(arg2);
13080
13081 wxPyEndAllowThreads(__tstate);
13082 if (PyErr_Occurred()) SWIG_fail;
13083 }
13084 Py_INCREF(Py_None); resultobj = Py_None;
13085 return resultobj;
13086 fail:
13087 return NULL;
13088 }
13089
13090
13091 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13092 PyObject *resultobj;
13093 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13094 int arg2 ;
13095 PyObject * obj0 = 0 ;
13096 PyObject * obj1 = 0 ;
13097 char *kwnames[] = {
13098 (char *) "self",(char *) "change", NULL
13099 };
13100
13101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13103 if (SWIG_arg_fail(1)) SWIG_fail;
13104 {
13105 arg2 = (int)(SWIG_As_int(obj1));
13106 if (SWIG_arg_fail(2)) SWIG_fail;
13107 }
13108 {
13109 PyThreadState* __tstate = wxPyBeginAllowThreads();
13110 (arg1)->SetButtonChange(arg2);
13111
13112 wxPyEndAllowThreads(__tstate);
13113 if (PyErr_Occurred()) SWIG_fail;
13114 }
13115 Py_INCREF(Py_None); resultobj = Py_None;
13116 return resultobj;
13117 fail:
13118 return NULL;
13119 }
13120
13121
13122 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13123 PyObject *resultobj;
13124 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13125 wxPoint *arg2 = 0 ;
13126 wxPoint temp2 ;
13127 PyObject * obj0 = 0 ;
13128 PyObject * obj1 = 0 ;
13129 char *kwnames[] = {
13130 (char *) "self",(char *) "pos", NULL
13131 };
13132
13133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13135 if (SWIG_arg_fail(1)) SWIG_fail;
13136 {
13137 arg2 = &temp2;
13138 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13139 }
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 (arg1)->SetPosition((wxPoint const &)*arg2);
13143
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 Py_INCREF(Py_None); resultobj = Py_None;
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj;
13156 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13157 int arg2 ;
13158 PyObject * obj0 = 0 ;
13159 PyObject * obj1 = 0 ;
13160 char *kwnames[] = {
13161 (char *) "self",(char *) "zPos", NULL
13162 };
13163
13164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13166 if (SWIG_arg_fail(1)) SWIG_fail;
13167 {
13168 arg2 = (int)(SWIG_As_int(obj1));
13169 if (SWIG_arg_fail(2)) SWIG_fail;
13170 }
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 (arg1)->SetZPosition(arg2);
13174
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 Py_INCREF(Py_None); resultobj = Py_None;
13179 return resultobj;
13180 fail:
13181 return NULL;
13182 }
13183
13184
13185 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13186 PyObject *resultobj;
13187 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13188 bool result;
13189 PyObject * obj0 = 0 ;
13190 char *kwnames[] = {
13191 (char *) "self", NULL
13192 };
13193
13194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13196 if (SWIG_arg_fail(1)) SWIG_fail;
13197 {
13198 PyThreadState* __tstate = wxPyBeginAllowThreads();
13199 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13200
13201 wxPyEndAllowThreads(__tstate);
13202 if (PyErr_Occurred()) SWIG_fail;
13203 }
13204 {
13205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13206 }
13207 return resultobj;
13208 fail:
13209 return NULL;
13210 }
13211
13212
13213 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13214 PyObject *resultobj;
13215 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13216 bool result;
13217 PyObject * obj0 = 0 ;
13218 char *kwnames[] = {
13219 (char *) "self", NULL
13220 };
13221
13222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13224 if (SWIG_arg_fail(1)) SWIG_fail;
13225 {
13226 PyThreadState* __tstate = wxPyBeginAllowThreads();
13227 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13228
13229 wxPyEndAllowThreads(__tstate);
13230 if (PyErr_Occurred()) SWIG_fail;
13231 }
13232 {
13233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13234 }
13235 return resultobj;
13236 fail:
13237 return NULL;
13238 }
13239
13240
13241 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13242 PyObject *resultobj;
13243 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13244 bool result;
13245 PyObject * obj0 = 0 ;
13246 char *kwnames[] = {
13247 (char *) "self", NULL
13248 };
13249
13250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13252 if (SWIG_arg_fail(1)) SWIG_fail;
13253 {
13254 PyThreadState* __tstate = wxPyBeginAllowThreads();
13255 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13256
13257 wxPyEndAllowThreads(__tstate);
13258 if (PyErr_Occurred()) SWIG_fail;
13259 }
13260 {
13261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13262 }
13263 return resultobj;
13264 fail:
13265 return NULL;
13266 }
13267
13268
13269 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13270 PyObject *resultobj;
13271 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13272 int arg2 = (int) wxJOY_BUTTON_ANY ;
13273 bool result;
13274 PyObject * obj0 = 0 ;
13275 PyObject * obj1 = 0 ;
13276 char *kwnames[] = {
13277 (char *) "self",(char *) "but", NULL
13278 };
13279
13280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13282 if (SWIG_arg_fail(1)) SWIG_fail;
13283 if (obj1) {
13284 {
13285 arg2 = (int)(SWIG_As_int(obj1));
13286 if (SWIG_arg_fail(2)) SWIG_fail;
13287 }
13288 }
13289 {
13290 PyThreadState* __tstate = wxPyBeginAllowThreads();
13291 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13292
13293 wxPyEndAllowThreads(__tstate);
13294 if (PyErr_Occurred()) SWIG_fail;
13295 }
13296 {
13297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13298 }
13299 return resultobj;
13300 fail:
13301 return NULL;
13302 }
13303
13304
13305 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13306 PyObject *resultobj;
13307 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13308 int arg2 = (int) wxJOY_BUTTON_ANY ;
13309 bool result;
13310 PyObject * obj0 = 0 ;
13311 PyObject * obj1 = 0 ;
13312 char *kwnames[] = {
13313 (char *) "self",(char *) "but", NULL
13314 };
13315
13316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13318 if (SWIG_arg_fail(1)) SWIG_fail;
13319 if (obj1) {
13320 {
13321 arg2 = (int)(SWIG_As_int(obj1));
13322 if (SWIG_arg_fail(2)) SWIG_fail;
13323 }
13324 }
13325 {
13326 PyThreadState* __tstate = wxPyBeginAllowThreads();
13327 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13328
13329 wxPyEndAllowThreads(__tstate);
13330 if (PyErr_Occurred()) SWIG_fail;
13331 }
13332 {
13333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13334 }
13335 return resultobj;
13336 fail:
13337 return NULL;
13338 }
13339
13340
13341 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13342 PyObject *resultobj;
13343 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13344 int arg2 = (int) wxJOY_BUTTON_ANY ;
13345 bool result;
13346 PyObject * obj0 = 0 ;
13347 PyObject * obj1 = 0 ;
13348 char *kwnames[] = {
13349 (char *) "self",(char *) "but", NULL
13350 };
13351
13352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13354 if (SWIG_arg_fail(1)) SWIG_fail;
13355 if (obj1) {
13356 {
13357 arg2 = (int)(SWIG_As_int(obj1));
13358 if (SWIG_arg_fail(2)) SWIG_fail;
13359 }
13360 }
13361 {
13362 PyThreadState* __tstate = wxPyBeginAllowThreads();
13363 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13364
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 {
13369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13370 }
13371 return resultobj;
13372 fail:
13373 return NULL;
13374 }
13375
13376
13377 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13378 PyObject *obj;
13379 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13380 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13381 Py_INCREF(obj);
13382 return Py_BuildValue((char *)"");
13383 }
13384 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13385 PyObject *resultobj;
13386 wxString const &arg1_defvalue = wxPyEmptyString ;
13387 wxString *arg1 = (wxString *) &arg1_defvalue ;
13388 wxSound *result;
13389 bool temp1 = false ;
13390 PyObject * obj0 = 0 ;
13391 char *kwnames[] = {
13392 (char *) "fileName", NULL
13393 };
13394
13395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13396 if (obj0) {
13397 {
13398 arg1 = wxString_in_helper(obj0);
13399 if (arg1 == NULL) SWIG_fail;
13400 temp1 = true;
13401 }
13402 }
13403 {
13404 if (!wxPyCheckForApp()) SWIG_fail;
13405 PyThreadState* __tstate = wxPyBeginAllowThreads();
13406 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13407
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13412 {
13413 if (temp1)
13414 delete arg1;
13415 }
13416 return resultobj;
13417 fail:
13418 {
13419 if (temp1)
13420 delete arg1;
13421 }
13422 return NULL;
13423 }
13424
13425
13426 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13427 PyObject *resultobj;
13428 PyObject *arg1 = (PyObject *) 0 ;
13429 wxSound *result;
13430 PyObject * obj0 = 0 ;
13431 char *kwnames[] = {
13432 (char *) "data", NULL
13433 };
13434
13435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13436 arg1 = obj0;
13437 {
13438 if (!wxPyCheckForApp()) SWIG_fail;
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = (wxSound *)new_wxSound(arg1);
13441
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13446 return resultobj;
13447 fail:
13448 return NULL;
13449 }
13450
13451
13452 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj;
13454 wxSound *arg1 = (wxSound *) 0 ;
13455 PyObject * obj0 = 0 ;
13456 char *kwnames[] = {
13457 (char *) "self", NULL
13458 };
13459
13460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13462 if (SWIG_arg_fail(1)) SWIG_fail;
13463 {
13464 PyThreadState* __tstate = wxPyBeginAllowThreads();
13465 delete arg1;
13466
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 Py_INCREF(Py_None); resultobj = Py_None;
13471 return resultobj;
13472 fail:
13473 return NULL;
13474 }
13475
13476
13477 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13478 PyObject *resultobj;
13479 wxSound *arg1 = (wxSound *) 0 ;
13480 wxString *arg2 = 0 ;
13481 bool result;
13482 bool temp2 = false ;
13483 PyObject * obj0 = 0 ;
13484 PyObject * obj1 = 0 ;
13485 char *kwnames[] = {
13486 (char *) "self",(char *) "fileName", NULL
13487 };
13488
13489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13491 if (SWIG_arg_fail(1)) SWIG_fail;
13492 {
13493 arg2 = wxString_in_helper(obj1);
13494 if (arg2 == NULL) SWIG_fail;
13495 temp2 = true;
13496 }
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = (bool)(arg1)->Create((wxString const &)*arg2);
13500
13501 wxPyEndAllowThreads(__tstate);
13502 if (PyErr_Occurred()) SWIG_fail;
13503 }
13504 {
13505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13506 }
13507 {
13508 if (temp2)
13509 delete arg2;
13510 }
13511 return resultobj;
13512 fail:
13513 {
13514 if (temp2)
13515 delete arg2;
13516 }
13517 return NULL;
13518 }
13519
13520
13521 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13522 PyObject *resultobj;
13523 wxSound *arg1 = (wxSound *) 0 ;
13524 PyObject *arg2 = (PyObject *) 0 ;
13525 bool result;
13526 PyObject * obj0 = 0 ;
13527 PyObject * obj1 = 0 ;
13528 char *kwnames[] = {
13529 (char *) "self",(char *) "data", NULL
13530 };
13531
13532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13534 if (SWIG_arg_fail(1)) SWIG_fail;
13535 arg2 = obj1;
13536 {
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 result = (bool)wxSound_CreateFromData(arg1,arg2);
13539
13540 wxPyEndAllowThreads(__tstate);
13541 if (PyErr_Occurred()) SWIG_fail;
13542 }
13543 {
13544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13545 }
13546 return resultobj;
13547 fail:
13548 return NULL;
13549 }
13550
13551
13552 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj;
13554 wxSound *arg1 = (wxSound *) 0 ;
13555 bool result;
13556 PyObject * obj0 = 0 ;
13557 char *kwnames[] = {
13558 (char *) "self", NULL
13559 };
13560
13561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13563 if (SWIG_arg_fail(1)) SWIG_fail;
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 result = (bool)(arg1)->IsOk();
13567
13568 wxPyEndAllowThreads(__tstate);
13569 if (PyErr_Occurred()) SWIG_fail;
13570 }
13571 {
13572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13573 }
13574 return resultobj;
13575 fail:
13576 return NULL;
13577 }
13578
13579
13580 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13581 PyObject *resultobj;
13582 wxSound *arg1 = (wxSound *) 0 ;
13583 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13584 bool result;
13585 PyObject * obj0 = 0 ;
13586 PyObject * obj1 = 0 ;
13587 char *kwnames[] = {
13588 (char *) "self",(char *) "flags", NULL
13589 };
13590
13591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13593 if (SWIG_arg_fail(1)) SWIG_fail;
13594 if (obj1) {
13595 {
13596 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13597 if (SWIG_arg_fail(2)) SWIG_fail;
13598 }
13599 }
13600 {
13601 if (!wxPyCheckForApp()) SWIG_fail;
13602 PyThreadState* __tstate = wxPyBeginAllowThreads();
13603 result = (bool)((wxSound const *)arg1)->Play(arg2);
13604
13605 wxPyEndAllowThreads(__tstate);
13606 if (PyErr_Occurred()) SWIG_fail;
13607 }
13608 {
13609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13610 }
13611 return resultobj;
13612 fail:
13613 return NULL;
13614 }
13615
13616
13617 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13618 PyObject *resultobj;
13619 wxString *arg1 = 0 ;
13620 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13621 bool result;
13622 bool temp1 = false ;
13623 PyObject * obj0 = 0 ;
13624 PyObject * obj1 = 0 ;
13625 char *kwnames[] = {
13626 (char *) "filename",(char *) "flags", NULL
13627 };
13628
13629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13630 {
13631 arg1 = wxString_in_helper(obj0);
13632 if (arg1 == NULL) SWIG_fail;
13633 temp1 = true;
13634 }
13635 if (obj1) {
13636 {
13637 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13638 if (SWIG_arg_fail(2)) SWIG_fail;
13639 }
13640 }
13641 {
13642 if (!wxPyCheckForApp()) SWIG_fail;
13643 PyThreadState* __tstate = wxPyBeginAllowThreads();
13644 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13645
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 {
13650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13651 }
13652 {
13653 if (temp1)
13654 delete arg1;
13655 }
13656 return resultobj;
13657 fail:
13658 {
13659 if (temp1)
13660 delete arg1;
13661 }
13662 return NULL;
13663 }
13664
13665
13666 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj;
13668 char *kwnames[] = {
13669 NULL
13670 };
13671
13672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13673 {
13674 if (!wxPyCheckForApp()) SWIG_fail;
13675 PyThreadState* __tstate = wxPyBeginAllowThreads();
13676 wxSound::Stop();
13677
13678 wxPyEndAllowThreads(__tstate);
13679 if (PyErr_Occurred()) SWIG_fail;
13680 }
13681 Py_INCREF(Py_None); resultobj = Py_None;
13682 return resultobj;
13683 fail:
13684 return NULL;
13685 }
13686
13687
13688 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13689 PyObject *obj;
13690 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13691 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13692 Py_INCREF(obj);
13693 return Py_BuildValue((char *)"");
13694 }
13695 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13696 PyObject *resultobj;
13697 wxString *arg1 = 0 ;
13698 wxString *arg2 = 0 ;
13699 wxString *arg3 = 0 ;
13700 wxString *arg4 = 0 ;
13701 wxFileTypeInfo *result;
13702 bool temp1 = false ;
13703 bool temp2 = false ;
13704 bool temp3 = false ;
13705 bool temp4 = false ;
13706 PyObject * obj0 = 0 ;
13707 PyObject * obj1 = 0 ;
13708 PyObject * obj2 = 0 ;
13709 PyObject * obj3 = 0 ;
13710 char *kwnames[] = {
13711 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13712 };
13713
13714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13715 {
13716 arg1 = wxString_in_helper(obj0);
13717 if (arg1 == NULL) SWIG_fail;
13718 temp1 = true;
13719 }
13720 {
13721 arg2 = wxString_in_helper(obj1);
13722 if (arg2 == NULL) SWIG_fail;
13723 temp2 = true;
13724 }
13725 {
13726 arg3 = wxString_in_helper(obj2);
13727 if (arg3 == NULL) SWIG_fail;
13728 temp3 = true;
13729 }
13730 {
13731 arg4 = wxString_in_helper(obj3);
13732 if (arg4 == NULL) SWIG_fail;
13733 temp4 = true;
13734 }
13735 {
13736 PyThreadState* __tstate = wxPyBeginAllowThreads();
13737 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13738
13739 wxPyEndAllowThreads(__tstate);
13740 if (PyErr_Occurred()) SWIG_fail;
13741 }
13742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13743 {
13744 if (temp1)
13745 delete arg1;
13746 }
13747 {
13748 if (temp2)
13749 delete arg2;
13750 }
13751 {
13752 if (temp3)
13753 delete arg3;
13754 }
13755 {
13756 if (temp4)
13757 delete arg4;
13758 }
13759 return resultobj;
13760 fail:
13761 {
13762 if (temp1)
13763 delete arg1;
13764 }
13765 {
13766 if (temp2)
13767 delete arg2;
13768 }
13769 {
13770 if (temp3)
13771 delete arg3;
13772 }
13773 {
13774 if (temp4)
13775 delete arg4;
13776 }
13777 return NULL;
13778 }
13779
13780
13781 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13782 PyObject *resultobj;
13783 wxArrayString *arg1 = 0 ;
13784 wxFileTypeInfo *result;
13785 bool temp1 = false ;
13786 PyObject * obj0 = 0 ;
13787 char *kwnames[] = {
13788 (char *) "sArray", NULL
13789 };
13790
13791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13792 {
13793 if (! PySequence_Check(obj0)) {
13794 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13795 SWIG_fail;
13796 }
13797 arg1 = new wxArrayString;
13798 temp1 = true;
13799 int i, len=PySequence_Length(obj0);
13800 for (i=0; i<len; i++) {
13801 PyObject* item = PySequence_GetItem(obj0, i);
13802 #if wxUSE_UNICODE
13803 PyObject* str = PyObject_Unicode(item);
13804 #else
13805 PyObject* str = PyObject_Str(item);
13806 #endif
13807 if (PyErr_Occurred()) SWIG_fail;
13808 arg1->Add(Py2wxString(str));
13809 Py_DECREF(item);
13810 Py_DECREF(str);
13811 }
13812 }
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13816
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13821 {
13822 if (temp1) delete arg1;
13823 }
13824 return resultobj;
13825 fail:
13826 {
13827 if (temp1) delete arg1;
13828 }
13829 return NULL;
13830 }
13831
13832
13833 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13834 PyObject *resultobj;
13835 wxFileTypeInfo *result;
13836 char *kwnames[] = {
13837 NULL
13838 };
13839
13840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13841 {
13842 PyThreadState* __tstate = wxPyBeginAllowThreads();
13843 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13844
13845 wxPyEndAllowThreads(__tstate);
13846 if (PyErr_Occurred()) SWIG_fail;
13847 }
13848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13856 PyObject *resultobj;
13857 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13858 bool result;
13859 PyObject * obj0 = 0 ;
13860 char *kwnames[] = {
13861 (char *) "self", NULL
13862 };
13863
13864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13866 if (SWIG_arg_fail(1)) SWIG_fail;
13867 {
13868 PyThreadState* __tstate = wxPyBeginAllowThreads();
13869 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13870
13871 wxPyEndAllowThreads(__tstate);
13872 if (PyErr_Occurred()) SWIG_fail;
13873 }
13874 {
13875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13876 }
13877 return resultobj;
13878 fail:
13879 return NULL;
13880 }
13881
13882
13883 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13884 PyObject *resultobj;
13885 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13886 wxString *arg2 = 0 ;
13887 int arg3 = (int) 0 ;
13888 bool temp2 = false ;
13889 PyObject * obj0 = 0 ;
13890 PyObject * obj1 = 0 ;
13891 PyObject * obj2 = 0 ;
13892 char *kwnames[] = {
13893 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13894 };
13895
13896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13898 if (SWIG_arg_fail(1)) SWIG_fail;
13899 {
13900 arg2 = wxString_in_helper(obj1);
13901 if (arg2 == NULL) SWIG_fail;
13902 temp2 = true;
13903 }
13904 if (obj2) {
13905 {
13906 arg3 = (int)(SWIG_As_int(obj2));
13907 if (SWIG_arg_fail(3)) SWIG_fail;
13908 }
13909 }
13910 {
13911 PyThreadState* __tstate = wxPyBeginAllowThreads();
13912 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13913
13914 wxPyEndAllowThreads(__tstate);
13915 if (PyErr_Occurred()) SWIG_fail;
13916 }
13917 Py_INCREF(Py_None); resultobj = Py_None;
13918 {
13919 if (temp2)
13920 delete arg2;
13921 }
13922 return resultobj;
13923 fail:
13924 {
13925 if (temp2)
13926 delete arg2;
13927 }
13928 return NULL;
13929 }
13930
13931
13932 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13933 PyObject *resultobj;
13934 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13935 wxString *arg2 = 0 ;
13936 bool temp2 = false ;
13937 PyObject * obj0 = 0 ;
13938 PyObject * obj1 = 0 ;
13939 char *kwnames[] = {
13940 (char *) "self",(char *) "shortDesc", NULL
13941 };
13942
13943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13945 if (SWIG_arg_fail(1)) SWIG_fail;
13946 {
13947 arg2 = wxString_in_helper(obj1);
13948 if (arg2 == NULL) SWIG_fail;
13949 temp2 = true;
13950 }
13951 {
13952 PyThreadState* __tstate = wxPyBeginAllowThreads();
13953 (arg1)->SetShortDesc((wxString const &)*arg2);
13954
13955 wxPyEndAllowThreads(__tstate);
13956 if (PyErr_Occurred()) SWIG_fail;
13957 }
13958 Py_INCREF(Py_None); resultobj = Py_None;
13959 {
13960 if (temp2)
13961 delete arg2;
13962 }
13963 return resultobj;
13964 fail:
13965 {
13966 if (temp2)
13967 delete arg2;
13968 }
13969 return NULL;
13970 }
13971
13972
13973 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13974 PyObject *resultobj;
13975 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13976 wxString *result;
13977 PyObject * obj0 = 0 ;
13978 char *kwnames[] = {
13979 (char *) "self", NULL
13980 };
13981
13982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13984 if (SWIG_arg_fail(1)) SWIG_fail;
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 {
13988 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13989 result = (wxString *) &_result_ref;
13990 }
13991
13992 wxPyEndAllowThreads(__tstate);
13993 if (PyErr_Occurred()) SWIG_fail;
13994 }
13995 {
13996 #if wxUSE_UNICODE
13997 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13998 #else
13999 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14000 #endif
14001 }
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14009 PyObject *resultobj;
14010 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14011 wxString *result;
14012 PyObject * obj0 = 0 ;
14013 char *kwnames[] = {
14014 (char *) "self", NULL
14015 };
14016
14017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14019 if (SWIG_arg_fail(1)) SWIG_fail;
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 {
14023 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14024 result = (wxString *) &_result_ref;
14025 }
14026
14027 wxPyEndAllowThreads(__tstate);
14028 if (PyErr_Occurred()) SWIG_fail;
14029 }
14030 {
14031 #if wxUSE_UNICODE
14032 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14033 #else
14034 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14035 #endif
14036 }
14037 return resultobj;
14038 fail:
14039 return NULL;
14040 }
14041
14042
14043 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14044 PyObject *resultobj;
14045 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14046 wxString *result;
14047 PyObject * obj0 = 0 ;
14048 char *kwnames[] = {
14049 (char *) "self", NULL
14050 };
14051
14052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14054 if (SWIG_arg_fail(1)) SWIG_fail;
14055 {
14056 PyThreadState* __tstate = wxPyBeginAllowThreads();
14057 {
14058 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14059 result = (wxString *) &_result_ref;
14060 }
14061
14062 wxPyEndAllowThreads(__tstate);
14063 if (PyErr_Occurred()) SWIG_fail;
14064 }
14065 {
14066 #if wxUSE_UNICODE
14067 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14068 #else
14069 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14070 #endif
14071 }
14072 return resultobj;
14073 fail:
14074 return NULL;
14075 }
14076
14077
14078 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14079 PyObject *resultobj;
14080 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14081 wxString *result;
14082 PyObject * obj0 = 0 ;
14083 char *kwnames[] = {
14084 (char *) "self", NULL
14085 };
14086
14087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14089 if (SWIG_arg_fail(1)) SWIG_fail;
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 {
14093 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14094 result = (wxString *) &_result_ref;
14095 }
14096
14097 wxPyEndAllowThreads(__tstate);
14098 if (PyErr_Occurred()) SWIG_fail;
14099 }
14100 {
14101 #if wxUSE_UNICODE
14102 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14103 #else
14104 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14105 #endif
14106 }
14107 return resultobj;
14108 fail:
14109 return NULL;
14110 }
14111
14112
14113 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj;
14115 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14116 wxString *result;
14117 PyObject * obj0 = 0 ;
14118 char *kwnames[] = {
14119 (char *) "self", NULL
14120 };
14121
14122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14124 if (SWIG_arg_fail(1)) SWIG_fail;
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 {
14128 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14129 result = (wxString *) &_result_ref;
14130 }
14131
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 {
14136 #if wxUSE_UNICODE
14137 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14138 #else
14139 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14140 #endif
14141 }
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14149 PyObject *resultobj;
14150 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14151 wxArrayString *result;
14152 PyObject * obj0 = 0 ;
14153 char *kwnames[] = {
14154 (char *) "self", NULL
14155 };
14156
14157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14159 if (SWIG_arg_fail(1)) SWIG_fail;
14160 {
14161 PyThreadState* __tstate = wxPyBeginAllowThreads();
14162 {
14163 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14164 result = (wxArrayString *) &_result_ref;
14165 }
14166
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 {
14171 resultobj = wxArrayString2PyList_helper(*result);
14172 }
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14180 PyObject *resultobj;
14181 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14182 int result;
14183 PyObject * obj0 = 0 ;
14184 char *kwnames[] = {
14185 (char *) "self", NULL
14186 };
14187
14188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14190 if (SWIG_arg_fail(1)) SWIG_fail;
14191 {
14192 PyThreadState* __tstate = wxPyBeginAllowThreads();
14193 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14194
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 {
14199 resultobj = SWIG_From_int((int)(result));
14200 }
14201 return resultobj;
14202 fail:
14203 return NULL;
14204 }
14205
14206
14207 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14208 PyObject *resultobj;
14209 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14210 wxString *result;
14211 PyObject * obj0 = 0 ;
14212 char *kwnames[] = {
14213 (char *) "self", NULL
14214 };
14215
14216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14218 if (SWIG_arg_fail(1)) SWIG_fail;
14219 {
14220 PyThreadState* __tstate = wxPyBeginAllowThreads();
14221 {
14222 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14223 result = (wxString *) &_result_ref;
14224 }
14225
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 {
14230 #if wxUSE_UNICODE
14231 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14232 #else
14233 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14234 #endif
14235 }
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj;
14244 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14245 int result;
14246 PyObject * obj0 = 0 ;
14247 char *kwnames[] = {
14248 (char *) "self", NULL
14249 };
14250
14251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14253 if (SWIG_arg_fail(1)) SWIG_fail;
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14257
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 {
14262 resultobj = SWIG_From_int((int)(result));
14263 }
14264 return resultobj;
14265 fail:
14266 return NULL;
14267 }
14268
14269
14270 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14271 PyObject *obj;
14272 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14273 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14274 Py_INCREF(obj);
14275 return Py_BuildValue((char *)"");
14276 }
14277 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14278 PyObject *resultobj;
14279 wxFileTypeInfo *arg1 = 0 ;
14280 wxFileType *result;
14281 PyObject * obj0 = 0 ;
14282 char *kwnames[] = {
14283 (char *) "ftInfo", NULL
14284 };
14285
14286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14287 {
14288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14289 if (SWIG_arg_fail(1)) SWIG_fail;
14290 if (arg1 == NULL) {
14291 SWIG_null_ref("wxFileTypeInfo");
14292 }
14293 if (SWIG_arg_fail(1)) SWIG_fail;
14294 }
14295 {
14296 PyThreadState* __tstate = wxPyBeginAllowThreads();
14297 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14298
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14303 return resultobj;
14304 fail:
14305 return NULL;
14306 }
14307
14308
14309 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14310 PyObject *resultobj;
14311 wxFileType *arg1 = (wxFileType *) 0 ;
14312 PyObject * obj0 = 0 ;
14313 char *kwnames[] = {
14314 (char *) "self", NULL
14315 };
14316
14317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14319 if (SWIG_arg_fail(1)) SWIG_fail;
14320 {
14321 PyThreadState* __tstate = wxPyBeginAllowThreads();
14322 delete arg1;
14323
14324 wxPyEndAllowThreads(__tstate);
14325 if (PyErr_Occurred()) SWIG_fail;
14326 }
14327 Py_INCREF(Py_None); resultobj = Py_None;
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14335 PyObject *resultobj;
14336 wxFileType *arg1 = (wxFileType *) 0 ;
14337 PyObject *result;
14338 PyObject * obj0 = 0 ;
14339 char *kwnames[] = {
14340 (char *) "self", NULL
14341 };
14342
14343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14345 if (SWIG_arg_fail(1)) SWIG_fail;
14346 {
14347 PyThreadState* __tstate = wxPyBeginAllowThreads();
14348 result = (PyObject *)wxFileType_GetMimeType(arg1);
14349
14350 wxPyEndAllowThreads(__tstate);
14351 if (PyErr_Occurred()) SWIG_fail;
14352 }
14353 resultobj = result;
14354 return resultobj;
14355 fail:
14356 return NULL;
14357 }
14358
14359
14360 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14361 PyObject *resultobj;
14362 wxFileType *arg1 = (wxFileType *) 0 ;
14363 PyObject *result;
14364 PyObject * obj0 = 0 ;
14365 char *kwnames[] = {
14366 (char *) "self", NULL
14367 };
14368
14369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14371 if (SWIG_arg_fail(1)) SWIG_fail;
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14375
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 resultobj = result;
14380 return resultobj;
14381 fail:
14382 return NULL;
14383 }
14384
14385
14386 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14387 PyObject *resultobj;
14388 wxFileType *arg1 = (wxFileType *) 0 ;
14389 PyObject *result;
14390 PyObject * obj0 = 0 ;
14391 char *kwnames[] = {
14392 (char *) "self", NULL
14393 };
14394
14395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14397 if (SWIG_arg_fail(1)) SWIG_fail;
14398 {
14399 PyThreadState* __tstate = wxPyBeginAllowThreads();
14400 result = (PyObject *)wxFileType_GetExtensions(arg1);
14401
14402 wxPyEndAllowThreads(__tstate);
14403 if (PyErr_Occurred()) SWIG_fail;
14404 }
14405 resultobj = result;
14406 return resultobj;
14407 fail:
14408 return NULL;
14409 }
14410
14411
14412 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14413 PyObject *resultobj;
14414 wxFileType *arg1 = (wxFileType *) 0 ;
14415 wxIcon *result;
14416 PyObject * obj0 = 0 ;
14417 char *kwnames[] = {
14418 (char *) "self", NULL
14419 };
14420
14421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14423 if (SWIG_arg_fail(1)) SWIG_fail;
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (wxIcon *)wxFileType_GetIcon(arg1);
14427
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14439 PyObject *resultobj;
14440 wxFileType *arg1 = (wxFileType *) 0 ;
14441 PyObject *result;
14442 PyObject * obj0 = 0 ;
14443 char *kwnames[] = {
14444 (char *) "self", NULL
14445 };
14446
14447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14449 if (SWIG_arg_fail(1)) SWIG_fail;
14450 {
14451 PyThreadState* __tstate = wxPyBeginAllowThreads();
14452 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14453
14454 wxPyEndAllowThreads(__tstate);
14455 if (PyErr_Occurred()) SWIG_fail;
14456 }
14457 resultobj = result;
14458 return resultobj;
14459 fail:
14460 return NULL;
14461 }
14462
14463
14464 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14465 PyObject *resultobj;
14466 wxFileType *arg1 = (wxFileType *) 0 ;
14467 PyObject *result;
14468 PyObject * obj0 = 0 ;
14469 char *kwnames[] = {
14470 (char *) "self", NULL
14471 };
14472
14473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14475 if (SWIG_arg_fail(1)) SWIG_fail;
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 result = (PyObject *)wxFileType_GetDescription(arg1);
14479
14480 wxPyEndAllowThreads(__tstate);
14481 if (PyErr_Occurred()) SWIG_fail;
14482 }
14483 resultobj = result;
14484 return resultobj;
14485 fail:
14486 return NULL;
14487 }
14488
14489
14490 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14491 PyObject *resultobj;
14492 wxFileType *arg1 = (wxFileType *) 0 ;
14493 wxString *arg2 = 0 ;
14494 wxString const &arg3_defvalue = wxPyEmptyString ;
14495 wxString *arg3 = (wxString *) &arg3_defvalue ;
14496 PyObject *result;
14497 bool temp2 = false ;
14498 bool temp3 = false ;
14499 PyObject * obj0 = 0 ;
14500 PyObject * obj1 = 0 ;
14501 PyObject * obj2 = 0 ;
14502 char *kwnames[] = {
14503 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14504 };
14505
14506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14508 if (SWIG_arg_fail(1)) SWIG_fail;
14509 {
14510 arg2 = wxString_in_helper(obj1);
14511 if (arg2 == NULL) SWIG_fail;
14512 temp2 = true;
14513 }
14514 if (obj2) {
14515 {
14516 arg3 = wxString_in_helper(obj2);
14517 if (arg3 == NULL) SWIG_fail;
14518 temp3 = true;
14519 }
14520 }
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14524
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 resultobj = result;
14529 {
14530 if (temp2)
14531 delete arg2;
14532 }
14533 {
14534 if (temp3)
14535 delete arg3;
14536 }
14537 return resultobj;
14538 fail:
14539 {
14540 if (temp2)
14541 delete arg2;
14542 }
14543 {
14544 if (temp3)
14545 delete arg3;
14546 }
14547 return NULL;
14548 }
14549
14550
14551 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14552 PyObject *resultobj;
14553 wxFileType *arg1 = (wxFileType *) 0 ;
14554 wxString *arg2 = 0 ;
14555 wxString const &arg3_defvalue = wxPyEmptyString ;
14556 wxString *arg3 = (wxString *) &arg3_defvalue ;
14557 PyObject *result;
14558 bool temp2 = false ;
14559 bool temp3 = false ;
14560 PyObject * obj0 = 0 ;
14561 PyObject * obj1 = 0 ;
14562 PyObject * obj2 = 0 ;
14563 char *kwnames[] = {
14564 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14565 };
14566
14567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14569 if (SWIG_arg_fail(1)) SWIG_fail;
14570 {
14571 arg2 = wxString_in_helper(obj1);
14572 if (arg2 == NULL) SWIG_fail;
14573 temp2 = true;
14574 }
14575 if (obj2) {
14576 {
14577 arg3 = wxString_in_helper(obj2);
14578 if (arg3 == NULL) SWIG_fail;
14579 temp3 = true;
14580 }
14581 }
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14585
14586 wxPyEndAllowThreads(__tstate);
14587 if (PyErr_Occurred()) SWIG_fail;
14588 }
14589 resultobj = result;
14590 {
14591 if (temp2)
14592 delete arg2;
14593 }
14594 {
14595 if (temp3)
14596 delete arg3;
14597 }
14598 return resultobj;
14599 fail:
14600 {
14601 if (temp2)
14602 delete arg2;
14603 }
14604 {
14605 if (temp3)
14606 delete arg3;
14607 }
14608 return NULL;
14609 }
14610
14611
14612 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14613 PyObject *resultobj;
14614 wxFileType *arg1 = (wxFileType *) 0 ;
14615 wxString *arg2 = 0 ;
14616 wxString const &arg3_defvalue = wxPyEmptyString ;
14617 wxString *arg3 = (wxString *) &arg3_defvalue ;
14618 PyObject *result;
14619 bool temp2 = false ;
14620 bool temp3 = false ;
14621 PyObject * obj0 = 0 ;
14622 PyObject * obj1 = 0 ;
14623 PyObject * obj2 = 0 ;
14624 char *kwnames[] = {
14625 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14626 };
14627
14628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14630 if (SWIG_arg_fail(1)) SWIG_fail;
14631 {
14632 arg2 = wxString_in_helper(obj1);
14633 if (arg2 == NULL) SWIG_fail;
14634 temp2 = true;
14635 }
14636 if (obj2) {
14637 {
14638 arg3 = wxString_in_helper(obj2);
14639 if (arg3 == NULL) SWIG_fail;
14640 temp3 = true;
14641 }
14642 }
14643 {
14644 PyThreadState* __tstate = wxPyBeginAllowThreads();
14645 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14646
14647 wxPyEndAllowThreads(__tstate);
14648 if (PyErr_Occurred()) SWIG_fail;
14649 }
14650 resultobj = result;
14651 {
14652 if (temp2)
14653 delete arg2;
14654 }
14655 {
14656 if (temp3)
14657 delete arg3;
14658 }
14659 return resultobj;
14660 fail:
14661 {
14662 if (temp2)
14663 delete arg2;
14664 }
14665 {
14666 if (temp3)
14667 delete arg3;
14668 }
14669 return NULL;
14670 }
14671
14672
14673 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14674 PyObject *resultobj;
14675 wxFileType *arg1 = (wxFileType *) 0 ;
14676 wxString *arg2 = 0 ;
14677 wxString *arg3 = 0 ;
14678 bool arg4 = (bool) true ;
14679 bool result;
14680 bool temp2 = false ;
14681 bool temp3 = false ;
14682 PyObject * obj0 = 0 ;
14683 PyObject * obj1 = 0 ;
14684 PyObject * obj2 = 0 ;
14685 PyObject * obj3 = 0 ;
14686 char *kwnames[] = {
14687 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14688 };
14689
14690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14692 if (SWIG_arg_fail(1)) SWIG_fail;
14693 {
14694 arg2 = wxString_in_helper(obj1);
14695 if (arg2 == NULL) SWIG_fail;
14696 temp2 = true;
14697 }
14698 {
14699 arg3 = wxString_in_helper(obj2);
14700 if (arg3 == NULL) SWIG_fail;
14701 temp3 = true;
14702 }
14703 if (obj3) {
14704 {
14705 arg4 = (bool)(SWIG_As_bool(obj3));
14706 if (SWIG_arg_fail(4)) SWIG_fail;
14707 }
14708 }
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14712
14713 wxPyEndAllowThreads(__tstate);
14714 if (PyErr_Occurred()) SWIG_fail;
14715 }
14716 {
14717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14718 }
14719 {
14720 if (temp2)
14721 delete arg2;
14722 }
14723 {
14724 if (temp3)
14725 delete arg3;
14726 }
14727 return resultobj;
14728 fail:
14729 {
14730 if (temp2)
14731 delete arg2;
14732 }
14733 {
14734 if (temp3)
14735 delete arg3;
14736 }
14737 return NULL;
14738 }
14739
14740
14741 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14742 PyObject *resultobj;
14743 wxFileType *arg1 = (wxFileType *) 0 ;
14744 wxString const &arg2_defvalue = wxPyEmptyString ;
14745 wxString *arg2 = (wxString *) &arg2_defvalue ;
14746 int arg3 = (int) 0 ;
14747 bool result;
14748 bool temp2 = false ;
14749 PyObject * obj0 = 0 ;
14750 PyObject * obj1 = 0 ;
14751 PyObject * obj2 = 0 ;
14752 char *kwnames[] = {
14753 (char *) "self",(char *) "cmd",(char *) "index", NULL
14754 };
14755
14756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14758 if (SWIG_arg_fail(1)) SWIG_fail;
14759 if (obj1) {
14760 {
14761 arg2 = wxString_in_helper(obj1);
14762 if (arg2 == NULL) SWIG_fail;
14763 temp2 = true;
14764 }
14765 }
14766 if (obj2) {
14767 {
14768 arg3 = (int)(SWIG_As_int(obj2));
14769 if (SWIG_arg_fail(3)) SWIG_fail;
14770 }
14771 }
14772 {
14773 PyThreadState* __tstate = wxPyBeginAllowThreads();
14774 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14775
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 {
14780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14781 }
14782 {
14783 if (temp2)
14784 delete arg2;
14785 }
14786 return resultobj;
14787 fail:
14788 {
14789 if (temp2)
14790 delete arg2;
14791 }
14792 return NULL;
14793 }
14794
14795
14796 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj;
14798 wxFileType *arg1 = (wxFileType *) 0 ;
14799 bool result;
14800 PyObject * obj0 = 0 ;
14801 char *kwnames[] = {
14802 (char *) "self", NULL
14803 };
14804
14805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14807 if (SWIG_arg_fail(1)) SWIG_fail;
14808 {
14809 PyThreadState* __tstate = wxPyBeginAllowThreads();
14810 result = (bool)(arg1)->Unassociate();
14811
14812 wxPyEndAllowThreads(__tstate);
14813 if (PyErr_Occurred()) SWIG_fail;
14814 }
14815 {
14816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14817 }
14818 return resultobj;
14819 fail:
14820 return NULL;
14821 }
14822
14823
14824 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14825 PyObject *resultobj;
14826 wxString *arg1 = 0 ;
14827 wxString *arg2 = 0 ;
14828 wxString const &arg3_defvalue = wxPyEmptyString ;
14829 wxString *arg3 = (wxString *) &arg3_defvalue ;
14830 wxString result;
14831 bool temp1 = false ;
14832 bool temp2 = false ;
14833 bool temp3 = false ;
14834 PyObject * obj0 = 0 ;
14835 PyObject * obj1 = 0 ;
14836 PyObject * obj2 = 0 ;
14837 char *kwnames[] = {
14838 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14839 };
14840
14841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14842 {
14843 arg1 = wxString_in_helper(obj0);
14844 if (arg1 == NULL) SWIG_fail;
14845 temp1 = true;
14846 }
14847 {
14848 arg2 = wxString_in_helper(obj1);
14849 if (arg2 == NULL) SWIG_fail;
14850 temp2 = true;
14851 }
14852 if (obj2) {
14853 {
14854 arg3 = wxString_in_helper(obj2);
14855 if (arg3 == NULL) SWIG_fail;
14856 temp3 = true;
14857 }
14858 }
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14862
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 {
14867 #if wxUSE_UNICODE
14868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14869 #else
14870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14871 #endif
14872 }
14873 {
14874 if (temp1)
14875 delete arg1;
14876 }
14877 {
14878 if (temp2)
14879 delete arg2;
14880 }
14881 {
14882 if (temp3)
14883 delete arg3;
14884 }
14885 return resultobj;
14886 fail:
14887 {
14888 if (temp1)
14889 delete arg1;
14890 }
14891 {
14892 if (temp2)
14893 delete arg2;
14894 }
14895 {
14896 if (temp3)
14897 delete arg3;
14898 }
14899 return NULL;
14900 }
14901
14902
14903 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14904 PyObject *obj;
14905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14906 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14907 Py_INCREF(obj);
14908 return Py_BuildValue((char *)"");
14909 }
14910 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14911 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14912 return 1;
14913 }
14914
14915
14916 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14917 PyObject *pyobj;
14918
14919 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14920 return pyobj;
14921 }
14922
14923
14924 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14925 PyObject *resultobj;
14926 wxString *arg1 = 0 ;
14927 wxString *arg2 = 0 ;
14928 bool result;
14929 bool temp1 = false ;
14930 bool temp2 = false ;
14931 PyObject * obj0 = 0 ;
14932 PyObject * obj1 = 0 ;
14933 char *kwnames[] = {
14934 (char *) "mimeType",(char *) "wildcard", NULL
14935 };
14936
14937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14938 {
14939 arg1 = wxString_in_helper(obj0);
14940 if (arg1 == NULL) SWIG_fail;
14941 temp1 = true;
14942 }
14943 {
14944 arg2 = wxString_in_helper(obj1);
14945 if (arg2 == NULL) SWIG_fail;
14946 temp2 = true;
14947 }
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14951
14952 wxPyEndAllowThreads(__tstate);
14953 if (PyErr_Occurred()) SWIG_fail;
14954 }
14955 {
14956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14957 }
14958 {
14959 if (temp1)
14960 delete arg1;
14961 }
14962 {
14963 if (temp2)
14964 delete arg2;
14965 }
14966 return resultobj;
14967 fail:
14968 {
14969 if (temp1)
14970 delete arg1;
14971 }
14972 {
14973 if (temp2)
14974 delete arg2;
14975 }
14976 return NULL;
14977 }
14978
14979
14980 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14981 PyObject *resultobj;
14982 wxMimeTypesManager *result;
14983 char *kwnames[] = {
14984 NULL
14985 };
14986
14987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14988 {
14989 PyThreadState* __tstate = wxPyBeginAllowThreads();
14990 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14991
14992 wxPyEndAllowThreads(__tstate);
14993 if (PyErr_Occurred()) SWIG_fail;
14994 }
14995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14996 return resultobj;
14997 fail:
14998 return NULL;
14999 }
15000
15001
15002 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15003 PyObject *resultobj;
15004 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15005 int arg2 = (int) wxMAILCAP_ALL ;
15006 wxString const &arg3_defvalue = wxPyEmptyString ;
15007 wxString *arg3 = (wxString *) &arg3_defvalue ;
15008 bool temp3 = false ;
15009 PyObject * obj0 = 0 ;
15010 PyObject * obj1 = 0 ;
15011 PyObject * obj2 = 0 ;
15012 char *kwnames[] = {
15013 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15014 };
15015
15016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15018 if (SWIG_arg_fail(1)) SWIG_fail;
15019 if (obj1) {
15020 {
15021 arg2 = (int)(SWIG_As_int(obj1));
15022 if (SWIG_arg_fail(2)) SWIG_fail;
15023 }
15024 }
15025 if (obj2) {
15026 {
15027 arg3 = wxString_in_helper(obj2);
15028 if (arg3 == NULL) SWIG_fail;
15029 temp3 = true;
15030 }
15031 }
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15035
15036 wxPyEndAllowThreads(__tstate);
15037 if (PyErr_Occurred()) SWIG_fail;
15038 }
15039 Py_INCREF(Py_None); resultobj = Py_None;
15040 {
15041 if (temp3)
15042 delete arg3;
15043 }
15044 return resultobj;
15045 fail:
15046 {
15047 if (temp3)
15048 delete arg3;
15049 }
15050 return NULL;
15051 }
15052
15053
15054 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15055 PyObject *resultobj;
15056 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15057 PyObject * obj0 = 0 ;
15058 char *kwnames[] = {
15059 (char *) "self", NULL
15060 };
15061
15062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15064 if (SWIG_arg_fail(1)) SWIG_fail;
15065 {
15066 PyThreadState* __tstate = wxPyBeginAllowThreads();
15067 (arg1)->ClearData();
15068
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 Py_INCREF(Py_None); resultobj = Py_None;
15073 return resultobj;
15074 fail:
15075 return NULL;
15076 }
15077
15078
15079 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15080 PyObject *resultobj;
15081 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15082 wxString *arg2 = 0 ;
15083 wxFileType *result;
15084 bool temp2 = false ;
15085 PyObject * obj0 = 0 ;
15086 PyObject * obj1 = 0 ;
15087 char *kwnames[] = {
15088 (char *) "self",(char *) "ext", NULL
15089 };
15090
15091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15093 if (SWIG_arg_fail(1)) SWIG_fail;
15094 {
15095 arg2 = wxString_in_helper(obj1);
15096 if (arg2 == NULL) SWIG_fail;
15097 temp2 = true;
15098 }
15099 {
15100 PyThreadState* __tstate = wxPyBeginAllowThreads();
15101 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15102
15103 wxPyEndAllowThreads(__tstate);
15104 if (PyErr_Occurred()) SWIG_fail;
15105 }
15106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15107 {
15108 if (temp2)
15109 delete arg2;
15110 }
15111 return resultobj;
15112 fail:
15113 {
15114 if (temp2)
15115 delete arg2;
15116 }
15117 return NULL;
15118 }
15119
15120
15121 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15122 PyObject *resultobj;
15123 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15124 wxString *arg2 = 0 ;
15125 wxFileType *result;
15126 bool temp2 = false ;
15127 PyObject * obj0 = 0 ;
15128 PyObject * obj1 = 0 ;
15129 char *kwnames[] = {
15130 (char *) "self",(char *) "mimeType", NULL
15131 };
15132
15133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
15138 if (arg2 == NULL) SWIG_fail;
15139 temp2 = true;
15140 }
15141 {
15142 PyThreadState* __tstate = wxPyBeginAllowThreads();
15143 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15144
15145 wxPyEndAllowThreads(__tstate);
15146 if (PyErr_Occurred()) SWIG_fail;
15147 }
15148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15149 {
15150 if (temp2)
15151 delete arg2;
15152 }
15153 return resultobj;
15154 fail:
15155 {
15156 if (temp2)
15157 delete arg2;
15158 }
15159 return NULL;
15160 }
15161
15162
15163 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15164 PyObject *resultobj;
15165 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15166 wxString *arg2 = 0 ;
15167 bool arg3 = (bool) false ;
15168 bool result;
15169 bool temp2 = false ;
15170 PyObject * obj0 = 0 ;
15171 PyObject * obj1 = 0 ;
15172 PyObject * obj2 = 0 ;
15173 char *kwnames[] = {
15174 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15175 };
15176
15177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15179 if (SWIG_arg_fail(1)) SWIG_fail;
15180 {
15181 arg2 = wxString_in_helper(obj1);
15182 if (arg2 == NULL) SWIG_fail;
15183 temp2 = true;
15184 }
15185 if (obj2) {
15186 {
15187 arg3 = (bool)(SWIG_As_bool(obj2));
15188 if (SWIG_arg_fail(3)) SWIG_fail;
15189 }
15190 }
15191 {
15192 PyThreadState* __tstate = wxPyBeginAllowThreads();
15193 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15194
15195 wxPyEndAllowThreads(__tstate);
15196 if (PyErr_Occurred()) SWIG_fail;
15197 }
15198 {
15199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15200 }
15201 {
15202 if (temp2)
15203 delete arg2;
15204 }
15205 return resultobj;
15206 fail:
15207 {
15208 if (temp2)
15209 delete arg2;
15210 }
15211 return NULL;
15212 }
15213
15214
15215 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15216 PyObject *resultobj;
15217 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15218 wxString *arg2 = 0 ;
15219 bool result;
15220 bool temp2 = false ;
15221 PyObject * obj0 = 0 ;
15222 PyObject * obj1 = 0 ;
15223 char *kwnames[] = {
15224 (char *) "self",(char *) "filename", NULL
15225 };
15226
15227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15229 if (SWIG_arg_fail(1)) SWIG_fail;
15230 {
15231 arg2 = wxString_in_helper(obj1);
15232 if (arg2 == NULL) SWIG_fail;
15233 temp2 = true;
15234 }
15235 {
15236 PyThreadState* __tstate = wxPyBeginAllowThreads();
15237 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15238
15239 wxPyEndAllowThreads(__tstate);
15240 if (PyErr_Occurred()) SWIG_fail;
15241 }
15242 {
15243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15244 }
15245 {
15246 if (temp2)
15247 delete arg2;
15248 }
15249 return resultobj;
15250 fail:
15251 {
15252 if (temp2)
15253 delete arg2;
15254 }
15255 return NULL;
15256 }
15257
15258
15259 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15260 PyObject *resultobj;
15261 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15262 PyObject *result;
15263 PyObject * obj0 = 0 ;
15264 char *kwnames[] = {
15265 (char *) "self", NULL
15266 };
15267
15268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15270 if (SWIG_arg_fail(1)) SWIG_fail;
15271 {
15272 PyThreadState* __tstate = wxPyBeginAllowThreads();
15273 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15274
15275 wxPyEndAllowThreads(__tstate);
15276 if (PyErr_Occurred()) SWIG_fail;
15277 }
15278 resultobj = result;
15279 return resultobj;
15280 fail:
15281 return NULL;
15282 }
15283
15284
15285 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15286 PyObject *resultobj;
15287 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15288 wxFileTypeInfo *arg2 = 0 ;
15289 PyObject * obj0 = 0 ;
15290 PyObject * obj1 = 0 ;
15291 char *kwnames[] = {
15292 (char *) "self",(char *) "ft", NULL
15293 };
15294
15295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15297 if (SWIG_arg_fail(1)) SWIG_fail;
15298 {
15299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15300 if (SWIG_arg_fail(2)) SWIG_fail;
15301 if (arg2 == NULL) {
15302 SWIG_null_ref("wxFileTypeInfo");
15303 }
15304 if (SWIG_arg_fail(2)) SWIG_fail;
15305 }
15306 {
15307 PyThreadState* __tstate = wxPyBeginAllowThreads();
15308 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15309
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 Py_INCREF(Py_None); resultobj = Py_None;
15314 return resultobj;
15315 fail:
15316 return NULL;
15317 }
15318
15319
15320 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15321 PyObject *resultobj;
15322 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15323 wxFileTypeInfo *arg2 = 0 ;
15324 wxFileType *result;
15325 PyObject * obj0 = 0 ;
15326 PyObject * obj1 = 0 ;
15327 char *kwnames[] = {
15328 (char *) "self",(char *) "ftInfo", NULL
15329 };
15330
15331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15333 if (SWIG_arg_fail(1)) SWIG_fail;
15334 {
15335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15336 if (SWIG_arg_fail(2)) SWIG_fail;
15337 if (arg2 == NULL) {
15338 SWIG_null_ref("wxFileTypeInfo");
15339 }
15340 if (SWIG_arg_fail(2)) SWIG_fail;
15341 }
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15345
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15350 return resultobj;
15351 fail:
15352 return NULL;
15353 }
15354
15355
15356 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15357 PyObject *resultobj;
15358 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15359 wxFileType *arg2 = (wxFileType *) 0 ;
15360 bool result;
15361 PyObject * obj0 = 0 ;
15362 PyObject * obj1 = 0 ;
15363 char *kwnames[] = {
15364 (char *) "self",(char *) "ft", NULL
15365 };
15366
15367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15369 if (SWIG_arg_fail(1)) SWIG_fail;
15370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15371 if (SWIG_arg_fail(2)) SWIG_fail;
15372 {
15373 PyThreadState* __tstate = wxPyBeginAllowThreads();
15374 result = (bool)(arg1)->Unassociate(arg2);
15375
15376 wxPyEndAllowThreads(__tstate);
15377 if (PyErr_Occurred()) SWIG_fail;
15378 }
15379 {
15380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15381 }
15382 return resultobj;
15383 fail:
15384 return NULL;
15385 }
15386
15387
15388 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15389 PyObject *resultobj;
15390 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15391 PyObject * obj0 = 0 ;
15392 char *kwnames[] = {
15393 (char *) "self", NULL
15394 };
15395
15396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15398 if (SWIG_arg_fail(1)) SWIG_fail;
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 delete arg1;
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 Py_INCREF(Py_None); resultobj = Py_None;
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15414 PyObject *obj;
15415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15416 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15417 Py_INCREF(obj);
15418 return Py_BuildValue((char *)"");
15419 }
15420 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15421 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15422 return 1;
15423 }
15424
15425
15426 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15427 PyObject *pyobj;
15428
15429 {
15430 #if wxUSE_UNICODE
15431 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15432 #else
15433 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15434 #endif
15435 }
15436 return pyobj;
15437 }
15438
15439
15440 static int _wrap_ART_MENU_set(PyObject *) {
15441 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15442 return 1;
15443 }
15444
15445
15446 static PyObject *_wrap_ART_MENU_get(void) {
15447 PyObject *pyobj;
15448
15449 {
15450 #if wxUSE_UNICODE
15451 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15452 #else
15453 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15454 #endif
15455 }
15456 return pyobj;
15457 }
15458
15459
15460 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15461 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15462 return 1;
15463 }
15464
15465
15466 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15467 PyObject *pyobj;
15468
15469 {
15470 #if wxUSE_UNICODE
15471 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15472 #else
15473 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15474 #endif
15475 }
15476 return pyobj;
15477 }
15478
15479
15480 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15481 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15482 return 1;
15483 }
15484
15485
15486 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15487 PyObject *pyobj;
15488
15489 {
15490 #if wxUSE_UNICODE
15491 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15492 #else
15493 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15494 #endif
15495 }
15496 return pyobj;
15497 }
15498
15499
15500 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15501 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15502 return 1;
15503 }
15504
15505
15506 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15507 PyObject *pyobj;
15508
15509 {
15510 #if wxUSE_UNICODE
15511 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15512 #else
15513 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15514 #endif
15515 }
15516 return pyobj;
15517 }
15518
15519
15520 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15521 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15522 return 1;
15523 }
15524
15525
15526 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15527 PyObject *pyobj;
15528
15529 {
15530 #if wxUSE_UNICODE
15531 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15532 #else
15533 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15534 #endif
15535 }
15536 return pyobj;
15537 }
15538
15539
15540 static int _wrap_ART_BUTTON_set(PyObject *) {
15541 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15542 return 1;
15543 }
15544
15545
15546 static PyObject *_wrap_ART_BUTTON_get(void) {
15547 PyObject *pyobj;
15548
15549 {
15550 #if wxUSE_UNICODE
15551 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15552 #else
15553 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15554 #endif
15555 }
15556 return pyobj;
15557 }
15558
15559
15560 static int _wrap_ART_OTHER_set(PyObject *) {
15561 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15562 return 1;
15563 }
15564
15565
15566 static PyObject *_wrap_ART_OTHER_get(void) {
15567 PyObject *pyobj;
15568
15569 {
15570 #if wxUSE_UNICODE
15571 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15572 #else
15573 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15574 #endif
15575 }
15576 return pyobj;
15577 }
15578
15579
15580 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15581 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15582 return 1;
15583 }
15584
15585
15586 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15587 PyObject *pyobj;
15588
15589 {
15590 #if wxUSE_UNICODE
15591 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15592 #else
15593 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15594 #endif
15595 }
15596 return pyobj;
15597 }
15598
15599
15600 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15601 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15602 return 1;
15603 }
15604
15605
15606 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15607 PyObject *pyobj;
15608
15609 {
15610 #if wxUSE_UNICODE
15611 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15612 #else
15613 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15614 #endif
15615 }
15616 return pyobj;
15617 }
15618
15619
15620 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15621 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15622 return 1;
15623 }
15624
15625
15626 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15627 PyObject *pyobj;
15628
15629 {
15630 #if wxUSE_UNICODE
15631 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15632 #else
15633 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15634 #endif
15635 }
15636 return pyobj;
15637 }
15638
15639
15640 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15641 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15642 return 1;
15643 }
15644
15645
15646 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15647 PyObject *pyobj;
15648
15649 {
15650 #if wxUSE_UNICODE
15651 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15652 #else
15653 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15654 #endif
15655 }
15656 return pyobj;
15657 }
15658
15659
15660 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15661 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15662 return 1;
15663 }
15664
15665
15666 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15667 PyObject *pyobj;
15668
15669 {
15670 #if wxUSE_UNICODE
15671 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15672 #else
15673 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15674 #endif
15675 }
15676 return pyobj;
15677 }
15678
15679
15680 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15681 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15682 return 1;
15683 }
15684
15685
15686 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15687 PyObject *pyobj;
15688
15689 {
15690 #if wxUSE_UNICODE
15691 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15692 #else
15693 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15694 #endif
15695 }
15696 return pyobj;
15697 }
15698
15699
15700 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15701 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15702 return 1;
15703 }
15704
15705
15706 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15707 PyObject *pyobj;
15708
15709 {
15710 #if wxUSE_UNICODE
15711 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15712 #else
15713 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15714 #endif
15715 }
15716 return pyobj;
15717 }
15718
15719
15720 static int _wrap_ART_GO_BACK_set(PyObject *) {
15721 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15722 return 1;
15723 }
15724
15725
15726 static PyObject *_wrap_ART_GO_BACK_get(void) {
15727 PyObject *pyobj;
15728
15729 {
15730 #if wxUSE_UNICODE
15731 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15732 #else
15733 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15734 #endif
15735 }
15736 return pyobj;
15737 }
15738
15739
15740 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15741 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15742 return 1;
15743 }
15744
15745
15746 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15747 PyObject *pyobj;
15748
15749 {
15750 #if wxUSE_UNICODE
15751 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15752 #else
15753 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15754 #endif
15755 }
15756 return pyobj;
15757 }
15758
15759
15760 static int _wrap_ART_GO_UP_set(PyObject *) {
15761 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15762 return 1;
15763 }
15764
15765
15766 static PyObject *_wrap_ART_GO_UP_get(void) {
15767 PyObject *pyobj;
15768
15769 {
15770 #if wxUSE_UNICODE
15771 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15772 #else
15773 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15774 #endif
15775 }
15776 return pyobj;
15777 }
15778
15779
15780 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15781 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15782 return 1;
15783 }
15784
15785
15786 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15787 PyObject *pyobj;
15788
15789 {
15790 #if wxUSE_UNICODE
15791 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15792 #else
15793 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15794 #endif
15795 }
15796 return pyobj;
15797 }
15798
15799
15800 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15801 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15802 return 1;
15803 }
15804
15805
15806 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15807 PyObject *pyobj;
15808
15809 {
15810 #if wxUSE_UNICODE
15811 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15812 #else
15813 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15814 #endif
15815 }
15816 return pyobj;
15817 }
15818
15819
15820 static int _wrap_ART_GO_HOME_set(PyObject *) {
15821 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15822 return 1;
15823 }
15824
15825
15826 static PyObject *_wrap_ART_GO_HOME_get(void) {
15827 PyObject *pyobj;
15828
15829 {
15830 #if wxUSE_UNICODE
15831 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15832 #else
15833 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15834 #endif
15835 }
15836 return pyobj;
15837 }
15838
15839
15840 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15841 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15842 return 1;
15843 }
15844
15845
15846 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15847 PyObject *pyobj;
15848
15849 {
15850 #if wxUSE_UNICODE
15851 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15852 #else
15853 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15854 #endif
15855 }
15856 return pyobj;
15857 }
15858
15859
15860 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15861 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15862 return 1;
15863 }
15864
15865
15866 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15867 PyObject *pyobj;
15868
15869 {
15870 #if wxUSE_UNICODE
15871 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15872 #else
15873 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15874 #endif
15875 }
15876 return pyobj;
15877 }
15878
15879
15880 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15881 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15882 return 1;
15883 }
15884
15885
15886 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15887 PyObject *pyobj;
15888
15889 {
15890 #if wxUSE_UNICODE
15891 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15892 #else
15893 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15894 #endif
15895 }
15896 return pyobj;
15897 }
15898
15899
15900 static int _wrap_ART_PRINT_set(PyObject *) {
15901 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15902 return 1;
15903 }
15904
15905
15906 static PyObject *_wrap_ART_PRINT_get(void) {
15907 PyObject *pyobj;
15908
15909 {
15910 #if wxUSE_UNICODE
15911 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15912 #else
15913 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15914 #endif
15915 }
15916 return pyobj;
15917 }
15918
15919
15920 static int _wrap_ART_HELP_set(PyObject *) {
15921 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15922 return 1;
15923 }
15924
15925
15926 static PyObject *_wrap_ART_HELP_get(void) {
15927 PyObject *pyobj;
15928
15929 {
15930 #if wxUSE_UNICODE
15931 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15932 #else
15933 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15934 #endif
15935 }
15936 return pyobj;
15937 }
15938
15939
15940 static int _wrap_ART_TIP_set(PyObject *) {
15941 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15942 return 1;
15943 }
15944
15945
15946 static PyObject *_wrap_ART_TIP_get(void) {
15947 PyObject *pyobj;
15948
15949 {
15950 #if wxUSE_UNICODE
15951 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15952 #else
15953 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15954 #endif
15955 }
15956 return pyobj;
15957 }
15958
15959
15960 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15961 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15962 return 1;
15963 }
15964
15965
15966 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15967 PyObject *pyobj;
15968
15969 {
15970 #if wxUSE_UNICODE
15971 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15972 #else
15973 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15974 #endif
15975 }
15976 return pyobj;
15977 }
15978
15979
15980 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15981 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15982 return 1;
15983 }
15984
15985
15986 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15987 PyObject *pyobj;
15988
15989 {
15990 #if wxUSE_UNICODE
15991 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15992 #else
15993 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15994 #endif
15995 }
15996 return pyobj;
15997 }
15998
15999
16000 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16001 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16002 return 1;
16003 }
16004
16005
16006 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16007 PyObject *pyobj;
16008
16009 {
16010 #if wxUSE_UNICODE
16011 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16012 #else
16013 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16014 #endif
16015 }
16016 return pyobj;
16017 }
16018
16019
16020 static int _wrap_ART_HARDDISK_set(PyObject *) {
16021 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16022 return 1;
16023 }
16024
16025
16026 static PyObject *_wrap_ART_HARDDISK_get(void) {
16027 PyObject *pyobj;
16028
16029 {
16030 #if wxUSE_UNICODE
16031 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16032 #else
16033 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16034 #endif
16035 }
16036 return pyobj;
16037 }
16038
16039
16040 static int _wrap_ART_FLOPPY_set(PyObject *) {
16041 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16042 return 1;
16043 }
16044
16045
16046 static PyObject *_wrap_ART_FLOPPY_get(void) {
16047 PyObject *pyobj;
16048
16049 {
16050 #if wxUSE_UNICODE
16051 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16052 #else
16053 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16054 #endif
16055 }
16056 return pyobj;
16057 }
16058
16059
16060 static int _wrap_ART_CDROM_set(PyObject *) {
16061 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16062 return 1;
16063 }
16064
16065
16066 static PyObject *_wrap_ART_CDROM_get(void) {
16067 PyObject *pyobj;
16068
16069 {
16070 #if wxUSE_UNICODE
16071 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16072 #else
16073 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16074 #endif
16075 }
16076 return pyobj;
16077 }
16078
16079
16080 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16081 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16082 return 1;
16083 }
16084
16085
16086 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16087 PyObject *pyobj;
16088
16089 {
16090 #if wxUSE_UNICODE
16091 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16092 #else
16093 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16094 #endif
16095 }
16096 return pyobj;
16097 }
16098
16099
16100 static int _wrap_ART_FOLDER_set(PyObject *) {
16101 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16102 return 1;
16103 }
16104
16105
16106 static PyObject *_wrap_ART_FOLDER_get(void) {
16107 PyObject *pyobj;
16108
16109 {
16110 #if wxUSE_UNICODE
16111 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16112 #else
16113 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16114 #endif
16115 }
16116 return pyobj;
16117 }
16118
16119
16120 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16121 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16122 return 1;
16123 }
16124
16125
16126 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16127 PyObject *pyobj;
16128
16129 {
16130 #if wxUSE_UNICODE
16131 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16132 #else
16133 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16134 #endif
16135 }
16136 return pyobj;
16137 }
16138
16139
16140 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16141 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16142 return 1;
16143 }
16144
16145
16146 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16147 PyObject *pyobj;
16148
16149 {
16150 #if wxUSE_UNICODE
16151 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16152 #else
16153 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16154 #endif
16155 }
16156 return pyobj;
16157 }
16158
16159
16160 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16161 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16162 return 1;
16163 }
16164
16165
16166 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16167 PyObject *pyobj;
16168
16169 {
16170 #if wxUSE_UNICODE
16171 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16172 #else
16173 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16174 #endif
16175 }
16176 return pyobj;
16177 }
16178
16179
16180 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16181 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16182 return 1;
16183 }
16184
16185
16186 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16187 PyObject *pyobj;
16188
16189 {
16190 #if wxUSE_UNICODE
16191 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16192 #else
16193 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16194 #endif
16195 }
16196 return pyobj;
16197 }
16198
16199
16200 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16201 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16202 return 1;
16203 }
16204
16205
16206 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16207 PyObject *pyobj;
16208
16209 {
16210 #if wxUSE_UNICODE
16211 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16212 #else
16213 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16214 #endif
16215 }
16216 return pyobj;
16217 }
16218
16219
16220 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16221 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16222 return 1;
16223 }
16224
16225
16226 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16227 PyObject *pyobj;
16228
16229 {
16230 #if wxUSE_UNICODE
16231 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16232 #else
16233 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16234 #endif
16235 }
16236 return pyobj;
16237 }
16238
16239
16240 static int _wrap_ART_ERROR_set(PyObject *) {
16241 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16242 return 1;
16243 }
16244
16245
16246 static PyObject *_wrap_ART_ERROR_get(void) {
16247 PyObject *pyobj;
16248
16249 {
16250 #if wxUSE_UNICODE
16251 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16252 #else
16253 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16254 #endif
16255 }
16256 return pyobj;
16257 }
16258
16259
16260 static int _wrap_ART_QUESTION_set(PyObject *) {
16261 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16262 return 1;
16263 }
16264
16265
16266 static PyObject *_wrap_ART_QUESTION_get(void) {
16267 PyObject *pyobj;
16268
16269 {
16270 #if wxUSE_UNICODE
16271 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16272 #else
16273 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16274 #endif
16275 }
16276 return pyobj;
16277 }
16278
16279
16280 static int _wrap_ART_WARNING_set(PyObject *) {
16281 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16282 return 1;
16283 }
16284
16285
16286 static PyObject *_wrap_ART_WARNING_get(void) {
16287 PyObject *pyobj;
16288
16289 {
16290 #if wxUSE_UNICODE
16291 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16292 #else
16293 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16294 #endif
16295 }
16296 return pyobj;
16297 }
16298
16299
16300 static int _wrap_ART_INFORMATION_set(PyObject *) {
16301 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16302 return 1;
16303 }
16304
16305
16306 static PyObject *_wrap_ART_INFORMATION_get(void) {
16307 PyObject *pyobj;
16308
16309 {
16310 #if wxUSE_UNICODE
16311 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16312 #else
16313 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16314 #endif
16315 }
16316 return pyobj;
16317 }
16318
16319
16320 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16321 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16322 return 1;
16323 }
16324
16325
16326 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16327 PyObject *pyobj;
16328
16329 {
16330 #if wxUSE_UNICODE
16331 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16332 #else
16333 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16334 #endif
16335 }
16336 return pyobj;
16337 }
16338
16339
16340 static int _wrap_ART_COPY_set(PyObject *) {
16341 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16342 return 1;
16343 }
16344
16345
16346 static PyObject *_wrap_ART_COPY_get(void) {
16347 PyObject *pyobj;
16348
16349 {
16350 #if wxUSE_UNICODE
16351 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16352 #else
16353 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16354 #endif
16355 }
16356 return pyobj;
16357 }
16358
16359
16360 static int _wrap_ART_CUT_set(PyObject *) {
16361 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16362 return 1;
16363 }
16364
16365
16366 static PyObject *_wrap_ART_CUT_get(void) {
16367 PyObject *pyobj;
16368
16369 {
16370 #if wxUSE_UNICODE
16371 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16372 #else
16373 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16374 #endif
16375 }
16376 return pyobj;
16377 }
16378
16379
16380 static int _wrap_ART_PASTE_set(PyObject *) {
16381 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16382 return 1;
16383 }
16384
16385
16386 static PyObject *_wrap_ART_PASTE_get(void) {
16387 PyObject *pyobj;
16388
16389 {
16390 #if wxUSE_UNICODE
16391 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16392 #else
16393 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16394 #endif
16395 }
16396 return pyobj;
16397 }
16398
16399
16400 static int _wrap_ART_DELETE_set(PyObject *) {
16401 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16402 return 1;
16403 }
16404
16405
16406 static PyObject *_wrap_ART_DELETE_get(void) {
16407 PyObject *pyobj;
16408
16409 {
16410 #if wxUSE_UNICODE
16411 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16412 #else
16413 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16414 #endif
16415 }
16416 return pyobj;
16417 }
16418
16419
16420 static int _wrap_ART_UNDO_set(PyObject *) {
16421 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16422 return 1;
16423 }
16424
16425
16426 static PyObject *_wrap_ART_UNDO_get(void) {
16427 PyObject *pyobj;
16428
16429 {
16430 #if wxUSE_UNICODE
16431 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16432 #else
16433 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16434 #endif
16435 }
16436 return pyobj;
16437 }
16438
16439
16440 static int _wrap_ART_REDO_set(PyObject *) {
16441 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16442 return 1;
16443 }
16444
16445
16446 static PyObject *_wrap_ART_REDO_get(void) {
16447 PyObject *pyobj;
16448
16449 {
16450 #if wxUSE_UNICODE
16451 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16452 #else
16453 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16454 #endif
16455 }
16456 return pyobj;
16457 }
16458
16459
16460 static int _wrap_ART_QUIT_set(PyObject *) {
16461 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16462 return 1;
16463 }
16464
16465
16466 static PyObject *_wrap_ART_QUIT_get(void) {
16467 PyObject *pyobj;
16468
16469 {
16470 #if wxUSE_UNICODE
16471 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16472 #else
16473 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16474 #endif
16475 }
16476 return pyobj;
16477 }
16478
16479
16480 static int _wrap_ART_FIND_set(PyObject *) {
16481 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16482 return 1;
16483 }
16484
16485
16486 static PyObject *_wrap_ART_FIND_get(void) {
16487 PyObject *pyobj;
16488
16489 {
16490 #if wxUSE_UNICODE
16491 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16492 #else
16493 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16494 #endif
16495 }
16496 return pyobj;
16497 }
16498
16499
16500 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16501 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16502 return 1;
16503 }
16504
16505
16506 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16507 PyObject *pyobj;
16508
16509 {
16510 #if wxUSE_UNICODE
16511 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16512 #else
16513 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16514 #endif
16515 }
16516 return pyobj;
16517 }
16518
16519
16520 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16521 PyObject *resultobj;
16522 wxPyArtProvider *result;
16523 char *kwnames[] = {
16524 NULL
16525 };
16526
16527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16528 {
16529 if (!wxPyCheckForApp()) SWIG_fail;
16530 PyThreadState* __tstate = wxPyBeginAllowThreads();
16531 result = (wxPyArtProvider *)new wxPyArtProvider();
16532
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16544 PyObject *resultobj;
16545 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16546 PyObject *arg2 = (PyObject *) 0 ;
16547 PyObject *arg3 = (PyObject *) 0 ;
16548 PyObject * obj0 = 0 ;
16549 PyObject * obj1 = 0 ;
16550 PyObject * obj2 = 0 ;
16551 char *kwnames[] = {
16552 (char *) "self",(char *) "self",(char *) "_class", NULL
16553 };
16554
16555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16557 if (SWIG_arg_fail(1)) SWIG_fail;
16558 arg2 = obj1;
16559 arg3 = obj2;
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 (arg1)->_setCallbackInfo(arg2,arg3);
16563
16564 wxPyEndAllowThreads(__tstate);
16565 if (PyErr_Occurred()) SWIG_fail;
16566 }
16567 Py_INCREF(Py_None); resultobj = Py_None;
16568 return resultobj;
16569 fail:
16570 return NULL;
16571 }
16572
16573
16574 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj;
16576 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16577 PyObject * obj0 = 0 ;
16578 char *kwnames[] = {
16579 (char *) "provider", NULL
16580 };
16581
16582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16584 if (SWIG_arg_fail(1)) SWIG_fail;
16585 {
16586 PyThreadState* __tstate = wxPyBeginAllowThreads();
16587 wxPyArtProvider::PushProvider(arg1);
16588
16589 wxPyEndAllowThreads(__tstate);
16590 if (PyErr_Occurred()) SWIG_fail;
16591 }
16592 Py_INCREF(Py_None); resultobj = Py_None;
16593 return resultobj;
16594 fail:
16595 return NULL;
16596 }
16597
16598
16599 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16600 PyObject *resultobj;
16601 bool result;
16602 char *kwnames[] = {
16603 NULL
16604 };
16605
16606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16607 {
16608 PyThreadState* __tstate = wxPyBeginAllowThreads();
16609 result = (bool)wxPyArtProvider::PopProvider();
16610
16611 wxPyEndAllowThreads(__tstate);
16612 if (PyErr_Occurred()) SWIG_fail;
16613 }
16614 {
16615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16616 }
16617 return resultobj;
16618 fail:
16619 return NULL;
16620 }
16621
16622
16623 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16624 PyObject *resultobj;
16625 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16626 bool result;
16627 PyObject * obj0 = 0 ;
16628 char *kwnames[] = {
16629 (char *) "provider", NULL
16630 };
16631
16632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16634 if (SWIG_arg_fail(1)) SWIG_fail;
16635 {
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16638
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 {
16643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16644 }
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj;
16653 wxString *arg1 = 0 ;
16654 wxString const &arg2_defvalue = wxPyART_OTHER ;
16655 wxString *arg2 = (wxString *) &arg2_defvalue ;
16656 wxSize const &arg3_defvalue = wxDefaultSize ;
16657 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16658 wxBitmap result;
16659 bool temp1 = false ;
16660 bool temp2 = false ;
16661 wxSize temp3 ;
16662 PyObject * obj0 = 0 ;
16663 PyObject * obj1 = 0 ;
16664 PyObject * obj2 = 0 ;
16665 char *kwnames[] = {
16666 (char *) "id",(char *) "client",(char *) "size", NULL
16667 };
16668
16669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16670 {
16671 arg1 = wxString_in_helper(obj0);
16672 if (arg1 == NULL) SWIG_fail;
16673 temp1 = true;
16674 }
16675 if (obj1) {
16676 {
16677 arg2 = wxString_in_helper(obj1);
16678 if (arg2 == NULL) SWIG_fail;
16679 temp2 = true;
16680 }
16681 }
16682 if (obj2) {
16683 {
16684 arg3 = &temp3;
16685 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16686 }
16687 }
16688 {
16689 if (!wxPyCheckForApp()) SWIG_fail;
16690 PyThreadState* __tstate = wxPyBeginAllowThreads();
16691 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16692
16693 wxPyEndAllowThreads(__tstate);
16694 if (PyErr_Occurred()) SWIG_fail;
16695 }
16696 {
16697 wxBitmap * resultptr;
16698 resultptr = new wxBitmap((wxBitmap &)(result));
16699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16700 }
16701 {
16702 if (temp1)
16703 delete arg1;
16704 }
16705 {
16706 if (temp2)
16707 delete arg2;
16708 }
16709 return resultobj;
16710 fail:
16711 {
16712 if (temp1)
16713 delete arg1;
16714 }
16715 {
16716 if (temp2)
16717 delete arg2;
16718 }
16719 return NULL;
16720 }
16721
16722
16723 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj;
16725 wxString *arg1 = 0 ;
16726 wxString const &arg2_defvalue = wxPyART_OTHER ;
16727 wxString *arg2 = (wxString *) &arg2_defvalue ;
16728 wxSize const &arg3_defvalue = wxDefaultSize ;
16729 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16730 wxIcon result;
16731 bool temp1 = false ;
16732 bool temp2 = false ;
16733 wxSize temp3 ;
16734 PyObject * obj0 = 0 ;
16735 PyObject * obj1 = 0 ;
16736 PyObject * obj2 = 0 ;
16737 char *kwnames[] = {
16738 (char *) "id",(char *) "client",(char *) "size", NULL
16739 };
16740
16741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16742 {
16743 arg1 = wxString_in_helper(obj0);
16744 if (arg1 == NULL) SWIG_fail;
16745 temp1 = true;
16746 }
16747 if (obj1) {
16748 {
16749 arg2 = wxString_in_helper(obj1);
16750 if (arg2 == NULL) SWIG_fail;
16751 temp2 = true;
16752 }
16753 }
16754 if (obj2) {
16755 {
16756 arg3 = &temp3;
16757 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16758 }
16759 }
16760 {
16761 if (!wxPyCheckForApp()) SWIG_fail;
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16764
16765 wxPyEndAllowThreads(__tstate);
16766 if (PyErr_Occurred()) SWIG_fail;
16767 }
16768 {
16769 wxIcon * resultptr;
16770 resultptr = new wxIcon((wxIcon &)(result));
16771 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16772 }
16773 {
16774 if (temp1)
16775 delete arg1;
16776 }
16777 {
16778 if (temp2)
16779 delete arg2;
16780 }
16781 return resultobj;
16782 fail:
16783 {
16784 if (temp1)
16785 delete arg1;
16786 }
16787 {
16788 if (temp2)
16789 delete arg2;
16790 }
16791 return NULL;
16792 }
16793
16794
16795 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16796 PyObject *resultobj;
16797 wxString *arg1 = 0 ;
16798 bool arg2 = (bool) false ;
16799 wxSize result;
16800 bool temp1 = false ;
16801 PyObject * obj0 = 0 ;
16802 PyObject * obj1 = 0 ;
16803 char *kwnames[] = {
16804 (char *) "client",(char *) "platform_dependent", NULL
16805 };
16806
16807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16808 {
16809 arg1 = wxString_in_helper(obj0);
16810 if (arg1 == NULL) SWIG_fail;
16811 temp1 = true;
16812 }
16813 if (obj1) {
16814 {
16815 arg2 = (bool)(SWIG_As_bool(obj1));
16816 if (SWIG_arg_fail(2)) SWIG_fail;
16817 }
16818 }
16819 {
16820 PyThreadState* __tstate = wxPyBeginAllowThreads();
16821 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16822
16823 wxPyEndAllowThreads(__tstate);
16824 if (PyErr_Occurred()) SWIG_fail;
16825 }
16826 {
16827 wxSize * resultptr;
16828 resultptr = new wxSize((wxSize &)(result));
16829 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16830 }
16831 {
16832 if (temp1)
16833 delete arg1;
16834 }
16835 return resultobj;
16836 fail:
16837 {
16838 if (temp1)
16839 delete arg1;
16840 }
16841 return NULL;
16842 }
16843
16844
16845 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16846 PyObject *resultobj;
16847 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16848 PyObject * obj0 = 0 ;
16849 char *kwnames[] = {
16850 (char *) "self", NULL
16851 };
16852
16853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16855 if (SWIG_arg_fail(1)) SWIG_fail;
16856 {
16857 PyThreadState* __tstate = wxPyBeginAllowThreads();
16858 wxPyArtProvider_Destroy(arg1);
16859
16860 wxPyEndAllowThreads(__tstate);
16861 if (PyErr_Occurred()) SWIG_fail;
16862 }
16863 Py_INCREF(Py_None); resultobj = Py_None;
16864 return resultobj;
16865 fail:
16866 return NULL;
16867 }
16868
16869
16870 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16871 PyObject *obj;
16872 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16873 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16874 Py_INCREF(obj);
16875 return Py_BuildValue((char *)"");
16876 }
16877 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16878 PyObject *resultobj;
16879 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16880 PyObject * obj0 = 0 ;
16881 char *kwnames[] = {
16882 (char *) "self", NULL
16883 };
16884
16885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16887 if (SWIG_arg_fail(1)) SWIG_fail;
16888 {
16889 PyThreadState* __tstate = wxPyBeginAllowThreads();
16890 delete arg1;
16891
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 Py_INCREF(Py_None); resultobj = Py_None;
16896 return resultobj;
16897 fail:
16898 return NULL;
16899 }
16900
16901
16902 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16903 PyObject *resultobj;
16904 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16905 wxConfigBase *result;
16906 PyObject * obj0 = 0 ;
16907 char *kwnames[] = {
16908 (char *) "config", NULL
16909 };
16910
16911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16913 if (SWIG_arg_fail(1)) SWIG_fail;
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16917
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16922 return resultobj;
16923 fail:
16924 return NULL;
16925 }
16926
16927
16928 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16929 PyObject *resultobj;
16930 bool arg1 = (bool) true ;
16931 wxConfigBase *result;
16932 PyObject * obj0 = 0 ;
16933 char *kwnames[] = {
16934 (char *) "createOnDemand", NULL
16935 };
16936
16937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16938 if (obj0) {
16939 {
16940 arg1 = (bool)(SWIG_As_bool(obj0));
16941 if (SWIG_arg_fail(1)) SWIG_fail;
16942 }
16943 }
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16947
16948 wxPyEndAllowThreads(__tstate);
16949 if (PyErr_Occurred()) SWIG_fail;
16950 }
16951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16952 return resultobj;
16953 fail:
16954 return NULL;
16955 }
16956
16957
16958 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16959 PyObject *resultobj;
16960 wxConfigBase *result;
16961 char *kwnames[] = {
16962 NULL
16963 };
16964
16965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16966 {
16967 PyThreadState* __tstate = wxPyBeginAllowThreads();
16968 result = (wxConfigBase *)wxConfigBase::Create();
16969
16970 wxPyEndAllowThreads(__tstate);
16971 if (PyErr_Occurred()) SWIG_fail;
16972 }
16973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16981 PyObject *resultobj;
16982 char *kwnames[] = {
16983 NULL
16984 };
16985
16986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16987 {
16988 PyThreadState* __tstate = wxPyBeginAllowThreads();
16989 wxConfigBase::DontCreateOnDemand();
16990
16991 wxPyEndAllowThreads(__tstate);
16992 if (PyErr_Occurred()) SWIG_fail;
16993 }
16994 Py_INCREF(Py_None); resultobj = Py_None;
16995 return resultobj;
16996 fail:
16997 return NULL;
16998 }
16999
17000
17001 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17002 PyObject *resultobj;
17003 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17004 wxString *arg2 = 0 ;
17005 bool temp2 = false ;
17006 PyObject * obj0 = 0 ;
17007 PyObject * obj1 = 0 ;
17008 char *kwnames[] = {
17009 (char *) "self",(char *) "path", NULL
17010 };
17011
17012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17014 if (SWIG_arg_fail(1)) SWIG_fail;
17015 {
17016 arg2 = wxString_in_helper(obj1);
17017 if (arg2 == NULL) SWIG_fail;
17018 temp2 = true;
17019 }
17020 {
17021 PyThreadState* __tstate = wxPyBeginAllowThreads();
17022 (arg1)->SetPath((wxString const &)*arg2);
17023
17024 wxPyEndAllowThreads(__tstate);
17025 if (PyErr_Occurred()) SWIG_fail;
17026 }
17027 Py_INCREF(Py_None); resultobj = Py_None;
17028 {
17029 if (temp2)
17030 delete arg2;
17031 }
17032 return resultobj;
17033 fail:
17034 {
17035 if (temp2)
17036 delete arg2;
17037 }
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17045 wxString *result;
17046 PyObject * obj0 = 0 ;
17047 char *kwnames[] = {
17048 (char *) "self", NULL
17049 };
17050
17051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17053 if (SWIG_arg_fail(1)) SWIG_fail;
17054 {
17055 PyThreadState* __tstate = wxPyBeginAllowThreads();
17056 {
17057 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17058 result = (wxString *) &_result_ref;
17059 }
17060
17061 wxPyEndAllowThreads(__tstate);
17062 if (PyErr_Occurred()) SWIG_fail;
17063 }
17064 {
17065 #if wxUSE_UNICODE
17066 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17067 #else
17068 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17069 #endif
17070 }
17071 return resultobj;
17072 fail:
17073 return NULL;
17074 }
17075
17076
17077 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17078 PyObject *resultobj;
17079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17080 PyObject *result;
17081 PyObject * obj0 = 0 ;
17082 char *kwnames[] = {
17083 (char *) "self", NULL
17084 };
17085
17086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17088 if (SWIG_arg_fail(1)) SWIG_fail;
17089 {
17090 PyThreadState* __tstate = wxPyBeginAllowThreads();
17091 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17092
17093 wxPyEndAllowThreads(__tstate);
17094 if (PyErr_Occurred()) SWIG_fail;
17095 }
17096 resultobj = result;
17097 return resultobj;
17098 fail:
17099 return NULL;
17100 }
17101
17102
17103 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17104 PyObject *resultobj;
17105 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17106 long arg2 ;
17107 PyObject *result;
17108 PyObject * obj0 = 0 ;
17109 PyObject * obj1 = 0 ;
17110 char *kwnames[] = {
17111 (char *) "self",(char *) "index", NULL
17112 };
17113
17114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17116 if (SWIG_arg_fail(1)) SWIG_fail;
17117 {
17118 arg2 = (long)(SWIG_As_long(obj1));
17119 if (SWIG_arg_fail(2)) SWIG_fail;
17120 }
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17124
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 resultobj = result;
17129 return resultobj;
17130 fail:
17131 return NULL;
17132 }
17133
17134
17135 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17136 PyObject *resultobj;
17137 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17138 PyObject *result;
17139 PyObject * obj0 = 0 ;
17140 char *kwnames[] = {
17141 (char *) "self", NULL
17142 };
17143
17144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17146 if (SWIG_arg_fail(1)) SWIG_fail;
17147 {
17148 PyThreadState* __tstate = wxPyBeginAllowThreads();
17149 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17150
17151 wxPyEndAllowThreads(__tstate);
17152 if (PyErr_Occurred()) SWIG_fail;
17153 }
17154 resultobj = result;
17155 return resultobj;
17156 fail:
17157 return NULL;
17158 }
17159
17160
17161 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17162 PyObject *resultobj;
17163 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17164 long arg2 ;
17165 PyObject *result;
17166 PyObject * obj0 = 0 ;
17167 PyObject * obj1 = 0 ;
17168 char *kwnames[] = {
17169 (char *) "self",(char *) "index", NULL
17170 };
17171
17172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17174 if (SWIG_arg_fail(1)) SWIG_fail;
17175 {
17176 arg2 = (long)(SWIG_As_long(obj1));
17177 if (SWIG_arg_fail(2)) SWIG_fail;
17178 }
17179 {
17180 PyThreadState* __tstate = wxPyBeginAllowThreads();
17181 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17182
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = result;
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj;
17195 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17196 bool arg2 = (bool) false ;
17197 size_t result;
17198 PyObject * obj0 = 0 ;
17199 PyObject * obj1 = 0 ;
17200 char *kwnames[] = {
17201 (char *) "self",(char *) "recursive", NULL
17202 };
17203
17204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17206 if (SWIG_arg_fail(1)) SWIG_fail;
17207 if (obj1) {
17208 {
17209 arg2 = (bool)(SWIG_As_bool(obj1));
17210 if (SWIG_arg_fail(2)) SWIG_fail;
17211 }
17212 }
17213 {
17214 PyThreadState* __tstate = wxPyBeginAllowThreads();
17215 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17216
17217 wxPyEndAllowThreads(__tstate);
17218 if (PyErr_Occurred()) SWIG_fail;
17219 }
17220 {
17221 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17222 }
17223 return resultobj;
17224 fail:
17225 return NULL;
17226 }
17227
17228
17229 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17230 PyObject *resultobj;
17231 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17232 bool arg2 = (bool) false ;
17233 size_t result;
17234 PyObject * obj0 = 0 ;
17235 PyObject * obj1 = 0 ;
17236 char *kwnames[] = {
17237 (char *) "self",(char *) "recursive", NULL
17238 };
17239
17240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17242 if (SWIG_arg_fail(1)) SWIG_fail;
17243 if (obj1) {
17244 {
17245 arg2 = (bool)(SWIG_As_bool(obj1));
17246 if (SWIG_arg_fail(2)) SWIG_fail;
17247 }
17248 }
17249 {
17250 PyThreadState* __tstate = wxPyBeginAllowThreads();
17251 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17252
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 {
17257 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17258 }
17259 return resultobj;
17260 fail:
17261 return NULL;
17262 }
17263
17264
17265 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17266 PyObject *resultobj;
17267 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17268 wxString *arg2 = 0 ;
17269 bool result;
17270 bool temp2 = false ;
17271 PyObject * obj0 = 0 ;
17272 PyObject * obj1 = 0 ;
17273 char *kwnames[] = {
17274 (char *) "self",(char *) "name", NULL
17275 };
17276
17277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17279 if (SWIG_arg_fail(1)) SWIG_fail;
17280 {
17281 arg2 = wxString_in_helper(obj1);
17282 if (arg2 == NULL) SWIG_fail;
17283 temp2 = true;
17284 }
17285 {
17286 PyThreadState* __tstate = wxPyBeginAllowThreads();
17287 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17288
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 {
17293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17294 }
17295 {
17296 if (temp2)
17297 delete arg2;
17298 }
17299 return resultobj;
17300 fail:
17301 {
17302 if (temp2)
17303 delete arg2;
17304 }
17305 return NULL;
17306 }
17307
17308
17309 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj;
17311 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17312 wxString *arg2 = 0 ;
17313 bool result;
17314 bool temp2 = false ;
17315 PyObject * obj0 = 0 ;
17316 PyObject * obj1 = 0 ;
17317 char *kwnames[] = {
17318 (char *) "self",(char *) "name", NULL
17319 };
17320
17321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17323 if (SWIG_arg_fail(1)) SWIG_fail;
17324 {
17325 arg2 = wxString_in_helper(obj1);
17326 if (arg2 == NULL) SWIG_fail;
17327 temp2 = true;
17328 }
17329 {
17330 PyThreadState* __tstate = wxPyBeginAllowThreads();
17331 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17332
17333 wxPyEndAllowThreads(__tstate);
17334 if (PyErr_Occurred()) SWIG_fail;
17335 }
17336 {
17337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17338 }
17339 {
17340 if (temp2)
17341 delete arg2;
17342 }
17343 return resultobj;
17344 fail:
17345 {
17346 if (temp2)
17347 delete arg2;
17348 }
17349 return NULL;
17350 }
17351
17352
17353 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17354 PyObject *resultobj;
17355 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17356 wxString *arg2 = 0 ;
17357 bool result;
17358 bool temp2 = false ;
17359 PyObject * obj0 = 0 ;
17360 PyObject * obj1 = 0 ;
17361 char *kwnames[] = {
17362 (char *) "self",(char *) "name", NULL
17363 };
17364
17365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17367 if (SWIG_arg_fail(1)) SWIG_fail;
17368 {
17369 arg2 = wxString_in_helper(obj1);
17370 if (arg2 == NULL) SWIG_fail;
17371 temp2 = true;
17372 }
17373 {
17374 PyThreadState* __tstate = wxPyBeginAllowThreads();
17375 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17376
17377 wxPyEndAllowThreads(__tstate);
17378 if (PyErr_Occurred()) SWIG_fail;
17379 }
17380 {
17381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17382 }
17383 {
17384 if (temp2)
17385 delete arg2;
17386 }
17387 return resultobj;
17388 fail:
17389 {
17390 if (temp2)
17391 delete arg2;
17392 }
17393 return NULL;
17394 }
17395
17396
17397 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17398 PyObject *resultobj;
17399 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17400 wxString *arg2 = 0 ;
17401 wxConfigBase::EntryType result;
17402 bool temp2 = false ;
17403 PyObject * obj0 = 0 ;
17404 PyObject * obj1 = 0 ;
17405 char *kwnames[] = {
17406 (char *) "self",(char *) "name", NULL
17407 };
17408
17409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17411 if (SWIG_arg_fail(1)) SWIG_fail;
17412 {
17413 arg2 = wxString_in_helper(obj1);
17414 if (arg2 == NULL) SWIG_fail;
17415 temp2 = true;
17416 }
17417 {
17418 PyThreadState* __tstate = wxPyBeginAllowThreads();
17419 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17420
17421 wxPyEndAllowThreads(__tstate);
17422 if (PyErr_Occurred()) SWIG_fail;
17423 }
17424 resultobj = SWIG_From_int((result));
17425 {
17426 if (temp2)
17427 delete arg2;
17428 }
17429 return resultobj;
17430 fail:
17431 {
17432 if (temp2)
17433 delete arg2;
17434 }
17435 return NULL;
17436 }
17437
17438
17439 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17440 PyObject *resultobj;
17441 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17442 wxString *arg2 = 0 ;
17443 wxString const &arg3_defvalue = wxPyEmptyString ;
17444 wxString *arg3 = (wxString *) &arg3_defvalue ;
17445 wxString result;
17446 bool temp2 = false ;
17447 bool temp3 = false ;
17448 PyObject * obj0 = 0 ;
17449 PyObject * obj1 = 0 ;
17450 PyObject * obj2 = 0 ;
17451 char *kwnames[] = {
17452 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17453 };
17454
17455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17457 if (SWIG_arg_fail(1)) SWIG_fail;
17458 {
17459 arg2 = wxString_in_helper(obj1);
17460 if (arg2 == NULL) SWIG_fail;
17461 temp2 = true;
17462 }
17463 if (obj2) {
17464 {
17465 arg3 = wxString_in_helper(obj2);
17466 if (arg3 == NULL) SWIG_fail;
17467 temp3 = true;
17468 }
17469 }
17470 {
17471 PyThreadState* __tstate = wxPyBeginAllowThreads();
17472 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17473
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 {
17478 #if wxUSE_UNICODE
17479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17480 #else
17481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17482 #endif
17483 }
17484 {
17485 if (temp2)
17486 delete arg2;
17487 }
17488 {
17489 if (temp3)
17490 delete arg3;
17491 }
17492 return resultobj;
17493 fail:
17494 {
17495 if (temp2)
17496 delete arg2;
17497 }
17498 {
17499 if (temp3)
17500 delete arg3;
17501 }
17502 return NULL;
17503 }
17504
17505
17506 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17507 PyObject *resultobj;
17508 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17509 wxString *arg2 = 0 ;
17510 long arg3 = (long) 0 ;
17511 long result;
17512 bool temp2 = false ;
17513 PyObject * obj0 = 0 ;
17514 PyObject * obj1 = 0 ;
17515 PyObject * obj2 = 0 ;
17516 char *kwnames[] = {
17517 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17518 };
17519
17520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17522 if (SWIG_arg_fail(1)) SWIG_fail;
17523 {
17524 arg2 = wxString_in_helper(obj1);
17525 if (arg2 == NULL) SWIG_fail;
17526 temp2 = true;
17527 }
17528 if (obj2) {
17529 {
17530 arg3 = (long)(SWIG_As_long(obj2));
17531 if (SWIG_arg_fail(3)) SWIG_fail;
17532 }
17533 }
17534 {
17535 PyThreadState* __tstate = wxPyBeginAllowThreads();
17536 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17537
17538 wxPyEndAllowThreads(__tstate);
17539 if (PyErr_Occurred()) SWIG_fail;
17540 }
17541 {
17542 resultobj = SWIG_From_long((long)(result));
17543 }
17544 {
17545 if (temp2)
17546 delete arg2;
17547 }
17548 return resultobj;
17549 fail:
17550 {
17551 if (temp2)
17552 delete arg2;
17553 }
17554 return NULL;
17555 }
17556
17557
17558 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17559 PyObject *resultobj;
17560 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17561 wxString *arg2 = 0 ;
17562 double arg3 = (double) 0.0 ;
17563 double result;
17564 bool temp2 = false ;
17565 PyObject * obj0 = 0 ;
17566 PyObject * obj1 = 0 ;
17567 PyObject * obj2 = 0 ;
17568 char *kwnames[] = {
17569 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17570 };
17571
17572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17574 if (SWIG_arg_fail(1)) SWIG_fail;
17575 {
17576 arg2 = wxString_in_helper(obj1);
17577 if (arg2 == NULL) SWIG_fail;
17578 temp2 = true;
17579 }
17580 if (obj2) {
17581 {
17582 arg3 = (double)(SWIG_As_double(obj2));
17583 if (SWIG_arg_fail(3)) SWIG_fail;
17584 }
17585 }
17586 {
17587 PyThreadState* __tstate = wxPyBeginAllowThreads();
17588 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17589
17590 wxPyEndAllowThreads(__tstate);
17591 if (PyErr_Occurred()) SWIG_fail;
17592 }
17593 {
17594 resultobj = SWIG_From_double((double)(result));
17595 }
17596 {
17597 if (temp2)
17598 delete arg2;
17599 }
17600 return resultobj;
17601 fail:
17602 {
17603 if (temp2)
17604 delete arg2;
17605 }
17606 return NULL;
17607 }
17608
17609
17610 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17611 PyObject *resultobj;
17612 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17613 wxString *arg2 = 0 ;
17614 bool arg3 = (bool) false ;
17615 bool result;
17616 bool temp2 = false ;
17617 PyObject * obj0 = 0 ;
17618 PyObject * obj1 = 0 ;
17619 PyObject * obj2 = 0 ;
17620 char *kwnames[] = {
17621 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17622 };
17623
17624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17626 if (SWIG_arg_fail(1)) SWIG_fail;
17627 {
17628 arg2 = wxString_in_helper(obj1);
17629 if (arg2 == NULL) SWIG_fail;
17630 temp2 = true;
17631 }
17632 if (obj2) {
17633 {
17634 arg3 = (bool)(SWIG_As_bool(obj2));
17635 if (SWIG_arg_fail(3)) SWIG_fail;
17636 }
17637 }
17638 {
17639 PyThreadState* __tstate = wxPyBeginAllowThreads();
17640 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17641
17642 wxPyEndAllowThreads(__tstate);
17643 if (PyErr_Occurred()) SWIG_fail;
17644 }
17645 {
17646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17647 }
17648 {
17649 if (temp2)
17650 delete arg2;
17651 }
17652 return resultobj;
17653 fail:
17654 {
17655 if (temp2)
17656 delete arg2;
17657 }
17658 return NULL;
17659 }
17660
17661
17662 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17663 PyObject *resultobj;
17664 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17665 wxString *arg2 = 0 ;
17666 wxString *arg3 = 0 ;
17667 bool result;
17668 bool temp2 = false ;
17669 bool temp3 = false ;
17670 PyObject * obj0 = 0 ;
17671 PyObject * obj1 = 0 ;
17672 PyObject * obj2 = 0 ;
17673 char *kwnames[] = {
17674 (char *) "self",(char *) "key",(char *) "value", NULL
17675 };
17676
17677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17679 if (SWIG_arg_fail(1)) SWIG_fail;
17680 {
17681 arg2 = wxString_in_helper(obj1);
17682 if (arg2 == NULL) SWIG_fail;
17683 temp2 = true;
17684 }
17685 {
17686 arg3 = wxString_in_helper(obj2);
17687 if (arg3 == NULL) SWIG_fail;
17688 temp3 = true;
17689 }
17690 {
17691 PyThreadState* __tstate = wxPyBeginAllowThreads();
17692 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17693
17694 wxPyEndAllowThreads(__tstate);
17695 if (PyErr_Occurred()) SWIG_fail;
17696 }
17697 {
17698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17699 }
17700 {
17701 if (temp2)
17702 delete arg2;
17703 }
17704 {
17705 if (temp3)
17706 delete arg3;
17707 }
17708 return resultobj;
17709 fail:
17710 {
17711 if (temp2)
17712 delete arg2;
17713 }
17714 {
17715 if (temp3)
17716 delete arg3;
17717 }
17718 return NULL;
17719 }
17720
17721
17722 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17723 PyObject *resultobj;
17724 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17725 wxString *arg2 = 0 ;
17726 long arg3 ;
17727 bool result;
17728 bool temp2 = false ;
17729 PyObject * obj0 = 0 ;
17730 PyObject * obj1 = 0 ;
17731 PyObject * obj2 = 0 ;
17732 char *kwnames[] = {
17733 (char *) "self",(char *) "key",(char *) "value", NULL
17734 };
17735
17736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17738 if (SWIG_arg_fail(1)) SWIG_fail;
17739 {
17740 arg2 = wxString_in_helper(obj1);
17741 if (arg2 == NULL) SWIG_fail;
17742 temp2 = true;
17743 }
17744 {
17745 arg3 = (long)(SWIG_As_long(obj2));
17746 if (SWIG_arg_fail(3)) SWIG_fail;
17747 }
17748 {
17749 PyThreadState* __tstate = wxPyBeginAllowThreads();
17750 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17751
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 {
17756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17757 }
17758 {
17759 if (temp2)
17760 delete arg2;
17761 }
17762 return resultobj;
17763 fail:
17764 {
17765 if (temp2)
17766 delete arg2;
17767 }
17768 return NULL;
17769 }
17770
17771
17772 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17773 PyObject *resultobj;
17774 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17775 wxString *arg2 = 0 ;
17776 double arg3 ;
17777 bool result;
17778 bool temp2 = false ;
17779 PyObject * obj0 = 0 ;
17780 PyObject * obj1 = 0 ;
17781 PyObject * obj2 = 0 ;
17782 char *kwnames[] = {
17783 (char *) "self",(char *) "key",(char *) "value", NULL
17784 };
17785
17786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17788 if (SWIG_arg_fail(1)) SWIG_fail;
17789 {
17790 arg2 = wxString_in_helper(obj1);
17791 if (arg2 == NULL) SWIG_fail;
17792 temp2 = true;
17793 }
17794 {
17795 arg3 = (double)(SWIG_As_double(obj2));
17796 if (SWIG_arg_fail(3)) SWIG_fail;
17797 }
17798 {
17799 PyThreadState* __tstate = wxPyBeginAllowThreads();
17800 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17801
17802 wxPyEndAllowThreads(__tstate);
17803 if (PyErr_Occurred()) SWIG_fail;
17804 }
17805 {
17806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17807 }
17808 {
17809 if (temp2)
17810 delete arg2;
17811 }
17812 return resultobj;
17813 fail:
17814 {
17815 if (temp2)
17816 delete arg2;
17817 }
17818 return NULL;
17819 }
17820
17821
17822 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17823 PyObject *resultobj;
17824 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17825 wxString *arg2 = 0 ;
17826 bool arg3 ;
17827 bool result;
17828 bool temp2 = false ;
17829 PyObject * obj0 = 0 ;
17830 PyObject * obj1 = 0 ;
17831 PyObject * obj2 = 0 ;
17832 char *kwnames[] = {
17833 (char *) "self",(char *) "key",(char *) "value", NULL
17834 };
17835
17836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17838 if (SWIG_arg_fail(1)) SWIG_fail;
17839 {
17840 arg2 = wxString_in_helper(obj1);
17841 if (arg2 == NULL) SWIG_fail;
17842 temp2 = true;
17843 }
17844 {
17845 arg3 = (bool)(SWIG_As_bool(obj2));
17846 if (SWIG_arg_fail(3)) SWIG_fail;
17847 }
17848 {
17849 PyThreadState* __tstate = wxPyBeginAllowThreads();
17850 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17851
17852 wxPyEndAllowThreads(__tstate);
17853 if (PyErr_Occurred()) SWIG_fail;
17854 }
17855 {
17856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17857 }
17858 {
17859 if (temp2)
17860 delete arg2;
17861 }
17862 return resultobj;
17863 fail:
17864 {
17865 if (temp2)
17866 delete arg2;
17867 }
17868 return NULL;
17869 }
17870
17871
17872 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17873 PyObject *resultobj;
17874 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17875 bool arg2 = (bool) false ;
17876 bool result;
17877 PyObject * obj0 = 0 ;
17878 PyObject * obj1 = 0 ;
17879 char *kwnames[] = {
17880 (char *) "self",(char *) "currentOnly", NULL
17881 };
17882
17883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17885 if (SWIG_arg_fail(1)) SWIG_fail;
17886 if (obj1) {
17887 {
17888 arg2 = (bool)(SWIG_As_bool(obj1));
17889 if (SWIG_arg_fail(2)) SWIG_fail;
17890 }
17891 }
17892 {
17893 PyThreadState* __tstate = wxPyBeginAllowThreads();
17894 result = (bool)(arg1)->Flush(arg2);
17895
17896 wxPyEndAllowThreads(__tstate);
17897 if (PyErr_Occurred()) SWIG_fail;
17898 }
17899 {
17900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17901 }
17902 return resultobj;
17903 fail:
17904 return NULL;
17905 }
17906
17907
17908 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17909 PyObject *resultobj;
17910 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17911 wxString *arg2 = 0 ;
17912 wxString *arg3 = 0 ;
17913 bool result;
17914 bool temp2 = false ;
17915 bool temp3 = false ;
17916 PyObject * obj0 = 0 ;
17917 PyObject * obj1 = 0 ;
17918 PyObject * obj2 = 0 ;
17919 char *kwnames[] = {
17920 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17921 };
17922
17923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17925 if (SWIG_arg_fail(1)) SWIG_fail;
17926 {
17927 arg2 = wxString_in_helper(obj1);
17928 if (arg2 == NULL) SWIG_fail;
17929 temp2 = true;
17930 }
17931 {
17932 arg3 = wxString_in_helper(obj2);
17933 if (arg3 == NULL) SWIG_fail;
17934 temp3 = true;
17935 }
17936 {
17937 PyThreadState* __tstate = wxPyBeginAllowThreads();
17938 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17939
17940 wxPyEndAllowThreads(__tstate);
17941 if (PyErr_Occurred()) SWIG_fail;
17942 }
17943 {
17944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17945 }
17946 {
17947 if (temp2)
17948 delete arg2;
17949 }
17950 {
17951 if (temp3)
17952 delete arg3;
17953 }
17954 return resultobj;
17955 fail:
17956 {
17957 if (temp2)
17958 delete arg2;
17959 }
17960 {
17961 if (temp3)
17962 delete arg3;
17963 }
17964 return NULL;
17965 }
17966
17967
17968 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17969 PyObject *resultobj;
17970 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17971 wxString *arg2 = 0 ;
17972 wxString *arg3 = 0 ;
17973 bool result;
17974 bool temp2 = false ;
17975 bool temp3 = false ;
17976 PyObject * obj0 = 0 ;
17977 PyObject * obj1 = 0 ;
17978 PyObject * obj2 = 0 ;
17979 char *kwnames[] = {
17980 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17981 };
17982
17983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(1)) SWIG_fail;
17986 {
17987 arg2 = wxString_in_helper(obj1);
17988 if (arg2 == NULL) SWIG_fail;
17989 temp2 = true;
17990 }
17991 {
17992 arg3 = wxString_in_helper(obj2);
17993 if (arg3 == NULL) SWIG_fail;
17994 temp3 = true;
17995 }
17996 {
17997 PyThreadState* __tstate = wxPyBeginAllowThreads();
17998 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17999
18000 wxPyEndAllowThreads(__tstate);
18001 if (PyErr_Occurred()) SWIG_fail;
18002 }
18003 {
18004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18005 }
18006 {
18007 if (temp2)
18008 delete arg2;
18009 }
18010 {
18011 if (temp3)
18012 delete arg3;
18013 }
18014 return resultobj;
18015 fail:
18016 {
18017 if (temp2)
18018 delete arg2;
18019 }
18020 {
18021 if (temp3)
18022 delete arg3;
18023 }
18024 return NULL;
18025 }
18026
18027
18028 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18029 PyObject *resultobj;
18030 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18031 wxString *arg2 = 0 ;
18032 bool arg3 = (bool) true ;
18033 bool result;
18034 bool temp2 = false ;
18035 PyObject * obj0 = 0 ;
18036 PyObject * obj1 = 0 ;
18037 PyObject * obj2 = 0 ;
18038 char *kwnames[] = {
18039 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18040 };
18041
18042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18044 if (SWIG_arg_fail(1)) SWIG_fail;
18045 {
18046 arg2 = wxString_in_helper(obj1);
18047 if (arg2 == NULL) SWIG_fail;
18048 temp2 = true;
18049 }
18050 if (obj2) {
18051 {
18052 arg3 = (bool)(SWIG_As_bool(obj2));
18053 if (SWIG_arg_fail(3)) SWIG_fail;
18054 }
18055 }
18056 {
18057 PyThreadState* __tstate = wxPyBeginAllowThreads();
18058 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18059
18060 wxPyEndAllowThreads(__tstate);
18061 if (PyErr_Occurred()) SWIG_fail;
18062 }
18063 {
18064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18065 }
18066 {
18067 if (temp2)
18068 delete arg2;
18069 }
18070 return resultobj;
18071 fail:
18072 {
18073 if (temp2)
18074 delete arg2;
18075 }
18076 return NULL;
18077 }
18078
18079
18080 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18081 PyObject *resultobj;
18082 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18083 wxString *arg2 = 0 ;
18084 bool result;
18085 bool temp2 = false ;
18086 PyObject * obj0 = 0 ;
18087 PyObject * obj1 = 0 ;
18088 char *kwnames[] = {
18089 (char *) "self",(char *) "key", NULL
18090 };
18091
18092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18094 if (SWIG_arg_fail(1)) SWIG_fail;
18095 {
18096 arg2 = wxString_in_helper(obj1);
18097 if (arg2 == NULL) SWIG_fail;
18098 temp2 = true;
18099 }
18100 {
18101 PyThreadState* __tstate = wxPyBeginAllowThreads();
18102 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18103
18104 wxPyEndAllowThreads(__tstate);
18105 if (PyErr_Occurred()) SWIG_fail;
18106 }
18107 {
18108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18109 }
18110 {
18111 if (temp2)
18112 delete arg2;
18113 }
18114 return resultobj;
18115 fail:
18116 {
18117 if (temp2)
18118 delete arg2;
18119 }
18120 return NULL;
18121 }
18122
18123
18124 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18125 PyObject *resultobj;
18126 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18127 bool result;
18128 PyObject * obj0 = 0 ;
18129 char *kwnames[] = {
18130 (char *) "self", NULL
18131 };
18132
18133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18135 if (SWIG_arg_fail(1)) SWIG_fail;
18136 {
18137 PyThreadState* __tstate = wxPyBeginAllowThreads();
18138 result = (bool)(arg1)->DeleteAll();
18139
18140 wxPyEndAllowThreads(__tstate);
18141 if (PyErr_Occurred()) SWIG_fail;
18142 }
18143 {
18144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18145 }
18146 return resultobj;
18147 fail:
18148 return NULL;
18149 }
18150
18151
18152 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18153 PyObject *resultobj;
18154 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18155 bool arg2 = (bool) true ;
18156 PyObject * obj0 = 0 ;
18157 PyObject * obj1 = 0 ;
18158 char *kwnames[] = {
18159 (char *) "self",(char *) "doIt", NULL
18160 };
18161
18162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18164 if (SWIG_arg_fail(1)) SWIG_fail;
18165 if (obj1) {
18166 {
18167 arg2 = (bool)(SWIG_As_bool(obj1));
18168 if (SWIG_arg_fail(2)) SWIG_fail;
18169 }
18170 }
18171 {
18172 PyThreadState* __tstate = wxPyBeginAllowThreads();
18173 (arg1)->SetExpandEnvVars(arg2);
18174
18175 wxPyEndAllowThreads(__tstate);
18176 if (PyErr_Occurred()) SWIG_fail;
18177 }
18178 Py_INCREF(Py_None); resultobj = Py_None;
18179 return resultobj;
18180 fail:
18181 return NULL;
18182 }
18183
18184
18185 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18186 PyObject *resultobj;
18187 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18188 bool result;
18189 PyObject * obj0 = 0 ;
18190 char *kwnames[] = {
18191 (char *) "self", NULL
18192 };
18193
18194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18196 if (SWIG_arg_fail(1)) SWIG_fail;
18197 {
18198 PyThreadState* __tstate = wxPyBeginAllowThreads();
18199 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18200
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 {
18205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18206 }
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18214 PyObject *resultobj;
18215 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18216 bool arg2 = (bool) true ;
18217 PyObject * obj0 = 0 ;
18218 PyObject * obj1 = 0 ;
18219 char *kwnames[] = {
18220 (char *) "self",(char *) "doIt", NULL
18221 };
18222
18223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18225 if (SWIG_arg_fail(1)) SWIG_fail;
18226 if (obj1) {
18227 {
18228 arg2 = (bool)(SWIG_As_bool(obj1));
18229 if (SWIG_arg_fail(2)) SWIG_fail;
18230 }
18231 }
18232 {
18233 PyThreadState* __tstate = wxPyBeginAllowThreads();
18234 (arg1)->SetRecordDefaults(arg2);
18235
18236 wxPyEndAllowThreads(__tstate);
18237 if (PyErr_Occurred()) SWIG_fail;
18238 }
18239 Py_INCREF(Py_None); resultobj = Py_None;
18240 return resultobj;
18241 fail:
18242 return NULL;
18243 }
18244
18245
18246 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18247 PyObject *resultobj;
18248 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18249 bool result;
18250 PyObject * obj0 = 0 ;
18251 char *kwnames[] = {
18252 (char *) "self", NULL
18253 };
18254
18255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18257 if (SWIG_arg_fail(1)) SWIG_fail;
18258 {
18259 PyThreadState* __tstate = wxPyBeginAllowThreads();
18260 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18261
18262 wxPyEndAllowThreads(__tstate);
18263 if (PyErr_Occurred()) SWIG_fail;
18264 }
18265 {
18266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18267 }
18268 return resultobj;
18269 fail:
18270 return NULL;
18271 }
18272
18273
18274 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18275 PyObject *resultobj;
18276 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18277 wxString *arg2 = 0 ;
18278 wxString result;
18279 bool temp2 = false ;
18280 PyObject * obj0 = 0 ;
18281 PyObject * obj1 = 0 ;
18282 char *kwnames[] = {
18283 (char *) "self",(char *) "str", NULL
18284 };
18285
18286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18288 if (SWIG_arg_fail(1)) SWIG_fail;
18289 {
18290 arg2 = wxString_in_helper(obj1);
18291 if (arg2 == NULL) SWIG_fail;
18292 temp2 = true;
18293 }
18294 {
18295 PyThreadState* __tstate = wxPyBeginAllowThreads();
18296 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18297
18298 wxPyEndAllowThreads(__tstate);
18299 if (PyErr_Occurred()) SWIG_fail;
18300 }
18301 {
18302 #if wxUSE_UNICODE
18303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18304 #else
18305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18306 #endif
18307 }
18308 {
18309 if (temp2)
18310 delete arg2;
18311 }
18312 return resultobj;
18313 fail:
18314 {
18315 if (temp2)
18316 delete arg2;
18317 }
18318 return NULL;
18319 }
18320
18321
18322 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18323 PyObject *resultobj;
18324 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18325 wxString result;
18326 PyObject * obj0 = 0 ;
18327 char *kwnames[] = {
18328 (char *) "self", NULL
18329 };
18330
18331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18333 if (SWIG_arg_fail(1)) SWIG_fail;
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 result = ((wxConfigBase const *)arg1)->GetAppName();
18337
18338 wxPyEndAllowThreads(__tstate);
18339 if (PyErr_Occurred()) SWIG_fail;
18340 }
18341 {
18342 #if wxUSE_UNICODE
18343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18344 #else
18345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18346 #endif
18347 }
18348 return resultobj;
18349 fail:
18350 return NULL;
18351 }
18352
18353
18354 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18355 PyObject *resultobj;
18356 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18357 wxString result;
18358 PyObject * obj0 = 0 ;
18359 char *kwnames[] = {
18360 (char *) "self", NULL
18361 };
18362
18363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18365 if (SWIG_arg_fail(1)) SWIG_fail;
18366 {
18367 PyThreadState* __tstate = wxPyBeginAllowThreads();
18368 result = ((wxConfigBase const *)arg1)->GetVendorName();
18369
18370 wxPyEndAllowThreads(__tstate);
18371 if (PyErr_Occurred()) SWIG_fail;
18372 }
18373 {
18374 #if wxUSE_UNICODE
18375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18376 #else
18377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18378 #endif
18379 }
18380 return resultobj;
18381 fail:
18382 return NULL;
18383 }
18384
18385
18386 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj;
18388 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18389 wxString *arg2 = 0 ;
18390 bool temp2 = false ;
18391 PyObject * obj0 = 0 ;
18392 PyObject * obj1 = 0 ;
18393 char *kwnames[] = {
18394 (char *) "self",(char *) "appName", NULL
18395 };
18396
18397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18399 if (SWIG_arg_fail(1)) SWIG_fail;
18400 {
18401 arg2 = wxString_in_helper(obj1);
18402 if (arg2 == NULL) SWIG_fail;
18403 temp2 = true;
18404 }
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 (arg1)->SetAppName((wxString const &)*arg2);
18408
18409 wxPyEndAllowThreads(__tstate);
18410 if (PyErr_Occurred()) SWIG_fail;
18411 }
18412 Py_INCREF(Py_None); resultobj = Py_None;
18413 {
18414 if (temp2)
18415 delete arg2;
18416 }
18417 return resultobj;
18418 fail:
18419 {
18420 if (temp2)
18421 delete arg2;
18422 }
18423 return NULL;
18424 }
18425
18426
18427 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj;
18429 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18430 wxString *arg2 = 0 ;
18431 bool temp2 = false ;
18432 PyObject * obj0 = 0 ;
18433 PyObject * obj1 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self",(char *) "vendorName", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 {
18442 arg2 = wxString_in_helper(obj1);
18443 if (arg2 == NULL) SWIG_fail;
18444 temp2 = true;
18445 }
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 (arg1)->SetVendorName((wxString const &)*arg2);
18449
18450 wxPyEndAllowThreads(__tstate);
18451 if (PyErr_Occurred()) SWIG_fail;
18452 }
18453 Py_INCREF(Py_None); resultobj = Py_None;
18454 {
18455 if (temp2)
18456 delete arg2;
18457 }
18458 return resultobj;
18459 fail:
18460 {
18461 if (temp2)
18462 delete arg2;
18463 }
18464 return NULL;
18465 }
18466
18467
18468 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18469 PyObject *resultobj;
18470 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18471 long arg2 ;
18472 PyObject * obj0 = 0 ;
18473 PyObject * obj1 = 0 ;
18474 char *kwnames[] = {
18475 (char *) "self",(char *) "style", NULL
18476 };
18477
18478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18480 if (SWIG_arg_fail(1)) SWIG_fail;
18481 {
18482 arg2 = (long)(SWIG_As_long(obj1));
18483 if (SWIG_arg_fail(2)) SWIG_fail;
18484 }
18485 {
18486 PyThreadState* __tstate = wxPyBeginAllowThreads();
18487 (arg1)->SetStyle(arg2);
18488
18489 wxPyEndAllowThreads(__tstate);
18490 if (PyErr_Occurred()) SWIG_fail;
18491 }
18492 Py_INCREF(Py_None); resultobj = Py_None;
18493 return resultobj;
18494 fail:
18495 return NULL;
18496 }
18497
18498
18499 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18500 PyObject *resultobj;
18501 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18502 long result;
18503 PyObject * obj0 = 0 ;
18504 char *kwnames[] = {
18505 (char *) "self", NULL
18506 };
18507
18508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18510 if (SWIG_arg_fail(1)) SWIG_fail;
18511 {
18512 PyThreadState* __tstate = wxPyBeginAllowThreads();
18513 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18514
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 {
18519 resultobj = SWIG_From_long((long)(result));
18520 }
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18528 PyObject *obj;
18529 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18530 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18531 Py_INCREF(obj);
18532 return Py_BuildValue((char *)"");
18533 }
18534 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18535 PyObject *resultobj;
18536 wxString const &arg1_defvalue = wxPyEmptyString ;
18537 wxString *arg1 = (wxString *) &arg1_defvalue ;
18538 wxString const &arg2_defvalue = wxPyEmptyString ;
18539 wxString *arg2 = (wxString *) &arg2_defvalue ;
18540 wxString const &arg3_defvalue = wxPyEmptyString ;
18541 wxString *arg3 = (wxString *) &arg3_defvalue ;
18542 wxString const &arg4_defvalue = wxPyEmptyString ;
18543 wxString *arg4 = (wxString *) &arg4_defvalue ;
18544 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18545 wxConfig *result;
18546 bool temp1 = false ;
18547 bool temp2 = false ;
18548 bool temp3 = false ;
18549 bool temp4 = false ;
18550 PyObject * obj0 = 0 ;
18551 PyObject * obj1 = 0 ;
18552 PyObject * obj2 = 0 ;
18553 PyObject * obj3 = 0 ;
18554 PyObject * obj4 = 0 ;
18555 char *kwnames[] = {
18556 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18557 };
18558
18559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18560 if (obj0) {
18561 {
18562 arg1 = wxString_in_helper(obj0);
18563 if (arg1 == NULL) SWIG_fail;
18564 temp1 = true;
18565 }
18566 }
18567 if (obj1) {
18568 {
18569 arg2 = wxString_in_helper(obj1);
18570 if (arg2 == NULL) SWIG_fail;
18571 temp2 = true;
18572 }
18573 }
18574 if (obj2) {
18575 {
18576 arg3 = wxString_in_helper(obj2);
18577 if (arg3 == NULL) SWIG_fail;
18578 temp3 = true;
18579 }
18580 }
18581 if (obj3) {
18582 {
18583 arg4 = wxString_in_helper(obj3);
18584 if (arg4 == NULL) SWIG_fail;
18585 temp4 = true;
18586 }
18587 }
18588 if (obj4) {
18589 {
18590 arg5 = (long)(SWIG_As_long(obj4));
18591 if (SWIG_arg_fail(5)) SWIG_fail;
18592 }
18593 }
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18597
18598 wxPyEndAllowThreads(__tstate);
18599 if (PyErr_Occurred()) SWIG_fail;
18600 }
18601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18602 {
18603 if (temp1)
18604 delete arg1;
18605 }
18606 {
18607 if (temp2)
18608 delete arg2;
18609 }
18610 {
18611 if (temp3)
18612 delete arg3;
18613 }
18614 {
18615 if (temp4)
18616 delete arg4;
18617 }
18618 return resultobj;
18619 fail:
18620 {
18621 if (temp1)
18622 delete arg1;
18623 }
18624 {
18625 if (temp2)
18626 delete arg2;
18627 }
18628 {
18629 if (temp3)
18630 delete arg3;
18631 }
18632 {
18633 if (temp4)
18634 delete arg4;
18635 }
18636 return NULL;
18637 }
18638
18639
18640 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18641 PyObject *resultobj;
18642 wxConfig *arg1 = (wxConfig *) 0 ;
18643 PyObject * obj0 = 0 ;
18644 char *kwnames[] = {
18645 (char *) "self", NULL
18646 };
18647
18648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18650 if (SWIG_arg_fail(1)) SWIG_fail;
18651 {
18652 PyThreadState* __tstate = wxPyBeginAllowThreads();
18653 delete arg1;
18654
18655 wxPyEndAllowThreads(__tstate);
18656 if (PyErr_Occurred()) SWIG_fail;
18657 }
18658 Py_INCREF(Py_None); resultobj = Py_None;
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18666 PyObject *obj;
18667 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18668 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18669 Py_INCREF(obj);
18670 return Py_BuildValue((char *)"");
18671 }
18672 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj;
18674 wxString const &arg1_defvalue = wxPyEmptyString ;
18675 wxString *arg1 = (wxString *) &arg1_defvalue ;
18676 wxString const &arg2_defvalue = wxPyEmptyString ;
18677 wxString *arg2 = (wxString *) &arg2_defvalue ;
18678 wxString const &arg3_defvalue = wxPyEmptyString ;
18679 wxString *arg3 = (wxString *) &arg3_defvalue ;
18680 wxString const &arg4_defvalue = wxPyEmptyString ;
18681 wxString *arg4 = (wxString *) &arg4_defvalue ;
18682 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18683 wxFileConfig *result;
18684 bool temp1 = false ;
18685 bool temp2 = false ;
18686 bool temp3 = false ;
18687 bool temp4 = false ;
18688 PyObject * obj0 = 0 ;
18689 PyObject * obj1 = 0 ;
18690 PyObject * obj2 = 0 ;
18691 PyObject * obj3 = 0 ;
18692 PyObject * obj4 = 0 ;
18693 char *kwnames[] = {
18694 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18695 };
18696
18697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18698 if (obj0) {
18699 {
18700 arg1 = wxString_in_helper(obj0);
18701 if (arg1 == NULL) SWIG_fail;
18702 temp1 = true;
18703 }
18704 }
18705 if (obj1) {
18706 {
18707 arg2 = wxString_in_helper(obj1);
18708 if (arg2 == NULL) SWIG_fail;
18709 temp2 = true;
18710 }
18711 }
18712 if (obj2) {
18713 {
18714 arg3 = wxString_in_helper(obj2);
18715 if (arg3 == NULL) SWIG_fail;
18716 temp3 = true;
18717 }
18718 }
18719 if (obj3) {
18720 {
18721 arg4 = wxString_in_helper(obj3);
18722 if (arg4 == NULL) SWIG_fail;
18723 temp4 = true;
18724 }
18725 }
18726 if (obj4) {
18727 {
18728 arg5 = (long)(SWIG_As_long(obj4));
18729 if (SWIG_arg_fail(5)) SWIG_fail;
18730 }
18731 }
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18735
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18740 {
18741 if (temp1)
18742 delete arg1;
18743 }
18744 {
18745 if (temp2)
18746 delete arg2;
18747 }
18748 {
18749 if (temp3)
18750 delete arg3;
18751 }
18752 {
18753 if (temp4)
18754 delete arg4;
18755 }
18756 return resultobj;
18757 fail:
18758 {
18759 if (temp1)
18760 delete arg1;
18761 }
18762 {
18763 if (temp2)
18764 delete arg2;
18765 }
18766 {
18767 if (temp3)
18768 delete arg3;
18769 }
18770 {
18771 if (temp4)
18772 delete arg4;
18773 }
18774 return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj;
18780 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18781 PyObject * obj0 = 0 ;
18782 char *kwnames[] = {
18783 (char *) "self", NULL
18784 };
18785
18786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18788 if (SWIG_arg_fail(1)) SWIG_fail;
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 delete arg1;
18792
18793 wxPyEndAllowThreads(__tstate);
18794 if (PyErr_Occurred()) SWIG_fail;
18795 }
18796 Py_INCREF(Py_None); resultobj = Py_None;
18797 return resultobj;
18798 fail:
18799 return NULL;
18800 }
18801
18802
18803 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18804 PyObject *obj;
18805 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18806 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18807 Py_INCREF(obj);
18808 return Py_BuildValue((char *)"");
18809 }
18810 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18811 PyObject *resultobj;
18812 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18813 wxString *arg2 = 0 ;
18814 wxConfigPathChanger *result;
18815 bool temp2 = false ;
18816 PyObject * obj0 = 0 ;
18817 PyObject * obj1 = 0 ;
18818 char *kwnames[] = {
18819 (char *) "config",(char *) "entry", NULL
18820 };
18821
18822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18824 if (SWIG_arg_fail(1)) SWIG_fail;
18825 {
18826 arg2 = wxString_in_helper(obj1);
18827 if (arg2 == NULL) SWIG_fail;
18828 temp2 = true;
18829 }
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18833
18834 wxPyEndAllowThreads(__tstate);
18835 if (PyErr_Occurred()) SWIG_fail;
18836 }
18837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18838 {
18839 if (temp2)
18840 delete arg2;
18841 }
18842 return resultobj;
18843 fail:
18844 {
18845 if (temp2)
18846 delete arg2;
18847 }
18848 return NULL;
18849 }
18850
18851
18852 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18853 PyObject *resultobj;
18854 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18855 PyObject * obj0 = 0 ;
18856 char *kwnames[] = {
18857 (char *) "self", NULL
18858 };
18859
18860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18862 if (SWIG_arg_fail(1)) SWIG_fail;
18863 {
18864 PyThreadState* __tstate = wxPyBeginAllowThreads();
18865 delete arg1;
18866
18867 wxPyEndAllowThreads(__tstate);
18868 if (PyErr_Occurred()) SWIG_fail;
18869 }
18870 Py_INCREF(Py_None); resultobj = Py_None;
18871 return resultobj;
18872 fail:
18873 return NULL;
18874 }
18875
18876
18877 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18878 PyObject *resultobj;
18879 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18880 wxString *result;
18881 PyObject * obj0 = 0 ;
18882 char *kwnames[] = {
18883 (char *) "self", NULL
18884 };
18885
18886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18888 if (SWIG_arg_fail(1)) SWIG_fail;
18889 {
18890 PyThreadState* __tstate = wxPyBeginAllowThreads();
18891 {
18892 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18893 result = (wxString *) &_result_ref;
18894 }
18895
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 {
18900 #if wxUSE_UNICODE
18901 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18902 #else
18903 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18904 #endif
18905 }
18906 return resultobj;
18907 fail:
18908 return NULL;
18909 }
18910
18911
18912 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18913 PyObject *obj;
18914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18915 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18916 Py_INCREF(obj);
18917 return Py_BuildValue((char *)"");
18918 }
18919 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18920 PyObject *resultobj;
18921 wxString *arg1 = 0 ;
18922 wxString result;
18923 bool temp1 = false ;
18924 PyObject * obj0 = 0 ;
18925 char *kwnames[] = {
18926 (char *) "sz", NULL
18927 };
18928
18929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18930 {
18931 arg1 = wxString_in_helper(obj0);
18932 if (arg1 == NULL) SWIG_fail;
18933 temp1 = true;
18934 }
18935 {
18936 PyThreadState* __tstate = wxPyBeginAllowThreads();
18937 result = wxExpandEnvVars((wxString const &)*arg1);
18938
18939 wxPyEndAllowThreads(__tstate);
18940 if (PyErr_Occurred()) SWIG_fail;
18941 }
18942 {
18943 #if wxUSE_UNICODE
18944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18945 #else
18946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18947 #endif
18948 }
18949 {
18950 if (temp1)
18951 delete arg1;
18952 }
18953 return resultobj;
18954 fail:
18955 {
18956 if (temp1)
18957 delete arg1;
18958 }
18959 return NULL;
18960 }
18961
18962
18963 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18964 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18965 return 1;
18966 }
18967
18968
18969 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18970 PyObject *pyobj;
18971
18972 {
18973 #if wxUSE_UNICODE
18974 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18975 #else
18976 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18977 #endif
18978 }
18979 return pyobj;
18980 }
18981
18982
18983 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18984 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18985 return 1;
18986 }
18987
18988
18989 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18990 PyObject *pyobj;
18991
18992 {
18993 #if wxUSE_UNICODE
18994 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18995 #else
18996 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18997 #endif
18998 }
18999 return pyobj;
19000 }
19001
19002
19003 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19004 PyObject *resultobj;
19005 wxDateTime::Country arg1 ;
19006 PyObject * obj0 = 0 ;
19007 char *kwnames[] = {
19008 (char *) "country", NULL
19009 };
19010
19011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19012 {
19013 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19014 if (SWIG_arg_fail(1)) SWIG_fail;
19015 }
19016 {
19017 PyThreadState* __tstate = wxPyBeginAllowThreads();
19018 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19019
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 Py_INCREF(Py_None); resultobj = Py_None;
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj;
19032 wxDateTime::Country result;
19033 char *kwnames[] = {
19034 NULL
19035 };
19036
19037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19038 {
19039 PyThreadState* __tstate = wxPyBeginAllowThreads();
19040 result = (wxDateTime::Country)wxDateTime::GetCountry();
19041
19042 wxPyEndAllowThreads(__tstate);
19043 if (PyErr_Occurred()) SWIG_fail;
19044 }
19045 resultobj = SWIG_From_int((result));
19046 return resultobj;
19047 fail:
19048 return NULL;
19049 }
19050
19051
19052 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19053 PyObject *resultobj;
19054 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19055 bool result;
19056 PyObject * obj0 = 0 ;
19057 char *kwnames[] = {
19058 (char *) "country", NULL
19059 };
19060
19061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19062 if (obj0) {
19063 {
19064 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19065 if (SWIG_arg_fail(1)) SWIG_fail;
19066 }
19067 }
19068 {
19069 PyThreadState* __tstate = wxPyBeginAllowThreads();
19070 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19071
19072 wxPyEndAllowThreads(__tstate);
19073 if (PyErr_Occurred()) SWIG_fail;
19074 }
19075 {
19076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19077 }
19078 return resultobj;
19079 fail:
19080 return NULL;
19081 }
19082
19083
19084 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19085 PyObject *resultobj;
19086 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19087 int result;
19088 PyObject * obj0 = 0 ;
19089 char *kwnames[] = {
19090 (char *) "cal", NULL
19091 };
19092
19093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19094 if (obj0) {
19095 {
19096 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19097 if (SWIG_arg_fail(1)) SWIG_fail;
19098 }
19099 }
19100 {
19101 PyThreadState* __tstate = wxPyBeginAllowThreads();
19102 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19103
19104 wxPyEndAllowThreads(__tstate);
19105 if (PyErr_Occurred()) SWIG_fail;
19106 }
19107 {
19108 resultobj = SWIG_From_int((int)(result));
19109 }
19110 return resultobj;
19111 fail:
19112 return NULL;
19113 }
19114
19115
19116 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19117 PyObject *resultobj;
19118 int arg1 ;
19119 int result;
19120 PyObject * obj0 = 0 ;
19121 char *kwnames[] = {
19122 (char *) "year", NULL
19123 };
19124
19125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19126 {
19127 arg1 = (int)(SWIG_As_int(obj0));
19128 if (SWIG_arg_fail(1)) SWIG_fail;
19129 }
19130 {
19131 PyThreadState* __tstate = wxPyBeginAllowThreads();
19132 result = (int)wxDateTime::ConvertYearToBC(arg1);
19133
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 {
19138 resultobj = SWIG_From_int((int)(result));
19139 }
19140 return resultobj;
19141 fail:
19142 return NULL;
19143 }
19144
19145
19146 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19147 PyObject *resultobj;
19148 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19149 wxDateTime::Month result;
19150 PyObject * obj0 = 0 ;
19151 char *kwnames[] = {
19152 (char *) "cal", NULL
19153 };
19154
19155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19156 if (obj0) {
19157 {
19158 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19159 if (SWIG_arg_fail(1)) SWIG_fail;
19160 }
19161 }
19162 {
19163 PyThreadState* __tstate = wxPyBeginAllowThreads();
19164 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19165
19166 wxPyEndAllowThreads(__tstate);
19167 if (PyErr_Occurred()) SWIG_fail;
19168 }
19169 resultobj = SWIG_From_int((result));
19170 return resultobj;
19171 fail:
19172 return NULL;
19173 }
19174
19175
19176 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19177 PyObject *resultobj;
19178 int arg1 = (int) wxDateTime::Inv_Year ;
19179 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19180 bool result;
19181 PyObject * obj0 = 0 ;
19182 PyObject * obj1 = 0 ;
19183 char *kwnames[] = {
19184 (char *) "year",(char *) "cal", NULL
19185 };
19186
19187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19188 if (obj0) {
19189 {
19190 arg1 = (int)(SWIG_As_int(obj0));
19191 if (SWIG_arg_fail(1)) SWIG_fail;
19192 }
19193 }
19194 if (obj1) {
19195 {
19196 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19197 if (SWIG_arg_fail(2)) SWIG_fail;
19198 }
19199 }
19200 {
19201 PyThreadState* __tstate = wxPyBeginAllowThreads();
19202 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19203
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 {
19208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19209 }
19210 return resultobj;
19211 fail:
19212 return NULL;
19213 }
19214
19215
19216 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19217 PyObject *resultobj;
19218 int arg1 = (int) wxDateTime::Inv_Year ;
19219 int result;
19220 PyObject * obj0 = 0 ;
19221 char *kwnames[] = {
19222 (char *) "year", NULL
19223 };
19224
19225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19226 if (obj0) {
19227 {
19228 arg1 = (int)(SWIG_As_int(obj0));
19229 if (SWIG_arg_fail(1)) SWIG_fail;
19230 }
19231 }
19232 {
19233 PyThreadState* __tstate = wxPyBeginAllowThreads();
19234 result = (int)wxDateTime::GetCentury(arg1);
19235
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 {
19240 resultobj = SWIG_From_int((int)(result));
19241 }
19242 return resultobj;
19243 fail:
19244 return NULL;
19245 }
19246
19247
19248 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19249 PyObject *resultobj;
19250 int arg1 ;
19251 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19252 int result;
19253 PyObject * obj0 = 0 ;
19254 PyObject * obj1 = 0 ;
19255 char *kwnames[] = {
19256 (char *) "year",(char *) "cal", NULL
19257 };
19258
19259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19260 {
19261 arg1 = (int)(SWIG_As_int(obj0));
19262 if (SWIG_arg_fail(1)) SWIG_fail;
19263 }
19264 if (obj1) {
19265 {
19266 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19267 if (SWIG_arg_fail(2)) SWIG_fail;
19268 }
19269 }
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19273
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 {
19278 resultobj = SWIG_From_int((int)(result));
19279 }
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19287 PyObject *resultobj;
19288 wxDateTime::Month arg1 ;
19289 int arg2 = (int) wxDateTime::Inv_Year ;
19290 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19291 int result;
19292 PyObject * obj0 = 0 ;
19293 PyObject * obj1 = 0 ;
19294 PyObject * obj2 = 0 ;
19295 char *kwnames[] = {
19296 (char *) "month",(char *) "year",(char *) "cal", NULL
19297 };
19298
19299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19300 {
19301 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19302 if (SWIG_arg_fail(1)) SWIG_fail;
19303 }
19304 if (obj1) {
19305 {
19306 arg2 = (int)(SWIG_As_int(obj1));
19307 if (SWIG_arg_fail(2)) SWIG_fail;
19308 }
19309 }
19310 if (obj2) {
19311 {
19312 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19313 if (SWIG_arg_fail(3)) SWIG_fail;
19314 }
19315 }
19316 {
19317 PyThreadState* __tstate = wxPyBeginAllowThreads();
19318 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19319
19320 wxPyEndAllowThreads(__tstate);
19321 if (PyErr_Occurred()) SWIG_fail;
19322 }
19323 {
19324 resultobj = SWIG_From_int((int)(result));
19325 }
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19333 PyObject *resultobj;
19334 wxDateTime::Month arg1 ;
19335 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19336 wxString result;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char *kwnames[] = {
19340 (char *) "month",(char *) "flags", NULL
19341 };
19342
19343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19344 {
19345 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19346 if (SWIG_arg_fail(1)) SWIG_fail;
19347 }
19348 if (obj1) {
19349 {
19350 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19351 if (SWIG_arg_fail(2)) SWIG_fail;
19352 }
19353 }
19354 {
19355 PyThreadState* __tstate = wxPyBeginAllowThreads();
19356 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19357
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 {
19362 #if wxUSE_UNICODE
19363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19364 #else
19365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19366 #endif
19367 }
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj;
19376 wxDateTime::WeekDay arg1 ;
19377 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19378 wxString result;
19379 PyObject * obj0 = 0 ;
19380 PyObject * obj1 = 0 ;
19381 char *kwnames[] = {
19382 (char *) "weekday",(char *) "flags", NULL
19383 };
19384
19385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19386 {
19387 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19388 if (SWIG_arg_fail(1)) SWIG_fail;
19389 }
19390 if (obj1) {
19391 {
19392 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19393 if (SWIG_arg_fail(2)) SWIG_fail;
19394 }
19395 }
19396 {
19397 PyThreadState* __tstate = wxPyBeginAllowThreads();
19398 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19399
19400 wxPyEndAllowThreads(__tstate);
19401 if (PyErr_Occurred()) SWIG_fail;
19402 }
19403 {
19404 #if wxUSE_UNICODE
19405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19406 #else
19407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19408 #endif
19409 }
19410 return resultobj;
19411 fail:
19412 return NULL;
19413 }
19414
19415
19416 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19417 PyObject *resultobj;
19418 PyObject *result;
19419 char *kwnames[] = {
19420 NULL
19421 };
19422
19423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19424 {
19425 PyThreadState* __tstate = wxPyBeginAllowThreads();
19426 result = (PyObject *)DateTime_GetAmPmStrings();
19427
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 resultobj = result;
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19439 PyObject *resultobj;
19440 int arg1 = (int) wxDateTime::Inv_Year ;
19441 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19442 bool result;
19443 PyObject * obj0 = 0 ;
19444 PyObject * obj1 = 0 ;
19445 char *kwnames[] = {
19446 (char *) "year",(char *) "country", NULL
19447 };
19448
19449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19450 if (obj0) {
19451 {
19452 arg1 = (int)(SWIG_As_int(obj0));
19453 if (SWIG_arg_fail(1)) SWIG_fail;
19454 }
19455 }
19456 if (obj1) {
19457 {
19458 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19459 if (SWIG_arg_fail(2)) SWIG_fail;
19460 }
19461 }
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19465
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 {
19470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19471 }
19472 return resultobj;
19473 fail:
19474 return NULL;
19475 }
19476
19477
19478 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19479 PyObject *resultobj;
19480 int arg1 = (int) wxDateTime::Inv_Year ;
19481 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19482 wxDateTime result;
19483 PyObject * obj0 = 0 ;
19484 PyObject * obj1 = 0 ;
19485 char *kwnames[] = {
19486 (char *) "year",(char *) "country", NULL
19487 };
19488
19489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19490 if (obj0) {
19491 {
19492 arg1 = (int)(SWIG_As_int(obj0));
19493 if (SWIG_arg_fail(1)) SWIG_fail;
19494 }
19495 }
19496 if (obj1) {
19497 {
19498 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19499 if (SWIG_arg_fail(2)) SWIG_fail;
19500 }
19501 }
19502 {
19503 PyThreadState* __tstate = wxPyBeginAllowThreads();
19504 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19505
19506 wxPyEndAllowThreads(__tstate);
19507 if (PyErr_Occurred()) SWIG_fail;
19508 }
19509 {
19510 wxDateTime * resultptr;
19511 resultptr = new wxDateTime((wxDateTime &)(result));
19512 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19513 }
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19521 PyObject *resultobj;
19522 int arg1 = (int) wxDateTime::Inv_Year ;
19523 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19524 wxDateTime result;
19525 PyObject * obj0 = 0 ;
19526 PyObject * obj1 = 0 ;
19527 char *kwnames[] = {
19528 (char *) "year",(char *) "country", NULL
19529 };
19530
19531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19532 if (obj0) {
19533 {
19534 arg1 = (int)(SWIG_As_int(obj0));
19535 if (SWIG_arg_fail(1)) SWIG_fail;
19536 }
19537 }
19538 if (obj1) {
19539 {
19540 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19541 if (SWIG_arg_fail(2)) SWIG_fail;
19542 }
19543 }
19544 {
19545 PyThreadState* __tstate = wxPyBeginAllowThreads();
19546 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19547
19548 wxPyEndAllowThreads(__tstate);
19549 if (PyErr_Occurred()) SWIG_fail;
19550 }
19551 {
19552 wxDateTime * resultptr;
19553 resultptr = new wxDateTime((wxDateTime &)(result));
19554 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19555 }
19556 return resultobj;
19557 fail:
19558 return NULL;
19559 }
19560
19561
19562 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj;
19564 wxDateTime result;
19565 char *kwnames[] = {
19566 NULL
19567 };
19568
19569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19570 {
19571 PyThreadState* __tstate = wxPyBeginAllowThreads();
19572 result = wxDateTime::Now();
19573
19574 wxPyEndAllowThreads(__tstate);
19575 if (PyErr_Occurred()) SWIG_fail;
19576 }
19577 {
19578 wxDateTime * resultptr;
19579 resultptr = new wxDateTime((wxDateTime &)(result));
19580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19581 }
19582 return resultobj;
19583 fail:
19584 return NULL;
19585 }
19586
19587
19588 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19589 PyObject *resultobj;
19590 wxDateTime result;
19591 char *kwnames[] = {
19592 NULL
19593 };
19594
19595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19596 {
19597 PyThreadState* __tstate = wxPyBeginAllowThreads();
19598 result = wxDateTime::UNow();
19599
19600 wxPyEndAllowThreads(__tstate);
19601 if (PyErr_Occurred()) SWIG_fail;
19602 }
19603 {
19604 wxDateTime * resultptr;
19605 resultptr = new wxDateTime((wxDateTime &)(result));
19606 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19607 }
19608 return resultobj;
19609 fail:
19610 return NULL;
19611 }
19612
19613
19614 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19615 PyObject *resultobj;
19616 wxDateTime result;
19617 char *kwnames[] = {
19618 NULL
19619 };
19620
19621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 result = wxDateTime::Today();
19625
19626 wxPyEndAllowThreads(__tstate);
19627 if (PyErr_Occurred()) SWIG_fail;
19628 }
19629 {
19630 wxDateTime * resultptr;
19631 resultptr = new wxDateTime((wxDateTime &)(result));
19632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19633 }
19634 return resultobj;
19635 fail:
19636 return NULL;
19637 }
19638
19639
19640 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19641 PyObject *resultobj;
19642 wxDateTime *result;
19643 char *kwnames[] = {
19644 NULL
19645 };
19646
19647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19648 {
19649 PyThreadState* __tstate = wxPyBeginAllowThreads();
19650 result = (wxDateTime *)new wxDateTime();
19651
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19656 return resultobj;
19657 fail:
19658 return NULL;
19659 }
19660
19661
19662 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj;
19664 time_t arg1 ;
19665 wxDateTime *result;
19666 PyObject * obj0 = 0 ;
19667 char *kwnames[] = {
19668 (char *) "timet", NULL
19669 };
19670
19671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19672 {
19673 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19674 if (SWIG_arg_fail(1)) SWIG_fail;
19675 }
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 result = (wxDateTime *)new wxDateTime(arg1);
19679
19680 wxPyEndAllowThreads(__tstate);
19681 if (PyErr_Occurred()) SWIG_fail;
19682 }
19683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19684 return resultobj;
19685 fail:
19686 return NULL;
19687 }
19688
19689
19690 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19691 PyObject *resultobj;
19692 double arg1 ;
19693 wxDateTime *result;
19694 PyObject * obj0 = 0 ;
19695 char *kwnames[] = {
19696 (char *) "jdn", NULL
19697 };
19698
19699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19700 {
19701 arg1 = (double)(SWIG_As_double(obj0));
19702 if (SWIG_arg_fail(1)) SWIG_fail;
19703 }
19704 {
19705 PyThreadState* __tstate = wxPyBeginAllowThreads();
19706 result = (wxDateTime *)new wxDateTime(arg1);
19707
19708 wxPyEndAllowThreads(__tstate);
19709 if (PyErr_Occurred()) SWIG_fail;
19710 }
19711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19712 return resultobj;
19713 fail:
19714 return NULL;
19715 }
19716
19717
19718 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19719 PyObject *resultobj;
19720 int arg1 ;
19721 int arg2 = (int) 0 ;
19722 int arg3 = (int) 0 ;
19723 int arg4 = (int) 0 ;
19724 wxDateTime *result;
19725 PyObject * obj0 = 0 ;
19726 PyObject * obj1 = 0 ;
19727 PyObject * obj2 = 0 ;
19728 PyObject * obj3 = 0 ;
19729 char *kwnames[] = {
19730 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19731 };
19732
19733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19734 {
19735 arg1 = (int)(SWIG_As_int(obj0));
19736 if (SWIG_arg_fail(1)) SWIG_fail;
19737 }
19738 if (obj1) {
19739 {
19740 arg2 = (int)(SWIG_As_int(obj1));
19741 if (SWIG_arg_fail(2)) SWIG_fail;
19742 }
19743 }
19744 if (obj2) {
19745 {
19746 arg3 = (int)(SWIG_As_int(obj2));
19747 if (SWIG_arg_fail(3)) SWIG_fail;
19748 }
19749 }
19750 if (obj3) {
19751 {
19752 arg4 = (int)(SWIG_As_int(obj3));
19753 if (SWIG_arg_fail(4)) SWIG_fail;
19754 }
19755 }
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19759
19760 wxPyEndAllowThreads(__tstate);
19761 if (PyErr_Occurred()) SWIG_fail;
19762 }
19763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19764 return resultobj;
19765 fail:
19766 return NULL;
19767 }
19768
19769
19770 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19771 PyObject *resultobj;
19772 int arg1 ;
19773 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19774 int arg3 = (int) wxDateTime::Inv_Year ;
19775 int arg4 = (int) 0 ;
19776 int arg5 = (int) 0 ;
19777 int arg6 = (int) 0 ;
19778 int arg7 = (int) 0 ;
19779 wxDateTime *result;
19780 PyObject * obj0 = 0 ;
19781 PyObject * obj1 = 0 ;
19782 PyObject * obj2 = 0 ;
19783 PyObject * obj3 = 0 ;
19784 PyObject * obj4 = 0 ;
19785 PyObject * obj5 = 0 ;
19786 PyObject * obj6 = 0 ;
19787 char *kwnames[] = {
19788 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19789 };
19790
19791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19792 {
19793 arg1 = (int)(SWIG_As_int(obj0));
19794 if (SWIG_arg_fail(1)) SWIG_fail;
19795 }
19796 if (obj1) {
19797 {
19798 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19799 if (SWIG_arg_fail(2)) SWIG_fail;
19800 }
19801 }
19802 if (obj2) {
19803 {
19804 arg3 = (int)(SWIG_As_int(obj2));
19805 if (SWIG_arg_fail(3)) SWIG_fail;
19806 }
19807 }
19808 if (obj3) {
19809 {
19810 arg4 = (int)(SWIG_As_int(obj3));
19811 if (SWIG_arg_fail(4)) SWIG_fail;
19812 }
19813 }
19814 if (obj4) {
19815 {
19816 arg5 = (int)(SWIG_As_int(obj4));
19817 if (SWIG_arg_fail(5)) SWIG_fail;
19818 }
19819 }
19820 if (obj5) {
19821 {
19822 arg6 = (int)(SWIG_As_int(obj5));
19823 if (SWIG_arg_fail(6)) SWIG_fail;
19824 }
19825 }
19826 if (obj6) {
19827 {
19828 arg7 = (int)(SWIG_As_int(obj6));
19829 if (SWIG_arg_fail(7)) SWIG_fail;
19830 }
19831 }
19832 {
19833 PyThreadState* __tstate = wxPyBeginAllowThreads();
19834 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19835
19836 wxPyEndAllowThreads(__tstate);
19837 if (PyErr_Occurred()) SWIG_fail;
19838 }
19839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19840 return resultobj;
19841 fail:
19842 return NULL;
19843 }
19844
19845
19846 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19847 PyObject *resultobj;
19848 wxDateTime *arg1 = (wxDateTime *) 0 ;
19849 PyObject * obj0 = 0 ;
19850 char *kwnames[] = {
19851 (char *) "self", NULL
19852 };
19853
19854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19856 if (SWIG_arg_fail(1)) SWIG_fail;
19857 {
19858 PyThreadState* __tstate = wxPyBeginAllowThreads();
19859 delete arg1;
19860
19861 wxPyEndAllowThreads(__tstate);
19862 if (PyErr_Occurred()) SWIG_fail;
19863 }
19864 Py_INCREF(Py_None); resultobj = Py_None;
19865 return resultobj;
19866 fail:
19867 return NULL;
19868 }
19869
19870
19871 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj;
19873 wxDateTime *arg1 = (wxDateTime *) 0 ;
19874 wxDateTime *result;
19875 PyObject * obj0 = 0 ;
19876 char *kwnames[] = {
19877 (char *) "self", NULL
19878 };
19879
19880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19882 if (SWIG_arg_fail(1)) SWIG_fail;
19883 {
19884 PyThreadState* __tstate = wxPyBeginAllowThreads();
19885 {
19886 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19887 result = (wxDateTime *) &_result_ref;
19888 }
19889
19890 wxPyEndAllowThreads(__tstate);
19891 if (PyErr_Occurred()) SWIG_fail;
19892 }
19893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19894 return resultobj;
19895 fail:
19896 return NULL;
19897 }
19898
19899
19900 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19901 PyObject *resultobj;
19902 wxDateTime *arg1 = (wxDateTime *) 0 ;
19903 time_t arg2 ;
19904 wxDateTime *result;
19905 PyObject * obj0 = 0 ;
19906 PyObject * obj1 = 0 ;
19907 char *kwnames[] = {
19908 (char *) "self",(char *) "timet", NULL
19909 };
19910
19911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19913 if (SWIG_arg_fail(1)) SWIG_fail;
19914 {
19915 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19916 if (SWIG_arg_fail(2)) SWIG_fail;
19917 }
19918 {
19919 PyThreadState* __tstate = wxPyBeginAllowThreads();
19920 {
19921 wxDateTime &_result_ref = (arg1)->Set(arg2);
19922 result = (wxDateTime *) &_result_ref;
19923 }
19924
19925 wxPyEndAllowThreads(__tstate);
19926 if (PyErr_Occurred()) SWIG_fail;
19927 }
19928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19929 return resultobj;
19930 fail:
19931 return NULL;
19932 }
19933
19934
19935 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19936 PyObject *resultobj;
19937 wxDateTime *arg1 = (wxDateTime *) 0 ;
19938 double arg2 ;
19939 wxDateTime *result;
19940 PyObject * obj0 = 0 ;
19941 PyObject * obj1 = 0 ;
19942 char *kwnames[] = {
19943 (char *) "self",(char *) "jdn", NULL
19944 };
19945
19946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19948 if (SWIG_arg_fail(1)) SWIG_fail;
19949 {
19950 arg2 = (double)(SWIG_As_double(obj1));
19951 if (SWIG_arg_fail(2)) SWIG_fail;
19952 }
19953 {
19954 PyThreadState* __tstate = wxPyBeginAllowThreads();
19955 {
19956 wxDateTime &_result_ref = (arg1)->Set(arg2);
19957 result = (wxDateTime *) &_result_ref;
19958 }
19959
19960 wxPyEndAllowThreads(__tstate);
19961 if (PyErr_Occurred()) SWIG_fail;
19962 }
19963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19964 return resultobj;
19965 fail:
19966 return NULL;
19967 }
19968
19969
19970 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19971 PyObject *resultobj;
19972 wxDateTime *arg1 = (wxDateTime *) 0 ;
19973 int arg2 ;
19974 int arg3 = (int) 0 ;
19975 int arg4 = (int) 0 ;
19976 int arg5 = (int) 0 ;
19977 wxDateTime *result;
19978 PyObject * obj0 = 0 ;
19979 PyObject * obj1 = 0 ;
19980 PyObject * obj2 = 0 ;
19981 PyObject * obj3 = 0 ;
19982 PyObject * obj4 = 0 ;
19983 char *kwnames[] = {
19984 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19985 };
19986
19987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19989 if (SWIG_arg_fail(1)) SWIG_fail;
19990 {
19991 arg2 = (int)(SWIG_As_int(obj1));
19992 if (SWIG_arg_fail(2)) SWIG_fail;
19993 }
19994 if (obj2) {
19995 {
19996 arg3 = (int)(SWIG_As_int(obj2));
19997 if (SWIG_arg_fail(3)) SWIG_fail;
19998 }
19999 }
20000 if (obj3) {
20001 {
20002 arg4 = (int)(SWIG_As_int(obj3));
20003 if (SWIG_arg_fail(4)) SWIG_fail;
20004 }
20005 }
20006 if (obj4) {
20007 {
20008 arg5 = (int)(SWIG_As_int(obj4));
20009 if (SWIG_arg_fail(5)) SWIG_fail;
20010 }
20011 }
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 {
20015 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20016 result = (wxDateTime *) &_result_ref;
20017 }
20018
20019 wxPyEndAllowThreads(__tstate);
20020 if (PyErr_Occurred()) SWIG_fail;
20021 }
20022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20023 return resultobj;
20024 fail:
20025 return NULL;
20026 }
20027
20028
20029 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20030 PyObject *resultobj;
20031 wxDateTime *arg1 = (wxDateTime *) 0 ;
20032 int arg2 ;
20033 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20034 int arg4 = (int) wxDateTime::Inv_Year ;
20035 int arg5 = (int) 0 ;
20036 int arg6 = (int) 0 ;
20037 int arg7 = (int) 0 ;
20038 int arg8 = (int) 0 ;
20039 wxDateTime *result;
20040 PyObject * obj0 = 0 ;
20041 PyObject * obj1 = 0 ;
20042 PyObject * obj2 = 0 ;
20043 PyObject * obj3 = 0 ;
20044 PyObject * obj4 = 0 ;
20045 PyObject * obj5 = 0 ;
20046 PyObject * obj6 = 0 ;
20047 PyObject * obj7 = 0 ;
20048 char *kwnames[] = {
20049 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20050 };
20051
20052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20054 if (SWIG_arg_fail(1)) SWIG_fail;
20055 {
20056 arg2 = (int)(SWIG_As_int(obj1));
20057 if (SWIG_arg_fail(2)) SWIG_fail;
20058 }
20059 if (obj2) {
20060 {
20061 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20062 if (SWIG_arg_fail(3)) SWIG_fail;
20063 }
20064 }
20065 if (obj3) {
20066 {
20067 arg4 = (int)(SWIG_As_int(obj3));
20068 if (SWIG_arg_fail(4)) SWIG_fail;
20069 }
20070 }
20071 if (obj4) {
20072 {
20073 arg5 = (int)(SWIG_As_int(obj4));
20074 if (SWIG_arg_fail(5)) SWIG_fail;
20075 }
20076 }
20077 if (obj5) {
20078 {
20079 arg6 = (int)(SWIG_As_int(obj5));
20080 if (SWIG_arg_fail(6)) SWIG_fail;
20081 }
20082 }
20083 if (obj6) {
20084 {
20085 arg7 = (int)(SWIG_As_int(obj6));
20086 if (SWIG_arg_fail(7)) SWIG_fail;
20087 }
20088 }
20089 if (obj7) {
20090 {
20091 arg8 = (int)(SWIG_As_int(obj7));
20092 if (SWIG_arg_fail(8)) SWIG_fail;
20093 }
20094 }
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 {
20098 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20099 result = (wxDateTime *) &_result_ref;
20100 }
20101
20102 wxPyEndAllowThreads(__tstate);
20103 if (PyErr_Occurred()) SWIG_fail;
20104 }
20105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20106 return resultobj;
20107 fail:
20108 return NULL;
20109 }
20110
20111
20112 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20113 PyObject *resultobj;
20114 wxDateTime *arg1 = (wxDateTime *) 0 ;
20115 wxDateTime *result;
20116 PyObject * obj0 = 0 ;
20117 char *kwnames[] = {
20118 (char *) "self", NULL
20119 };
20120
20121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20123 if (SWIG_arg_fail(1)) SWIG_fail;
20124 {
20125 PyThreadState* __tstate = wxPyBeginAllowThreads();
20126 {
20127 wxDateTime &_result_ref = (arg1)->ResetTime();
20128 result = (wxDateTime *) &_result_ref;
20129 }
20130
20131 wxPyEndAllowThreads(__tstate);
20132 if (PyErr_Occurred()) SWIG_fail;
20133 }
20134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20135 return resultobj;
20136 fail:
20137 return NULL;
20138 }
20139
20140
20141 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20142 PyObject *resultobj;
20143 wxDateTime *arg1 = (wxDateTime *) 0 ;
20144 int arg2 ;
20145 wxDateTime *result;
20146 PyObject * obj0 = 0 ;
20147 PyObject * obj1 = 0 ;
20148 char *kwnames[] = {
20149 (char *) "self",(char *) "year", NULL
20150 };
20151
20152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20154 if (SWIG_arg_fail(1)) SWIG_fail;
20155 {
20156 arg2 = (int)(SWIG_As_int(obj1));
20157 if (SWIG_arg_fail(2)) SWIG_fail;
20158 }
20159 {
20160 PyThreadState* __tstate = wxPyBeginAllowThreads();
20161 {
20162 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20163 result = (wxDateTime *) &_result_ref;
20164 }
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj;
20178 wxDateTime *arg1 = (wxDateTime *) 0 ;
20179 wxDateTime::Month arg2 ;
20180 wxDateTime *result;
20181 PyObject * obj0 = 0 ;
20182 PyObject * obj1 = 0 ;
20183 char *kwnames[] = {
20184 (char *) "self",(char *) "month", NULL
20185 };
20186
20187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20189 if (SWIG_arg_fail(1)) SWIG_fail;
20190 {
20191 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20192 if (SWIG_arg_fail(2)) SWIG_fail;
20193 }
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 {
20197 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20198 result = (wxDateTime *) &_result_ref;
20199 }
20200
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20212 PyObject *resultobj;
20213 wxDateTime *arg1 = (wxDateTime *) 0 ;
20214 int arg2 ;
20215 wxDateTime *result;
20216 PyObject * obj0 = 0 ;
20217 PyObject * obj1 = 0 ;
20218 char *kwnames[] = {
20219 (char *) "self",(char *) "day", NULL
20220 };
20221
20222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20224 if (SWIG_arg_fail(1)) SWIG_fail;
20225 {
20226 arg2 = (int)(SWIG_As_int(obj1));
20227 if (SWIG_arg_fail(2)) SWIG_fail;
20228 }
20229 {
20230 PyThreadState* __tstate = wxPyBeginAllowThreads();
20231 {
20232 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20233 result = (wxDateTime *) &_result_ref;
20234 }
20235
20236 wxPyEndAllowThreads(__tstate);
20237 if (PyErr_Occurred()) SWIG_fail;
20238 }
20239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20247 PyObject *resultobj;
20248 wxDateTime *arg1 = (wxDateTime *) 0 ;
20249 int arg2 ;
20250 wxDateTime *result;
20251 PyObject * obj0 = 0 ;
20252 PyObject * obj1 = 0 ;
20253 char *kwnames[] = {
20254 (char *) "self",(char *) "hour", NULL
20255 };
20256
20257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20259 if (SWIG_arg_fail(1)) SWIG_fail;
20260 {
20261 arg2 = (int)(SWIG_As_int(obj1));
20262 if (SWIG_arg_fail(2)) SWIG_fail;
20263 }
20264 {
20265 PyThreadState* __tstate = wxPyBeginAllowThreads();
20266 {
20267 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20268 result = (wxDateTime *) &_result_ref;
20269 }
20270
20271 wxPyEndAllowThreads(__tstate);
20272 if (PyErr_Occurred()) SWIG_fail;
20273 }
20274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20275 return resultobj;
20276 fail:
20277 return NULL;
20278 }
20279
20280
20281 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20282 PyObject *resultobj;
20283 wxDateTime *arg1 = (wxDateTime *) 0 ;
20284 int arg2 ;
20285 wxDateTime *result;
20286 PyObject * obj0 = 0 ;
20287 PyObject * obj1 = 0 ;
20288 char *kwnames[] = {
20289 (char *) "self",(char *) "minute", NULL
20290 };
20291
20292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20294 if (SWIG_arg_fail(1)) SWIG_fail;
20295 {
20296 arg2 = (int)(SWIG_As_int(obj1));
20297 if (SWIG_arg_fail(2)) SWIG_fail;
20298 }
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 {
20302 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20303 result = (wxDateTime *) &_result_ref;
20304 }
20305
20306 wxPyEndAllowThreads(__tstate);
20307 if (PyErr_Occurred()) SWIG_fail;
20308 }
20309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20310 return resultobj;
20311 fail:
20312 return NULL;
20313 }
20314
20315
20316 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20317 PyObject *resultobj;
20318 wxDateTime *arg1 = (wxDateTime *) 0 ;
20319 int arg2 ;
20320 wxDateTime *result;
20321 PyObject * obj0 = 0 ;
20322 PyObject * obj1 = 0 ;
20323 char *kwnames[] = {
20324 (char *) "self",(char *) "second", NULL
20325 };
20326
20327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20329 if (SWIG_arg_fail(1)) SWIG_fail;
20330 {
20331 arg2 = (int)(SWIG_As_int(obj1));
20332 if (SWIG_arg_fail(2)) SWIG_fail;
20333 }
20334 {
20335 PyThreadState* __tstate = wxPyBeginAllowThreads();
20336 {
20337 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20338 result = (wxDateTime *) &_result_ref;
20339 }
20340
20341 wxPyEndAllowThreads(__tstate);
20342 if (PyErr_Occurred()) SWIG_fail;
20343 }
20344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20345 return resultobj;
20346 fail:
20347 return NULL;
20348 }
20349
20350
20351 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20352 PyObject *resultobj;
20353 wxDateTime *arg1 = (wxDateTime *) 0 ;
20354 int arg2 ;
20355 wxDateTime *result;
20356 PyObject * obj0 = 0 ;
20357 PyObject * obj1 = 0 ;
20358 char *kwnames[] = {
20359 (char *) "self",(char *) "millisecond", NULL
20360 };
20361
20362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20364 if (SWIG_arg_fail(1)) SWIG_fail;
20365 {
20366 arg2 = (int)(SWIG_As_int(obj1));
20367 if (SWIG_arg_fail(2)) SWIG_fail;
20368 }
20369 {
20370 PyThreadState* __tstate = wxPyBeginAllowThreads();
20371 {
20372 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20373 result = (wxDateTime *) &_result_ref;
20374 }
20375
20376 wxPyEndAllowThreads(__tstate);
20377 if (PyErr_Occurred()) SWIG_fail;
20378 }
20379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20380 return resultobj;
20381 fail:
20382 return NULL;
20383 }
20384
20385
20386 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20387 PyObject *resultobj;
20388 wxDateTime *arg1 = (wxDateTime *) 0 ;
20389 wxDateTime::WeekDay arg2 ;
20390 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20391 wxDateTime *result;
20392 PyObject * obj0 = 0 ;
20393 PyObject * obj1 = 0 ;
20394 PyObject * obj2 = 0 ;
20395 char *kwnames[] = {
20396 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20397 };
20398
20399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20401 if (SWIG_arg_fail(1)) SWIG_fail;
20402 {
20403 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20404 if (SWIG_arg_fail(2)) SWIG_fail;
20405 }
20406 if (obj2) {
20407 {
20408 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20409 if (SWIG_arg_fail(3)) SWIG_fail;
20410 }
20411 }
20412 {
20413 PyThreadState* __tstate = wxPyBeginAllowThreads();
20414 {
20415 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20416 result = (wxDateTime *) &_result_ref;
20417 }
20418
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20423 return resultobj;
20424 fail:
20425 return NULL;
20426 }
20427
20428
20429 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20430 PyObject *resultobj;
20431 wxDateTime *arg1 = (wxDateTime *) 0 ;
20432 wxDateTime::WeekDay arg2 ;
20433 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20434 wxDateTime result;
20435 PyObject * obj0 = 0 ;
20436 PyObject * obj1 = 0 ;
20437 PyObject * obj2 = 0 ;
20438 char *kwnames[] = {
20439 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20440 };
20441
20442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20444 if (SWIG_arg_fail(1)) SWIG_fail;
20445 {
20446 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20447 if (SWIG_arg_fail(2)) SWIG_fail;
20448 }
20449 if (obj2) {
20450 {
20451 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20452 if (SWIG_arg_fail(3)) SWIG_fail;
20453 }
20454 }
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20458
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 wxDateTime * resultptr;
20464 resultptr = new wxDateTime((wxDateTime &)(result));
20465 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20466 }
20467 return resultobj;
20468 fail:
20469 return NULL;
20470 }
20471
20472
20473 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20474 PyObject *resultobj;
20475 wxDateTime *arg1 = (wxDateTime *) 0 ;
20476 wxDateTime::WeekDay arg2 ;
20477 wxDateTime *result;
20478 PyObject * obj0 = 0 ;
20479 PyObject * obj1 = 0 ;
20480 char *kwnames[] = {
20481 (char *) "self",(char *) "weekday", NULL
20482 };
20483
20484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20486 if (SWIG_arg_fail(1)) SWIG_fail;
20487 {
20488 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20489 if (SWIG_arg_fail(2)) SWIG_fail;
20490 }
20491 {
20492 PyThreadState* __tstate = wxPyBeginAllowThreads();
20493 {
20494 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20495 result = (wxDateTime *) &_result_ref;
20496 }
20497
20498 wxPyEndAllowThreads(__tstate);
20499 if (PyErr_Occurred()) SWIG_fail;
20500 }
20501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20502 return resultobj;
20503 fail:
20504 return NULL;
20505 }
20506
20507
20508 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20509 PyObject *resultobj;
20510 wxDateTime *arg1 = (wxDateTime *) 0 ;
20511 wxDateTime::WeekDay arg2 ;
20512 wxDateTime result;
20513 PyObject * obj0 = 0 ;
20514 PyObject * obj1 = 0 ;
20515 char *kwnames[] = {
20516 (char *) "self",(char *) "weekday", NULL
20517 };
20518
20519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20521 if (SWIG_arg_fail(1)) SWIG_fail;
20522 {
20523 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20524 if (SWIG_arg_fail(2)) SWIG_fail;
20525 }
20526 {
20527 PyThreadState* __tstate = wxPyBeginAllowThreads();
20528 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
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_SetToPrevWeekDay(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_SetToPrevWeekDay",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)->SetToPrevWeekDay((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_GetPrevWeekDay(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_GetPrevWeekDay",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)->GetPrevWeekDay((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_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20616 PyObject *resultobj;
20617 wxDateTime *arg1 = (wxDateTime *) 0 ;
20618 wxDateTime::WeekDay arg2 ;
20619 int arg3 = (int) 1 ;
20620 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20621 int arg5 = (int) wxDateTime::Inv_Year ;
20622 bool result;
20623 PyObject * obj0 = 0 ;
20624 PyObject * obj1 = 0 ;
20625 PyObject * obj2 = 0 ;
20626 PyObject * obj3 = 0 ;
20627 PyObject * obj4 = 0 ;
20628 char *kwnames[] = {
20629 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20630 };
20631
20632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20634 if (SWIG_arg_fail(1)) SWIG_fail;
20635 {
20636 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20637 if (SWIG_arg_fail(2)) SWIG_fail;
20638 }
20639 if (obj2) {
20640 {
20641 arg3 = (int)(SWIG_As_int(obj2));
20642 if (SWIG_arg_fail(3)) SWIG_fail;
20643 }
20644 }
20645 if (obj3) {
20646 {
20647 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20648 if (SWIG_arg_fail(4)) SWIG_fail;
20649 }
20650 }
20651 if (obj4) {
20652 {
20653 arg5 = (int)(SWIG_As_int(obj4));
20654 if (SWIG_arg_fail(5)) SWIG_fail;
20655 }
20656 }
20657 {
20658 PyThreadState* __tstate = wxPyBeginAllowThreads();
20659 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20660
20661 wxPyEndAllowThreads(__tstate);
20662 if (PyErr_Occurred()) SWIG_fail;
20663 }
20664 {
20665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20666 }
20667 return resultobj;
20668 fail:
20669 return NULL;
20670 }
20671
20672
20673 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20674 PyObject *resultobj;
20675 wxDateTime *arg1 = (wxDateTime *) 0 ;
20676 wxDateTime::WeekDay arg2 ;
20677 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20678 int arg4 = (int) wxDateTime::Inv_Year ;
20679 bool result;
20680 PyObject * obj0 = 0 ;
20681 PyObject * obj1 = 0 ;
20682 PyObject * obj2 = 0 ;
20683 PyObject * obj3 = 0 ;
20684 char *kwnames[] = {
20685 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20686 };
20687
20688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20690 if (SWIG_arg_fail(1)) SWIG_fail;
20691 {
20692 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20693 if (SWIG_arg_fail(2)) SWIG_fail;
20694 }
20695 if (obj2) {
20696 {
20697 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20698 if (SWIG_arg_fail(3)) SWIG_fail;
20699 }
20700 }
20701 if (obj3) {
20702 {
20703 arg4 = (int)(SWIG_As_int(obj3));
20704 if (SWIG_arg_fail(4)) SWIG_fail;
20705 }
20706 }
20707 {
20708 PyThreadState* __tstate = wxPyBeginAllowThreads();
20709 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20710
20711 wxPyEndAllowThreads(__tstate);
20712 if (PyErr_Occurred()) SWIG_fail;
20713 }
20714 {
20715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20716 }
20717 return resultobj;
20718 fail:
20719 return NULL;
20720 }
20721
20722
20723 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20724 PyObject *resultobj;
20725 wxDateTime *arg1 = (wxDateTime *) 0 ;
20726 wxDateTime::WeekDay arg2 ;
20727 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20728 int arg4 = (int) wxDateTime::Inv_Year ;
20729 wxDateTime result;
20730 PyObject * obj0 = 0 ;
20731 PyObject * obj1 = 0 ;
20732 PyObject * obj2 = 0 ;
20733 PyObject * obj3 = 0 ;
20734 char *kwnames[] = {
20735 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20736 };
20737
20738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20740 if (SWIG_arg_fail(1)) SWIG_fail;
20741 {
20742 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20743 if (SWIG_arg_fail(2)) SWIG_fail;
20744 }
20745 if (obj2) {
20746 {
20747 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20748 if (SWIG_arg_fail(3)) SWIG_fail;
20749 }
20750 }
20751 if (obj3) {
20752 {
20753 arg4 = (int)(SWIG_As_int(obj3));
20754 if (SWIG_arg_fail(4)) SWIG_fail;
20755 }
20756 }
20757 {
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20760
20761 wxPyEndAllowThreads(__tstate);
20762 if (PyErr_Occurred()) SWIG_fail;
20763 }
20764 {
20765 wxDateTime * resultptr;
20766 resultptr = new wxDateTime((wxDateTime &)(result));
20767 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20768 }
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20776 PyObject *resultobj;
20777 wxDateTime *arg1 = (wxDateTime *) 0 ;
20778 int arg2 ;
20779 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20780 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20781 bool result;
20782 PyObject * obj0 = 0 ;
20783 PyObject * obj1 = 0 ;
20784 PyObject * obj2 = 0 ;
20785 PyObject * obj3 = 0 ;
20786 char *kwnames[] = {
20787 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20788 };
20789
20790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 {
20794 arg2 = (int)(SWIG_As_int(obj1));
20795 if (SWIG_arg_fail(2)) SWIG_fail;
20796 }
20797 if (obj2) {
20798 {
20799 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20800 if (SWIG_arg_fail(3)) SWIG_fail;
20801 }
20802 }
20803 if (obj3) {
20804 {
20805 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20806 if (SWIG_arg_fail(4)) SWIG_fail;
20807 }
20808 }
20809 {
20810 PyThreadState* __tstate = wxPyBeginAllowThreads();
20811 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20812
20813 wxPyEndAllowThreads(__tstate);
20814 if (PyErr_Occurred()) SWIG_fail;
20815 }
20816 {
20817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20818 }
20819 return resultobj;
20820 fail:
20821 return NULL;
20822 }
20823
20824
20825 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20826 PyObject *resultobj;
20827 wxDateTime *arg1 = (wxDateTime *) 0 ;
20828 int arg2 ;
20829 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20830 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20831 wxDateTime result;
20832 PyObject * obj0 = 0 ;
20833 PyObject * obj1 = 0 ;
20834 PyObject * obj2 = 0 ;
20835 PyObject * obj3 = 0 ;
20836 char *kwnames[] = {
20837 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20838 };
20839
20840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20842 if (SWIG_arg_fail(1)) SWIG_fail;
20843 {
20844 arg2 = (int)(SWIG_As_int(obj1));
20845 if (SWIG_arg_fail(2)) SWIG_fail;
20846 }
20847 if (obj2) {
20848 {
20849 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20850 if (SWIG_arg_fail(3)) SWIG_fail;
20851 }
20852 }
20853 if (obj3) {
20854 {
20855 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20856 if (SWIG_arg_fail(4)) SWIG_fail;
20857 }
20858 }
20859 {
20860 PyThreadState* __tstate = wxPyBeginAllowThreads();
20861 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20862
20863 wxPyEndAllowThreads(__tstate);
20864 if (PyErr_Occurred()) SWIG_fail;
20865 }
20866 {
20867 wxDateTime * resultptr;
20868 resultptr = new wxDateTime((wxDateTime &)(result));
20869 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20870 }
20871 return resultobj;
20872 fail:
20873 return NULL;
20874 }
20875
20876
20877 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20878 PyObject *resultobj;
20879 int arg1 ;
20880 int arg2 ;
20881 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20882 wxDateTime result;
20883 PyObject * obj0 = 0 ;
20884 PyObject * obj1 = 0 ;
20885 PyObject * obj2 = 0 ;
20886 char *kwnames[] = {
20887 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20888 };
20889
20890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20891 {
20892 arg1 = (int)(SWIG_As_int(obj0));
20893 if (SWIG_arg_fail(1)) SWIG_fail;
20894 }
20895 {
20896 arg2 = (int)(SWIG_As_int(obj1));
20897 if (SWIG_arg_fail(2)) SWIG_fail;
20898 }
20899 if (obj2) {
20900 {
20901 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20902 if (SWIG_arg_fail(3)) SWIG_fail;
20903 }
20904 }
20905 {
20906 PyThreadState* __tstate = wxPyBeginAllowThreads();
20907 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20908
20909 wxPyEndAllowThreads(__tstate);
20910 if (PyErr_Occurred()) SWIG_fail;
20911 }
20912 {
20913 wxDateTime * resultptr;
20914 resultptr = new wxDateTime((wxDateTime &)(result));
20915 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20916 }
20917 return resultobj;
20918 fail:
20919 return NULL;
20920 }
20921
20922
20923 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20924 PyObject *resultobj;
20925 wxDateTime *arg1 = (wxDateTime *) 0 ;
20926 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20927 int arg3 = (int) wxDateTime::Inv_Year ;
20928 wxDateTime *result;
20929 PyObject * obj0 = 0 ;
20930 PyObject * obj1 = 0 ;
20931 PyObject * obj2 = 0 ;
20932 char *kwnames[] = {
20933 (char *) "self",(char *) "month",(char *) "year", NULL
20934 };
20935
20936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20938 if (SWIG_arg_fail(1)) SWIG_fail;
20939 if (obj1) {
20940 {
20941 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20942 if (SWIG_arg_fail(2)) SWIG_fail;
20943 }
20944 }
20945 if (obj2) {
20946 {
20947 arg3 = (int)(SWIG_As_int(obj2));
20948 if (SWIG_arg_fail(3)) SWIG_fail;
20949 }
20950 }
20951 {
20952 PyThreadState* __tstate = wxPyBeginAllowThreads();
20953 {
20954 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20955 result = (wxDateTime *) &_result_ref;
20956 }
20957
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20969 PyObject *resultobj;
20970 wxDateTime *arg1 = (wxDateTime *) 0 ;
20971 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20972 int arg3 = (int) wxDateTime::Inv_Year ;
20973 wxDateTime result;
20974 PyObject * obj0 = 0 ;
20975 PyObject * obj1 = 0 ;
20976 PyObject * obj2 = 0 ;
20977 char *kwnames[] = {
20978 (char *) "self",(char *) "month",(char *) "year", NULL
20979 };
20980
20981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20983 if (SWIG_arg_fail(1)) SWIG_fail;
20984 if (obj1) {
20985 {
20986 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20987 if (SWIG_arg_fail(2)) SWIG_fail;
20988 }
20989 }
20990 if (obj2) {
20991 {
20992 arg3 = (int)(SWIG_As_int(obj2));
20993 if (SWIG_arg_fail(3)) SWIG_fail;
20994 }
20995 }
20996 {
20997 PyThreadState* __tstate = wxPyBeginAllowThreads();
20998 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20999
21000 wxPyEndAllowThreads(__tstate);
21001 if (PyErr_Occurred()) SWIG_fail;
21002 }
21003 {
21004 wxDateTime * resultptr;
21005 resultptr = new wxDateTime((wxDateTime &)(result));
21006 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21007 }
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21015 PyObject *resultobj;
21016 wxDateTime *arg1 = (wxDateTime *) 0 ;
21017 int arg2 ;
21018 wxDateTime *result;
21019 PyObject * obj0 = 0 ;
21020 PyObject * obj1 = 0 ;
21021 char *kwnames[] = {
21022 (char *) "self",(char *) "yday", NULL
21023 };
21024
21025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21027 if (SWIG_arg_fail(1)) SWIG_fail;
21028 {
21029 arg2 = (int)(SWIG_As_int(obj1));
21030 if (SWIG_arg_fail(2)) SWIG_fail;
21031 }
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 {
21035 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21036 result = (wxDateTime *) &_result_ref;
21037 }
21038
21039 wxPyEndAllowThreads(__tstate);
21040 if (PyErr_Occurred()) SWIG_fail;
21041 }
21042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21043 return resultobj;
21044 fail:
21045 return NULL;
21046 }
21047
21048
21049 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21050 PyObject *resultobj;
21051 wxDateTime *arg1 = (wxDateTime *) 0 ;
21052 int arg2 ;
21053 wxDateTime result;
21054 PyObject * obj0 = 0 ;
21055 PyObject * obj1 = 0 ;
21056 char *kwnames[] = {
21057 (char *) "self",(char *) "yday", NULL
21058 };
21059
21060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21062 if (SWIG_arg_fail(1)) SWIG_fail;
21063 {
21064 arg2 = (int)(SWIG_As_int(obj1));
21065 if (SWIG_arg_fail(2)) SWIG_fail;
21066 }
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 result = (arg1)->GetYearDay(arg2);
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_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21086 PyObject *resultobj;
21087 wxDateTime *arg1 = (wxDateTime *) 0 ;
21088 double result;
21089 PyObject * obj0 = 0 ;
21090 char *kwnames[] = {
21091 (char *) "self", NULL
21092 };
21093
21094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21096 if (SWIG_arg_fail(1)) SWIG_fail;
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 result = (double)(arg1)->GetJulianDayNumber();
21100
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 {
21105 resultobj = SWIG_From_double((double)(result));
21106 }
21107 return resultobj;
21108 fail:
21109 return NULL;
21110 }
21111
21112
21113 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21114 PyObject *resultobj;
21115 wxDateTime *arg1 = (wxDateTime *) 0 ;
21116 double result;
21117 PyObject * obj0 = 0 ;
21118 char *kwnames[] = {
21119 (char *) "self", NULL
21120 };
21121
21122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21124 if (SWIG_arg_fail(1)) SWIG_fail;
21125 {
21126 PyThreadState* __tstate = wxPyBeginAllowThreads();
21127 result = (double)(arg1)->GetJDN();
21128
21129 wxPyEndAllowThreads(__tstate);
21130 if (PyErr_Occurred()) SWIG_fail;
21131 }
21132 {
21133 resultobj = SWIG_From_double((double)(result));
21134 }
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21142 PyObject *resultobj;
21143 wxDateTime *arg1 = (wxDateTime *) 0 ;
21144 double result;
21145 PyObject * obj0 = 0 ;
21146 char *kwnames[] = {
21147 (char *) "self", NULL
21148 };
21149
21150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21152 if (SWIG_arg_fail(1)) SWIG_fail;
21153 {
21154 PyThreadState* __tstate = wxPyBeginAllowThreads();
21155 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21156
21157 wxPyEndAllowThreads(__tstate);
21158 if (PyErr_Occurred()) SWIG_fail;
21159 }
21160 {
21161 resultobj = SWIG_From_double((double)(result));
21162 }
21163 return resultobj;
21164 fail:
21165 return NULL;
21166 }
21167
21168
21169 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21170 PyObject *resultobj;
21171 wxDateTime *arg1 = (wxDateTime *) 0 ;
21172 double result;
21173 PyObject * obj0 = 0 ;
21174 char *kwnames[] = {
21175 (char *) "self", NULL
21176 };
21177
21178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21180 if (SWIG_arg_fail(1)) SWIG_fail;
21181 {
21182 PyThreadState* __tstate = wxPyBeginAllowThreads();
21183 result = (double)(arg1)->GetMJD();
21184
21185 wxPyEndAllowThreads(__tstate);
21186 if (PyErr_Occurred()) SWIG_fail;
21187 }
21188 {
21189 resultobj = SWIG_From_double((double)(result));
21190 }
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21198 PyObject *resultobj;
21199 wxDateTime *arg1 = (wxDateTime *) 0 ;
21200 double result;
21201 PyObject * obj0 = 0 ;
21202 char *kwnames[] = {
21203 (char *) "self", NULL
21204 };
21205
21206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21208 if (SWIG_arg_fail(1)) SWIG_fail;
21209 {
21210 PyThreadState* __tstate = wxPyBeginAllowThreads();
21211 result = (double)(arg1)->GetRataDie();
21212
21213 wxPyEndAllowThreads(__tstate);
21214 if (PyErr_Occurred()) SWIG_fail;
21215 }
21216 {
21217 resultobj = SWIG_From_double((double)(result));
21218 }
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21226 PyObject *resultobj;
21227 wxDateTime *arg1 = (wxDateTime *) 0 ;
21228 wxDateTime::TimeZone *arg2 = 0 ;
21229 bool arg3 = (bool) false ;
21230 wxDateTime result;
21231 bool temp2 = false ;
21232 PyObject * obj0 = 0 ;
21233 PyObject * obj1 = 0 ;
21234 PyObject * obj2 = 0 ;
21235 char *kwnames[] = {
21236 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21237 };
21238
21239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21241 if (SWIG_arg_fail(1)) SWIG_fail;
21242 {
21243 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21244 temp2 = true;
21245 }
21246 if (obj2) {
21247 {
21248 arg3 = (bool)(SWIG_As_bool(obj2));
21249 if (SWIG_arg_fail(3)) SWIG_fail;
21250 }
21251 }
21252 {
21253 PyThreadState* __tstate = wxPyBeginAllowThreads();
21254 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21255
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 {
21260 wxDateTime * resultptr;
21261 resultptr = new wxDateTime((wxDateTime &)(result));
21262 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21263 }
21264 {
21265 if (temp2) delete arg2;
21266 }
21267 return resultobj;
21268 fail:
21269 {
21270 if (temp2) delete arg2;
21271 }
21272 return NULL;
21273 }
21274
21275
21276 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21277 PyObject *resultobj;
21278 wxDateTime *arg1 = (wxDateTime *) 0 ;
21279 wxDateTime::TimeZone *arg2 = 0 ;
21280 bool arg3 = (bool) false ;
21281 wxDateTime *result;
21282 bool temp2 = false ;
21283 PyObject * obj0 = 0 ;
21284 PyObject * obj1 = 0 ;
21285 PyObject * obj2 = 0 ;
21286 char *kwnames[] = {
21287 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21288 };
21289
21290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21292 if (SWIG_arg_fail(1)) SWIG_fail;
21293 {
21294 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21295 temp2 = true;
21296 }
21297 if (obj2) {
21298 {
21299 arg3 = (bool)(SWIG_As_bool(obj2));
21300 if (SWIG_arg_fail(3)) SWIG_fail;
21301 }
21302 }
21303 {
21304 PyThreadState* __tstate = wxPyBeginAllowThreads();
21305 {
21306 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21307 result = (wxDateTime *) &_result_ref;
21308 }
21309
21310 wxPyEndAllowThreads(__tstate);
21311 if (PyErr_Occurred()) SWIG_fail;
21312 }
21313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21314 {
21315 if (temp2) delete arg2;
21316 }
21317 return resultobj;
21318 fail:
21319 {
21320 if (temp2) delete arg2;
21321 }
21322 return NULL;
21323 }
21324
21325
21326 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21327 PyObject *resultobj;
21328 wxDateTime *arg1 = (wxDateTime *) 0 ;
21329 bool arg2 = (bool) false ;
21330 wxDateTime result;
21331 PyObject * obj0 = 0 ;
21332 PyObject * obj1 = 0 ;
21333 char *kwnames[] = {
21334 (char *) "self",(char *) "noDST", NULL
21335 };
21336
21337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21339 if (SWIG_arg_fail(1)) SWIG_fail;
21340 if (obj1) {
21341 {
21342 arg2 = (bool)(SWIG_As_bool(obj1));
21343 if (SWIG_arg_fail(2)) SWIG_fail;
21344 }
21345 }
21346 {
21347 PyThreadState* __tstate = wxPyBeginAllowThreads();
21348 result = (arg1)->ToGMT(arg2);
21349
21350 wxPyEndAllowThreads(__tstate);
21351 if (PyErr_Occurred()) SWIG_fail;
21352 }
21353 {
21354 wxDateTime * resultptr;
21355 resultptr = new wxDateTime((wxDateTime &)(result));
21356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21357 }
21358 return resultobj;
21359 fail:
21360 return NULL;
21361 }
21362
21363
21364 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21365 PyObject *resultobj;
21366 wxDateTime *arg1 = (wxDateTime *) 0 ;
21367 bool arg2 = (bool) false ;
21368 wxDateTime *result;
21369 PyObject * obj0 = 0 ;
21370 PyObject * obj1 = 0 ;
21371 char *kwnames[] = {
21372 (char *) "self",(char *) "noDST", NULL
21373 };
21374
21375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21377 if (SWIG_arg_fail(1)) SWIG_fail;
21378 if (obj1) {
21379 {
21380 arg2 = (bool)(SWIG_As_bool(obj1));
21381 if (SWIG_arg_fail(2)) SWIG_fail;
21382 }
21383 }
21384 {
21385 PyThreadState* __tstate = wxPyBeginAllowThreads();
21386 {
21387 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21388 result = (wxDateTime *) &_result_ref;
21389 }
21390
21391 wxPyEndAllowThreads(__tstate);
21392 if (PyErr_Occurred()) SWIG_fail;
21393 }
21394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21395 return resultobj;
21396 fail:
21397 return NULL;
21398 }
21399
21400
21401 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21402 PyObject *resultobj;
21403 wxDateTime *arg1 = (wxDateTime *) 0 ;
21404 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21405 int result;
21406 PyObject * obj0 = 0 ;
21407 PyObject * obj1 = 0 ;
21408 char *kwnames[] = {
21409 (char *) "self",(char *) "country", NULL
21410 };
21411
21412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21414 if (SWIG_arg_fail(1)) SWIG_fail;
21415 if (obj1) {
21416 {
21417 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21418 if (SWIG_arg_fail(2)) SWIG_fail;
21419 }
21420 }
21421 {
21422 PyThreadState* __tstate = wxPyBeginAllowThreads();
21423 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21424
21425 wxPyEndAllowThreads(__tstate);
21426 if (PyErr_Occurred()) SWIG_fail;
21427 }
21428 {
21429 resultobj = SWIG_From_int((int)(result));
21430 }
21431 return resultobj;
21432 fail:
21433 return NULL;
21434 }
21435
21436
21437 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21438 PyObject *resultobj;
21439 wxDateTime *arg1 = (wxDateTime *) 0 ;
21440 bool result;
21441 PyObject * obj0 = 0 ;
21442 char *kwnames[] = {
21443 (char *) "self", NULL
21444 };
21445
21446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) 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 {
21450 PyThreadState* __tstate = wxPyBeginAllowThreads();
21451 result = (bool)((wxDateTime const *)arg1)->IsValid();
21452
21453 wxPyEndAllowThreads(__tstate);
21454 if (PyErr_Occurred()) SWIG_fail;
21455 }
21456 {
21457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21458 }
21459 return resultobj;
21460 fail:
21461 return NULL;
21462 }
21463
21464
21465 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21466 PyObject *resultobj;
21467 wxDateTime *arg1 = (wxDateTime *) 0 ;
21468 time_t result;
21469 PyObject * obj0 = 0 ;
21470 char *kwnames[] = {
21471 (char *) "self", NULL
21472 };
21473
21474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21476 if (SWIG_arg_fail(1)) SWIG_fail;
21477 {
21478 PyThreadState* __tstate = wxPyBeginAllowThreads();
21479 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21480
21481 wxPyEndAllowThreads(__tstate);
21482 if (PyErr_Occurred()) SWIG_fail;
21483 }
21484 {
21485 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21486 }
21487 return resultobj;
21488 fail:
21489 return NULL;
21490 }
21491
21492
21493 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21494 PyObject *resultobj;
21495 wxDateTime *arg1 = (wxDateTime *) 0 ;
21496 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21497 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21498 int result;
21499 bool temp2 = false ;
21500 PyObject * obj0 = 0 ;
21501 PyObject * obj1 = 0 ;
21502 char *kwnames[] = {
21503 (char *) "self",(char *) "tz", NULL
21504 };
21505
21506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21508 if (SWIG_arg_fail(1)) SWIG_fail;
21509 if (obj1) {
21510 {
21511 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21512 temp2 = true;
21513 }
21514 }
21515 {
21516 PyThreadState* __tstate = wxPyBeginAllowThreads();
21517 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21518
21519 wxPyEndAllowThreads(__tstate);
21520 if (PyErr_Occurred()) SWIG_fail;
21521 }
21522 {
21523 resultobj = SWIG_From_int((int)(result));
21524 }
21525 {
21526 if (temp2) delete arg2;
21527 }
21528 return resultobj;
21529 fail:
21530 {
21531 if (temp2) delete arg2;
21532 }
21533 return NULL;
21534 }
21535
21536
21537 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21538 PyObject *resultobj;
21539 wxDateTime *arg1 = (wxDateTime *) 0 ;
21540 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21541 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21542 wxDateTime::Month result;
21543 bool temp2 = false ;
21544 PyObject * obj0 = 0 ;
21545 PyObject * obj1 = 0 ;
21546 char *kwnames[] = {
21547 (char *) "self",(char *) "tz", NULL
21548 };
21549
21550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21552 if (SWIG_arg_fail(1)) SWIG_fail;
21553 if (obj1) {
21554 {
21555 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21556 temp2 = true;
21557 }
21558 }
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21562
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 resultobj = SWIG_From_int((result));
21567 {
21568 if (temp2) delete arg2;
21569 }
21570 return resultobj;
21571 fail:
21572 {
21573 if (temp2) delete arg2;
21574 }
21575 return NULL;
21576 }
21577
21578
21579 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21580 PyObject *resultobj;
21581 wxDateTime *arg1 = (wxDateTime *) 0 ;
21582 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21583 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21584 int result;
21585 bool temp2 = false ;
21586 PyObject * obj0 = 0 ;
21587 PyObject * obj1 = 0 ;
21588 char *kwnames[] = {
21589 (char *) "self",(char *) "tz", NULL
21590 };
21591
21592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21594 if (SWIG_arg_fail(1)) SWIG_fail;
21595 if (obj1) {
21596 {
21597 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21598 temp2 = true;
21599 }
21600 }
21601 {
21602 PyThreadState* __tstate = wxPyBeginAllowThreads();
21603 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21604
21605 wxPyEndAllowThreads(__tstate);
21606 if (PyErr_Occurred()) SWIG_fail;
21607 }
21608 {
21609 resultobj = SWIG_From_int((int)(result));
21610 }
21611 {
21612 if (temp2) delete arg2;
21613 }
21614 return resultobj;
21615 fail:
21616 {
21617 if (temp2) delete arg2;
21618 }
21619 return NULL;
21620 }
21621
21622
21623 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21624 PyObject *resultobj;
21625 wxDateTime *arg1 = (wxDateTime *) 0 ;
21626 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21627 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21628 wxDateTime::WeekDay result;
21629 bool temp2 = false ;
21630 PyObject * obj0 = 0 ;
21631 PyObject * obj1 = 0 ;
21632 char *kwnames[] = {
21633 (char *) "self",(char *) "tz", NULL
21634 };
21635
21636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21638 if (SWIG_arg_fail(1)) SWIG_fail;
21639 if (obj1) {
21640 {
21641 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21642 temp2 = true;
21643 }
21644 }
21645 {
21646 PyThreadState* __tstate = wxPyBeginAllowThreads();
21647 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21648
21649 wxPyEndAllowThreads(__tstate);
21650 if (PyErr_Occurred()) SWIG_fail;
21651 }
21652 resultobj = SWIG_From_int((result));
21653 {
21654 if (temp2) delete arg2;
21655 }
21656 return resultobj;
21657 fail:
21658 {
21659 if (temp2) delete arg2;
21660 }
21661 return NULL;
21662 }
21663
21664
21665 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21666 PyObject *resultobj;
21667 wxDateTime *arg1 = (wxDateTime *) 0 ;
21668 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21669 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21670 int result;
21671 bool temp2 = false ;
21672 PyObject * obj0 = 0 ;
21673 PyObject * obj1 = 0 ;
21674 char *kwnames[] = {
21675 (char *) "self",(char *) "tz", NULL
21676 };
21677
21678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21680 if (SWIG_arg_fail(1)) SWIG_fail;
21681 if (obj1) {
21682 {
21683 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21684 temp2 = true;
21685 }
21686 }
21687 {
21688 PyThreadState* __tstate = wxPyBeginAllowThreads();
21689 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21690
21691 wxPyEndAllowThreads(__tstate);
21692 if (PyErr_Occurred()) SWIG_fail;
21693 }
21694 {
21695 resultobj = SWIG_From_int((int)(result));
21696 }
21697 {
21698 if (temp2) delete arg2;
21699 }
21700 return resultobj;
21701 fail:
21702 {
21703 if (temp2) delete arg2;
21704 }
21705 return NULL;
21706 }
21707
21708
21709 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21710 PyObject *resultobj;
21711 wxDateTime *arg1 = (wxDateTime *) 0 ;
21712 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21713 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21714 int result;
21715 bool temp2 = false ;
21716 PyObject * obj0 = 0 ;
21717 PyObject * obj1 = 0 ;
21718 char *kwnames[] = {
21719 (char *) "self",(char *) "tz", NULL
21720 };
21721
21722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21724 if (SWIG_arg_fail(1)) SWIG_fail;
21725 if (obj1) {
21726 {
21727 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21728 temp2 = true;
21729 }
21730 }
21731 {
21732 PyThreadState* __tstate = wxPyBeginAllowThreads();
21733 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21734
21735 wxPyEndAllowThreads(__tstate);
21736 if (PyErr_Occurred()) SWIG_fail;
21737 }
21738 {
21739 resultobj = SWIG_From_int((int)(result));
21740 }
21741 {
21742 if (temp2) delete arg2;
21743 }
21744 return resultobj;
21745 fail:
21746 {
21747 if (temp2) delete arg2;
21748 }
21749 return NULL;
21750 }
21751
21752
21753 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21754 PyObject *resultobj;
21755 wxDateTime *arg1 = (wxDateTime *) 0 ;
21756 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21757 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21758 int result;
21759 bool temp2 = false ;
21760 PyObject * obj0 = 0 ;
21761 PyObject * obj1 = 0 ;
21762 char *kwnames[] = {
21763 (char *) "self",(char *) "tz", NULL
21764 };
21765
21766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21768 if (SWIG_arg_fail(1)) SWIG_fail;
21769 if (obj1) {
21770 {
21771 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21772 temp2 = true;
21773 }
21774 }
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21778
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 {
21783 resultobj = SWIG_From_int((int)(result));
21784 }
21785 {
21786 if (temp2) delete arg2;
21787 }
21788 return resultobj;
21789 fail:
21790 {
21791 if (temp2) delete arg2;
21792 }
21793 return NULL;
21794 }
21795
21796
21797 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21798 PyObject *resultobj;
21799 wxDateTime *arg1 = (wxDateTime *) 0 ;
21800 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21801 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21802 int result;
21803 bool temp2 = false ;
21804 PyObject * obj0 = 0 ;
21805 PyObject * obj1 = 0 ;
21806 char *kwnames[] = {
21807 (char *) "self",(char *) "tz", NULL
21808 };
21809
21810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21812 if (SWIG_arg_fail(1)) SWIG_fail;
21813 if (obj1) {
21814 {
21815 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21816 temp2 = true;
21817 }
21818 }
21819 {
21820 PyThreadState* __tstate = wxPyBeginAllowThreads();
21821 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21822
21823 wxPyEndAllowThreads(__tstate);
21824 if (PyErr_Occurred()) SWIG_fail;
21825 }
21826 {
21827 resultobj = SWIG_From_int((int)(result));
21828 }
21829 {
21830 if (temp2) delete arg2;
21831 }
21832 return resultobj;
21833 fail:
21834 {
21835 if (temp2) delete arg2;
21836 }
21837 return NULL;
21838 }
21839
21840
21841 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21842 PyObject *resultobj;
21843 wxDateTime *arg1 = (wxDateTime *) 0 ;
21844 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21845 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21846 int result;
21847 bool temp2 = false ;
21848 PyObject * obj0 = 0 ;
21849 PyObject * obj1 = 0 ;
21850 char *kwnames[] = {
21851 (char *) "self",(char *) "tz", NULL
21852 };
21853
21854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21856 if (SWIG_arg_fail(1)) SWIG_fail;
21857 if (obj1) {
21858 {
21859 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21860 temp2 = true;
21861 }
21862 }
21863 {
21864 PyThreadState* __tstate = wxPyBeginAllowThreads();
21865 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21866
21867 wxPyEndAllowThreads(__tstate);
21868 if (PyErr_Occurred()) SWIG_fail;
21869 }
21870 {
21871 resultobj = SWIG_From_int((int)(result));
21872 }
21873 {
21874 if (temp2) delete arg2;
21875 }
21876 return resultobj;
21877 fail:
21878 {
21879 if (temp2) delete arg2;
21880 }
21881 return NULL;
21882 }
21883
21884
21885 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj;
21887 wxDateTime *arg1 = (wxDateTime *) 0 ;
21888 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21889 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21890 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21891 int result;
21892 bool temp3 = false ;
21893 PyObject * obj0 = 0 ;
21894 PyObject * obj1 = 0 ;
21895 PyObject * obj2 = 0 ;
21896 char *kwnames[] = {
21897 (char *) "self",(char *) "flags",(char *) "tz", NULL
21898 };
21899
21900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21902 if (SWIG_arg_fail(1)) SWIG_fail;
21903 if (obj1) {
21904 {
21905 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21906 if (SWIG_arg_fail(2)) SWIG_fail;
21907 }
21908 }
21909 if (obj2) {
21910 {
21911 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21912 temp3 = true;
21913 }
21914 }
21915 {
21916 PyThreadState* __tstate = wxPyBeginAllowThreads();
21917 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21918
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 {
21923 resultobj = SWIG_From_int((int)(result));
21924 }
21925 {
21926 if (temp3) delete arg3;
21927 }
21928 return resultobj;
21929 fail:
21930 {
21931 if (temp3) delete arg3;
21932 }
21933 return NULL;
21934 }
21935
21936
21937 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21938 PyObject *resultobj;
21939 wxDateTime *arg1 = (wxDateTime *) 0 ;
21940 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21941 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21942 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21943 int result;
21944 bool temp3 = false ;
21945 PyObject * obj0 = 0 ;
21946 PyObject * obj1 = 0 ;
21947 PyObject * obj2 = 0 ;
21948 char *kwnames[] = {
21949 (char *) "self",(char *) "flags",(char *) "tz", NULL
21950 };
21951
21952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21954 if (SWIG_arg_fail(1)) SWIG_fail;
21955 if (obj1) {
21956 {
21957 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21958 if (SWIG_arg_fail(2)) SWIG_fail;
21959 }
21960 }
21961 if (obj2) {
21962 {
21963 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21964 temp3 = true;
21965 }
21966 }
21967 {
21968 PyThreadState* __tstate = wxPyBeginAllowThreads();
21969 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21970
21971 wxPyEndAllowThreads(__tstate);
21972 if (PyErr_Occurred()) SWIG_fail;
21973 }
21974 {
21975 resultobj = SWIG_From_int((int)(result));
21976 }
21977 {
21978 if (temp3) delete arg3;
21979 }
21980 return resultobj;
21981 fail:
21982 {
21983 if (temp3) delete arg3;
21984 }
21985 return NULL;
21986 }
21987
21988
21989 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21990 PyObject *resultobj;
21991 wxDateTime *arg1 = (wxDateTime *) 0 ;
21992 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21993 bool result;
21994 PyObject * obj0 = 0 ;
21995 PyObject * obj1 = 0 ;
21996 char *kwnames[] = {
21997 (char *) "self",(char *) "country", NULL
21998 };
21999
22000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22002 if (SWIG_arg_fail(1)) SWIG_fail;
22003 if (obj1) {
22004 {
22005 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22006 if (SWIG_arg_fail(2)) SWIG_fail;
22007 }
22008 }
22009 {
22010 PyThreadState* __tstate = wxPyBeginAllowThreads();
22011 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22012
22013 wxPyEndAllowThreads(__tstate);
22014 if (PyErr_Occurred()) SWIG_fail;
22015 }
22016 {
22017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22018 }
22019 return resultobj;
22020 fail:
22021 return NULL;
22022 }
22023
22024
22025 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22026 PyObject *resultobj;
22027 wxDateTime *arg1 = (wxDateTime *) 0 ;
22028 wxDateTime *arg2 = 0 ;
22029 bool result;
22030 PyObject * obj0 = 0 ;
22031 PyObject * obj1 = 0 ;
22032 char *kwnames[] = {
22033 (char *) "self",(char *) "datetime", NULL
22034 };
22035
22036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22038 if (SWIG_arg_fail(1)) SWIG_fail;
22039 {
22040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22041 if (SWIG_arg_fail(2)) SWIG_fail;
22042 if (arg2 == NULL) {
22043 SWIG_null_ref("wxDateTime");
22044 }
22045 if (SWIG_arg_fail(2)) SWIG_fail;
22046 }
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22050
22051 wxPyEndAllowThreads(__tstate);
22052 if (PyErr_Occurred()) SWIG_fail;
22053 }
22054 {
22055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22056 }
22057 return resultobj;
22058 fail:
22059 return NULL;
22060 }
22061
22062
22063 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22064 PyObject *resultobj;
22065 wxDateTime *arg1 = (wxDateTime *) 0 ;
22066 wxDateTime *arg2 = 0 ;
22067 bool result;
22068 PyObject * obj0 = 0 ;
22069 PyObject * obj1 = 0 ;
22070 char *kwnames[] = {
22071 (char *) "self",(char *) "datetime", NULL
22072 };
22073
22074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22076 if (SWIG_arg_fail(1)) SWIG_fail;
22077 {
22078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22079 if (SWIG_arg_fail(2)) SWIG_fail;
22080 if (arg2 == NULL) {
22081 SWIG_null_ref("wxDateTime");
22082 }
22083 if (SWIG_arg_fail(2)) SWIG_fail;
22084 }
22085 {
22086 PyThreadState* __tstate = wxPyBeginAllowThreads();
22087 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22088
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 {
22093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22094 }
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22102 PyObject *resultobj;
22103 wxDateTime *arg1 = (wxDateTime *) 0 ;
22104 wxDateTime *arg2 = 0 ;
22105 bool result;
22106 PyObject * obj0 = 0 ;
22107 PyObject * obj1 = 0 ;
22108 char *kwnames[] = {
22109 (char *) "self",(char *) "datetime", NULL
22110 };
22111
22112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22114 if (SWIG_arg_fail(1)) SWIG_fail;
22115 {
22116 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22117 if (SWIG_arg_fail(2)) SWIG_fail;
22118 if (arg2 == NULL) {
22119 SWIG_null_ref("wxDateTime");
22120 }
22121 if (SWIG_arg_fail(2)) SWIG_fail;
22122 }
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22126
22127 wxPyEndAllowThreads(__tstate);
22128 if (PyErr_Occurred()) SWIG_fail;
22129 }
22130 {
22131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22132 }
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj;
22141 wxDateTime *arg1 = (wxDateTime *) 0 ;
22142 wxDateTime *arg2 = 0 ;
22143 wxDateTime *arg3 = 0 ;
22144 bool result;
22145 PyObject * obj0 = 0 ;
22146 PyObject * obj1 = 0 ;
22147 PyObject * obj2 = 0 ;
22148 char *kwnames[] = {
22149 (char *) "self",(char *) "t1",(char *) "t2", NULL
22150 };
22151
22152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22154 if (SWIG_arg_fail(1)) SWIG_fail;
22155 {
22156 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22157 if (SWIG_arg_fail(2)) SWIG_fail;
22158 if (arg2 == NULL) {
22159 SWIG_null_ref("wxDateTime");
22160 }
22161 if (SWIG_arg_fail(2)) SWIG_fail;
22162 }
22163 {
22164 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22165 if (SWIG_arg_fail(3)) SWIG_fail;
22166 if (arg3 == NULL) {
22167 SWIG_null_ref("wxDateTime");
22168 }
22169 if (SWIG_arg_fail(3)) SWIG_fail;
22170 }
22171 {
22172 PyThreadState* __tstate = wxPyBeginAllowThreads();
22173 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22174
22175 wxPyEndAllowThreads(__tstate);
22176 if (PyErr_Occurred()) SWIG_fail;
22177 }
22178 {
22179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22180 }
22181 return resultobj;
22182 fail:
22183 return NULL;
22184 }
22185
22186
22187 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22188 PyObject *resultobj;
22189 wxDateTime *arg1 = (wxDateTime *) 0 ;
22190 wxDateTime *arg2 = 0 ;
22191 wxDateTime *arg3 = 0 ;
22192 bool result;
22193 PyObject * obj0 = 0 ;
22194 PyObject * obj1 = 0 ;
22195 PyObject * obj2 = 0 ;
22196 char *kwnames[] = {
22197 (char *) "self",(char *) "t1",(char *) "t2", NULL
22198 };
22199
22200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22202 if (SWIG_arg_fail(1)) SWIG_fail;
22203 {
22204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22205 if (SWIG_arg_fail(2)) SWIG_fail;
22206 if (arg2 == NULL) {
22207 SWIG_null_ref("wxDateTime");
22208 }
22209 if (SWIG_arg_fail(2)) SWIG_fail;
22210 }
22211 {
22212 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22213 if (SWIG_arg_fail(3)) SWIG_fail;
22214 if (arg3 == NULL) {
22215 SWIG_null_ref("wxDateTime");
22216 }
22217 if (SWIG_arg_fail(3)) SWIG_fail;
22218 }
22219 {
22220 PyThreadState* __tstate = wxPyBeginAllowThreads();
22221 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22222
22223 wxPyEndAllowThreads(__tstate);
22224 if (PyErr_Occurred()) SWIG_fail;
22225 }
22226 {
22227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22228 }
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22236 PyObject *resultobj;
22237 wxDateTime *arg1 = (wxDateTime *) 0 ;
22238 wxDateTime *arg2 = 0 ;
22239 bool result;
22240 PyObject * obj0 = 0 ;
22241 PyObject * obj1 = 0 ;
22242 char *kwnames[] = {
22243 (char *) "self",(char *) "dt", NULL
22244 };
22245
22246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22248 if (SWIG_arg_fail(1)) SWIG_fail;
22249 {
22250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22251 if (SWIG_arg_fail(2)) SWIG_fail;
22252 if (arg2 == NULL) {
22253 SWIG_null_ref("wxDateTime");
22254 }
22255 if (SWIG_arg_fail(2)) SWIG_fail;
22256 }
22257 {
22258 PyThreadState* __tstate = wxPyBeginAllowThreads();
22259 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22260
22261 wxPyEndAllowThreads(__tstate);
22262 if (PyErr_Occurred()) SWIG_fail;
22263 }
22264 {
22265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22266 }
22267 return resultobj;
22268 fail:
22269 return NULL;
22270 }
22271
22272
22273 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22274 PyObject *resultobj;
22275 wxDateTime *arg1 = (wxDateTime *) 0 ;
22276 wxDateTime *arg2 = 0 ;
22277 bool result;
22278 PyObject * obj0 = 0 ;
22279 PyObject * obj1 = 0 ;
22280 char *kwnames[] = {
22281 (char *) "self",(char *) "dt", NULL
22282 };
22283
22284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22286 if (SWIG_arg_fail(1)) SWIG_fail;
22287 {
22288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22289 if (SWIG_arg_fail(2)) SWIG_fail;
22290 if (arg2 == NULL) {
22291 SWIG_null_ref("wxDateTime");
22292 }
22293 if (SWIG_arg_fail(2)) SWIG_fail;
22294 }
22295 {
22296 PyThreadState* __tstate = wxPyBeginAllowThreads();
22297 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22298
22299 wxPyEndAllowThreads(__tstate);
22300 if (PyErr_Occurred()) SWIG_fail;
22301 }
22302 {
22303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22304 }
22305 return resultobj;
22306 fail:
22307 return NULL;
22308 }
22309
22310
22311 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22312 PyObject *resultobj;
22313 wxDateTime *arg1 = (wxDateTime *) 0 ;
22314 wxDateTime *arg2 = 0 ;
22315 wxTimeSpan *arg3 = 0 ;
22316 bool result;
22317 PyObject * obj0 = 0 ;
22318 PyObject * obj1 = 0 ;
22319 PyObject * obj2 = 0 ;
22320 char *kwnames[] = {
22321 (char *) "self",(char *) "dt",(char *) "ts", NULL
22322 };
22323
22324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22326 if (SWIG_arg_fail(1)) SWIG_fail;
22327 {
22328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22329 if (SWIG_arg_fail(2)) SWIG_fail;
22330 if (arg2 == NULL) {
22331 SWIG_null_ref("wxDateTime");
22332 }
22333 if (SWIG_arg_fail(2)) SWIG_fail;
22334 }
22335 {
22336 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22337 if (SWIG_arg_fail(3)) SWIG_fail;
22338 if (arg3 == NULL) {
22339 SWIG_null_ref("wxTimeSpan");
22340 }
22341 if (SWIG_arg_fail(3)) SWIG_fail;
22342 }
22343 {
22344 PyThreadState* __tstate = wxPyBeginAllowThreads();
22345 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22346
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 {
22351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22352 }
22353 return resultobj;
22354 fail:
22355 return NULL;
22356 }
22357
22358
22359 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22360 PyObject *resultobj;
22361 wxDateTime *arg1 = (wxDateTime *) 0 ;
22362 wxTimeSpan *arg2 = 0 ;
22363 wxDateTime *result;
22364 PyObject * obj0 = 0 ;
22365 PyObject * obj1 = 0 ;
22366 char *kwnames[] = {
22367 (char *) "self",(char *) "diff", NULL
22368 };
22369
22370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22372 if (SWIG_arg_fail(1)) SWIG_fail;
22373 {
22374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22375 if (SWIG_arg_fail(2)) SWIG_fail;
22376 if (arg2 == NULL) {
22377 SWIG_null_ref("wxTimeSpan");
22378 }
22379 if (SWIG_arg_fail(2)) SWIG_fail;
22380 }
22381 {
22382 PyThreadState* __tstate = wxPyBeginAllowThreads();
22383 {
22384 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22385 result = (wxDateTime *) &_result_ref;
22386 }
22387
22388 wxPyEndAllowThreads(__tstate);
22389 if (PyErr_Occurred()) SWIG_fail;
22390 }
22391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22392 return resultobj;
22393 fail:
22394 return NULL;
22395 }
22396
22397
22398 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22399 PyObject *resultobj;
22400 wxDateTime *arg1 = (wxDateTime *) 0 ;
22401 wxDateSpan *arg2 = 0 ;
22402 wxDateTime *result;
22403 PyObject * obj0 = 0 ;
22404 PyObject * obj1 = 0 ;
22405 char *kwnames[] = {
22406 (char *) "self",(char *) "diff", NULL
22407 };
22408
22409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22411 if (SWIG_arg_fail(1)) SWIG_fail;
22412 {
22413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22414 if (SWIG_arg_fail(2)) SWIG_fail;
22415 if (arg2 == NULL) {
22416 SWIG_null_ref("wxDateSpan");
22417 }
22418 if (SWIG_arg_fail(2)) SWIG_fail;
22419 }
22420 {
22421 PyThreadState* __tstate = wxPyBeginAllowThreads();
22422 {
22423 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22424 result = (wxDateTime *) &_result_ref;
22425 }
22426
22427 wxPyEndAllowThreads(__tstate);
22428 if (PyErr_Occurred()) SWIG_fail;
22429 }
22430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22431 return resultobj;
22432 fail:
22433 return NULL;
22434 }
22435
22436
22437 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22438 PyObject *resultobj;
22439 wxDateTime *arg1 = (wxDateTime *) 0 ;
22440 wxTimeSpan *arg2 = 0 ;
22441 wxDateTime *result;
22442 PyObject * obj0 = 0 ;
22443 PyObject * obj1 = 0 ;
22444 char *kwnames[] = {
22445 (char *) "self",(char *) "diff", NULL
22446 };
22447
22448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22450 if (SWIG_arg_fail(1)) SWIG_fail;
22451 {
22452 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22453 if (SWIG_arg_fail(2)) SWIG_fail;
22454 if (arg2 == NULL) {
22455 SWIG_null_ref("wxTimeSpan");
22456 }
22457 if (SWIG_arg_fail(2)) SWIG_fail;
22458 }
22459 {
22460 PyThreadState* __tstate = wxPyBeginAllowThreads();
22461 {
22462 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22463 result = (wxDateTime *) &_result_ref;
22464 }
22465
22466 wxPyEndAllowThreads(__tstate);
22467 if (PyErr_Occurred()) SWIG_fail;
22468 }
22469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22470 return resultobj;
22471 fail:
22472 return NULL;
22473 }
22474
22475
22476 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22477 PyObject *resultobj;
22478 wxDateTime *arg1 = (wxDateTime *) 0 ;
22479 wxDateSpan *arg2 = 0 ;
22480 wxDateTime *result;
22481 PyObject * obj0 = 0 ;
22482 PyObject * obj1 = 0 ;
22483 char *kwnames[] = {
22484 (char *) "self",(char *) "diff", NULL
22485 };
22486
22487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22489 if (SWIG_arg_fail(1)) SWIG_fail;
22490 {
22491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22492 if (SWIG_arg_fail(2)) SWIG_fail;
22493 if (arg2 == NULL) {
22494 SWIG_null_ref("wxDateSpan");
22495 }
22496 if (SWIG_arg_fail(2)) SWIG_fail;
22497 }
22498 {
22499 PyThreadState* __tstate = wxPyBeginAllowThreads();
22500 {
22501 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22502 result = (wxDateTime *) &_result_ref;
22503 }
22504
22505 wxPyEndAllowThreads(__tstate);
22506 if (PyErr_Occurred()) SWIG_fail;
22507 }
22508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22509 return resultobj;
22510 fail:
22511 return NULL;
22512 }
22513
22514
22515 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22516 PyObject *resultobj;
22517 wxDateTime *arg1 = (wxDateTime *) 0 ;
22518 wxDateTime *arg2 = 0 ;
22519 wxTimeSpan result;
22520 PyObject * obj0 = 0 ;
22521 PyObject * obj1 = 0 ;
22522 char *kwnames[] = {
22523 (char *) "self",(char *) "dt", NULL
22524 };
22525
22526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22528 if (SWIG_arg_fail(1)) SWIG_fail;
22529 {
22530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22531 if (SWIG_arg_fail(2)) SWIG_fail;
22532 if (arg2 == NULL) {
22533 SWIG_null_ref("wxDateTime");
22534 }
22535 if (SWIG_arg_fail(2)) SWIG_fail;
22536 }
22537 {
22538 PyThreadState* __tstate = wxPyBeginAllowThreads();
22539 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22540
22541 wxPyEndAllowThreads(__tstate);
22542 if (PyErr_Occurred()) SWIG_fail;
22543 }
22544 {
22545 wxTimeSpan * resultptr;
22546 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22548 }
22549 return resultobj;
22550 fail:
22551 return NULL;
22552 }
22553
22554
22555 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22556 PyObject *resultobj;
22557 wxDateTime *arg1 = (wxDateTime *) 0 ;
22558 wxTimeSpan *arg2 = 0 ;
22559 wxDateTime *result;
22560 PyObject * obj0 = 0 ;
22561 PyObject * obj1 = 0 ;
22562
22563 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22565 if (SWIG_arg_fail(1)) SWIG_fail;
22566 {
22567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22568 if (SWIG_arg_fail(2)) SWIG_fail;
22569 if (arg2 == NULL) {
22570 SWIG_null_ref("wxTimeSpan");
22571 }
22572 if (SWIG_arg_fail(2)) SWIG_fail;
22573 }
22574 {
22575 PyThreadState* __tstate = wxPyBeginAllowThreads();
22576 {
22577 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22578 result = (wxDateTime *) &_result_ref;
22579 }
22580
22581 wxPyEndAllowThreads(__tstate);
22582 if (PyErr_Occurred()) SWIG_fail;
22583 }
22584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22585 return resultobj;
22586 fail:
22587 return NULL;
22588 }
22589
22590
22591 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22592 PyObject *resultobj;
22593 wxDateTime *arg1 = (wxDateTime *) 0 ;
22594 wxDateSpan *arg2 = 0 ;
22595 wxDateTime *result;
22596 PyObject * obj0 = 0 ;
22597 PyObject * obj1 = 0 ;
22598
22599 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22601 if (SWIG_arg_fail(1)) SWIG_fail;
22602 {
22603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22604 if (SWIG_arg_fail(2)) SWIG_fail;
22605 if (arg2 == NULL) {
22606 SWIG_null_ref("wxDateSpan");
22607 }
22608 if (SWIG_arg_fail(2)) SWIG_fail;
22609 }
22610 {
22611 PyThreadState* __tstate = wxPyBeginAllowThreads();
22612 {
22613 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22614 result = (wxDateTime *) &_result_ref;
22615 }
22616
22617 wxPyEndAllowThreads(__tstate);
22618 if (PyErr_Occurred()) SWIG_fail;
22619 }
22620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22621 return resultobj;
22622 fail:
22623 return NULL;
22624 }
22625
22626
22627 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22628 int argc;
22629 PyObject *argv[3];
22630 int ii;
22631
22632 argc = PyObject_Length(args);
22633 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22634 argv[ii] = PyTuple_GetItem(args,ii);
22635 }
22636 if (argc == 2) {
22637 int _v;
22638 {
22639 void *ptr;
22640 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22641 _v = 0;
22642 PyErr_Clear();
22643 } else {
22644 _v = 1;
22645 }
22646 }
22647 if (_v) {
22648 {
22649 void *ptr = 0;
22650 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22651 _v = 0;
22652 PyErr_Clear();
22653 } else {
22654 _v = (ptr != 0);
22655 }
22656 }
22657 if (_v) {
22658 return _wrap_DateTime___iadd____SWIG_0(self,args);
22659 }
22660 }
22661 }
22662 if (argc == 2) {
22663 int _v;
22664 {
22665 void *ptr;
22666 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22667 _v = 0;
22668 PyErr_Clear();
22669 } else {
22670 _v = 1;
22671 }
22672 }
22673 if (_v) {
22674 {
22675 void *ptr = 0;
22676 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22677 _v = 0;
22678 PyErr_Clear();
22679 } else {
22680 _v = (ptr != 0);
22681 }
22682 }
22683 if (_v) {
22684 return _wrap_DateTime___iadd____SWIG_1(self,args);
22685 }
22686 }
22687 }
22688
22689 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22690 return NULL;
22691 }
22692
22693
22694 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22695 PyObject *resultobj;
22696 wxDateTime *arg1 = (wxDateTime *) 0 ;
22697 wxTimeSpan *arg2 = 0 ;
22698 wxDateTime *result;
22699 PyObject * obj0 = 0 ;
22700 PyObject * obj1 = 0 ;
22701
22702 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22704 if (SWIG_arg_fail(1)) SWIG_fail;
22705 {
22706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22707 if (SWIG_arg_fail(2)) SWIG_fail;
22708 if (arg2 == NULL) {
22709 SWIG_null_ref("wxTimeSpan");
22710 }
22711 if (SWIG_arg_fail(2)) SWIG_fail;
22712 }
22713 {
22714 PyThreadState* __tstate = wxPyBeginAllowThreads();
22715 {
22716 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22717 result = (wxDateTime *) &_result_ref;
22718 }
22719
22720 wxPyEndAllowThreads(__tstate);
22721 if (PyErr_Occurred()) SWIG_fail;
22722 }
22723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22724 return resultobj;
22725 fail:
22726 return NULL;
22727 }
22728
22729
22730 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22731 PyObject *resultobj;
22732 wxDateTime *arg1 = (wxDateTime *) 0 ;
22733 wxDateSpan *arg2 = 0 ;
22734 wxDateTime *result;
22735 PyObject * obj0 = 0 ;
22736 PyObject * obj1 = 0 ;
22737
22738 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22740 if (SWIG_arg_fail(1)) SWIG_fail;
22741 {
22742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22743 if (SWIG_arg_fail(2)) SWIG_fail;
22744 if (arg2 == NULL) {
22745 SWIG_null_ref("wxDateSpan");
22746 }
22747 if (SWIG_arg_fail(2)) SWIG_fail;
22748 }
22749 {
22750 PyThreadState* __tstate = wxPyBeginAllowThreads();
22751 {
22752 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22753 result = (wxDateTime *) &_result_ref;
22754 }
22755
22756 wxPyEndAllowThreads(__tstate);
22757 if (PyErr_Occurred()) SWIG_fail;
22758 }
22759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22760 return resultobj;
22761 fail:
22762 return NULL;
22763 }
22764
22765
22766 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22767 int argc;
22768 PyObject *argv[3];
22769 int ii;
22770
22771 argc = PyObject_Length(args);
22772 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22773 argv[ii] = PyTuple_GetItem(args,ii);
22774 }
22775 if (argc == 2) {
22776 int _v;
22777 {
22778 void *ptr;
22779 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22780 _v = 0;
22781 PyErr_Clear();
22782 } else {
22783 _v = 1;
22784 }
22785 }
22786 if (_v) {
22787 {
22788 void *ptr = 0;
22789 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22790 _v = 0;
22791 PyErr_Clear();
22792 } else {
22793 _v = (ptr != 0);
22794 }
22795 }
22796 if (_v) {
22797 return _wrap_DateTime___isub____SWIG_0(self,args);
22798 }
22799 }
22800 }
22801 if (argc == 2) {
22802 int _v;
22803 {
22804 void *ptr;
22805 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22806 _v = 0;
22807 PyErr_Clear();
22808 } else {
22809 _v = 1;
22810 }
22811 }
22812 if (_v) {
22813 {
22814 void *ptr = 0;
22815 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22816 _v = 0;
22817 PyErr_Clear();
22818 } else {
22819 _v = (ptr != 0);
22820 }
22821 }
22822 if (_v) {
22823 return _wrap_DateTime___isub____SWIG_1(self,args);
22824 }
22825 }
22826 }
22827
22828 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22829 return NULL;
22830 }
22831
22832
22833 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22834 PyObject *resultobj;
22835 wxDateTime *arg1 = (wxDateTime *) 0 ;
22836 wxTimeSpan *arg2 = 0 ;
22837 wxDateTime result;
22838 PyObject * obj0 = 0 ;
22839 PyObject * obj1 = 0 ;
22840
22841 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22843 if (SWIG_arg_fail(1)) SWIG_fail;
22844 {
22845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22846 if (SWIG_arg_fail(2)) SWIG_fail;
22847 if (arg2 == NULL) {
22848 SWIG_null_ref("wxTimeSpan");
22849 }
22850 if (SWIG_arg_fail(2)) SWIG_fail;
22851 }
22852 {
22853 PyThreadState* __tstate = wxPyBeginAllowThreads();
22854 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22855
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 {
22860 wxDateTime * resultptr;
22861 resultptr = new wxDateTime((wxDateTime &)(result));
22862 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22863 }
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22871 PyObject *resultobj;
22872 wxDateTime *arg1 = (wxDateTime *) 0 ;
22873 wxDateSpan *arg2 = 0 ;
22874 wxDateTime result;
22875 PyObject * obj0 = 0 ;
22876 PyObject * obj1 = 0 ;
22877
22878 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22880 if (SWIG_arg_fail(1)) SWIG_fail;
22881 {
22882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22883 if (SWIG_arg_fail(2)) SWIG_fail;
22884 if (arg2 == NULL) {
22885 SWIG_null_ref("wxDateSpan");
22886 }
22887 if (SWIG_arg_fail(2)) SWIG_fail;
22888 }
22889 {
22890 PyThreadState* __tstate = wxPyBeginAllowThreads();
22891 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22892
22893 wxPyEndAllowThreads(__tstate);
22894 if (PyErr_Occurred()) SWIG_fail;
22895 }
22896 {
22897 wxDateTime * resultptr;
22898 resultptr = new wxDateTime((wxDateTime &)(result));
22899 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22900 }
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22908 int argc;
22909 PyObject *argv[3];
22910 int ii;
22911
22912 argc = PyObject_Length(args);
22913 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22914 argv[ii] = PyTuple_GetItem(args,ii);
22915 }
22916 if (argc == 2) {
22917 int _v;
22918 {
22919 void *ptr;
22920 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22921 _v = 0;
22922 PyErr_Clear();
22923 } else {
22924 _v = 1;
22925 }
22926 }
22927 if (_v) {
22928 {
22929 void *ptr = 0;
22930 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22931 _v = 0;
22932 PyErr_Clear();
22933 } else {
22934 _v = (ptr != 0);
22935 }
22936 }
22937 if (_v) {
22938 return _wrap_DateTime___add____SWIG_0(self,args);
22939 }
22940 }
22941 }
22942 if (argc == 2) {
22943 int _v;
22944 {
22945 void *ptr;
22946 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22947 _v = 0;
22948 PyErr_Clear();
22949 } else {
22950 _v = 1;
22951 }
22952 }
22953 if (_v) {
22954 {
22955 void *ptr = 0;
22956 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22957 _v = 0;
22958 PyErr_Clear();
22959 } else {
22960 _v = (ptr != 0);
22961 }
22962 }
22963 if (_v) {
22964 return _wrap_DateTime___add____SWIG_1(self,args);
22965 }
22966 }
22967 }
22968
22969 Py_INCREF(Py_NotImplemented);
22970 return Py_NotImplemented;
22971 }
22972
22973
22974 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22975 PyObject *resultobj;
22976 wxDateTime *arg1 = (wxDateTime *) 0 ;
22977 wxDateTime *arg2 = 0 ;
22978 wxTimeSpan result;
22979 PyObject * obj0 = 0 ;
22980 PyObject * obj1 = 0 ;
22981
22982 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22984 if (SWIG_arg_fail(1)) SWIG_fail;
22985 {
22986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22987 if (SWIG_arg_fail(2)) SWIG_fail;
22988 if (arg2 == NULL) {
22989 SWIG_null_ref("wxDateTime");
22990 }
22991 if (SWIG_arg_fail(2)) SWIG_fail;
22992 }
22993 {
22994 PyThreadState* __tstate = wxPyBeginAllowThreads();
22995 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22996
22997 wxPyEndAllowThreads(__tstate);
22998 if (PyErr_Occurred()) SWIG_fail;
22999 }
23000 {
23001 wxTimeSpan * resultptr;
23002 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23003 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23004 }
23005 return resultobj;
23006 fail:
23007 return NULL;
23008 }
23009
23010
23011 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23012 PyObject *resultobj;
23013 wxDateTime *arg1 = (wxDateTime *) 0 ;
23014 wxTimeSpan *arg2 = 0 ;
23015 wxDateTime result;
23016 PyObject * obj0 = 0 ;
23017 PyObject * obj1 = 0 ;
23018
23019 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23021 if (SWIG_arg_fail(1)) SWIG_fail;
23022 {
23023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23024 if (SWIG_arg_fail(2)) SWIG_fail;
23025 if (arg2 == NULL) {
23026 SWIG_null_ref("wxTimeSpan");
23027 }
23028 if (SWIG_arg_fail(2)) SWIG_fail;
23029 }
23030 {
23031 PyThreadState* __tstate = wxPyBeginAllowThreads();
23032 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23033
23034 wxPyEndAllowThreads(__tstate);
23035 if (PyErr_Occurred()) SWIG_fail;
23036 }
23037 {
23038 wxDateTime * resultptr;
23039 resultptr = new wxDateTime((wxDateTime &)(result));
23040 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23041 }
23042 return resultobj;
23043 fail:
23044 return NULL;
23045 }
23046
23047
23048 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23049 PyObject *resultobj;
23050 wxDateTime *arg1 = (wxDateTime *) 0 ;
23051 wxDateSpan *arg2 = 0 ;
23052 wxDateTime result;
23053 PyObject * obj0 = 0 ;
23054 PyObject * obj1 = 0 ;
23055
23056 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23058 if (SWIG_arg_fail(1)) SWIG_fail;
23059 {
23060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23061 if (SWIG_arg_fail(2)) SWIG_fail;
23062 if (arg2 == NULL) {
23063 SWIG_null_ref("wxDateSpan");
23064 }
23065 if (SWIG_arg_fail(2)) SWIG_fail;
23066 }
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23070
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 {
23075 wxDateTime * resultptr;
23076 resultptr = new wxDateTime((wxDateTime &)(result));
23077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23078 }
23079 return resultobj;
23080 fail:
23081 return NULL;
23082 }
23083
23084
23085 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23086 int argc;
23087 PyObject *argv[3];
23088 int ii;
23089
23090 argc = PyObject_Length(args);
23091 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23092 argv[ii] = PyTuple_GetItem(args,ii);
23093 }
23094 if (argc == 2) {
23095 int _v;
23096 {
23097 void *ptr;
23098 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23099 _v = 0;
23100 PyErr_Clear();
23101 } else {
23102 _v = 1;
23103 }
23104 }
23105 if (_v) {
23106 {
23107 void *ptr = 0;
23108 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23109 _v = 0;
23110 PyErr_Clear();
23111 } else {
23112 _v = (ptr != 0);
23113 }
23114 }
23115 if (_v) {
23116 return _wrap_DateTime___sub____SWIG_0(self,args);
23117 }
23118 }
23119 }
23120 if (argc == 2) {
23121 int _v;
23122 {
23123 void *ptr;
23124 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23125 _v = 0;
23126 PyErr_Clear();
23127 } else {
23128 _v = 1;
23129 }
23130 }
23131 if (_v) {
23132 {
23133 void *ptr = 0;
23134 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23135 _v = 0;
23136 PyErr_Clear();
23137 } else {
23138 _v = (ptr != 0);
23139 }
23140 }
23141 if (_v) {
23142 return _wrap_DateTime___sub____SWIG_1(self,args);
23143 }
23144 }
23145 }
23146 if (argc == 2) {
23147 int _v;
23148 {
23149 void *ptr;
23150 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23151 _v = 0;
23152 PyErr_Clear();
23153 } else {
23154 _v = 1;
23155 }
23156 }
23157 if (_v) {
23158 {
23159 void *ptr = 0;
23160 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23161 _v = 0;
23162 PyErr_Clear();
23163 } else {
23164 _v = (ptr != 0);
23165 }
23166 }
23167 if (_v) {
23168 return _wrap_DateTime___sub____SWIG_2(self,args);
23169 }
23170 }
23171 }
23172
23173 Py_INCREF(Py_NotImplemented);
23174 return Py_NotImplemented;
23175 }
23176
23177
23178 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23179 PyObject *resultobj;
23180 wxDateTime *arg1 = (wxDateTime *) 0 ;
23181 wxDateTime *arg2 = (wxDateTime *) 0 ;
23182 bool result;
23183 PyObject * obj0 = 0 ;
23184 PyObject * obj1 = 0 ;
23185 char *kwnames[] = {
23186 (char *) "self",(char *) "other", NULL
23187 };
23188
23189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23191 if (SWIG_arg_fail(1)) SWIG_fail;
23192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23193 if (SWIG_arg_fail(2)) SWIG_fail;
23194 {
23195 PyThreadState* __tstate = wxPyBeginAllowThreads();
23196 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23197
23198 wxPyEndAllowThreads(__tstate);
23199 if (PyErr_Occurred()) SWIG_fail;
23200 }
23201 {
23202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23203 }
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23211 PyObject *resultobj;
23212 wxDateTime *arg1 = (wxDateTime *) 0 ;
23213 wxDateTime *arg2 = (wxDateTime *) 0 ;
23214 bool result;
23215 PyObject * obj0 = 0 ;
23216 PyObject * obj1 = 0 ;
23217 char *kwnames[] = {
23218 (char *) "self",(char *) "other", NULL
23219 };
23220
23221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23223 if (SWIG_arg_fail(1)) SWIG_fail;
23224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23225 if (SWIG_arg_fail(2)) SWIG_fail;
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23229
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 {
23234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23235 }
23236 return resultobj;
23237 fail:
23238 return NULL;
23239 }
23240
23241
23242 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23243 PyObject *resultobj;
23244 wxDateTime *arg1 = (wxDateTime *) 0 ;
23245 wxDateTime *arg2 = (wxDateTime *) 0 ;
23246 bool result;
23247 PyObject * obj0 = 0 ;
23248 PyObject * obj1 = 0 ;
23249 char *kwnames[] = {
23250 (char *) "self",(char *) "other", NULL
23251 };
23252
23253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23255 if (SWIG_arg_fail(1)) SWIG_fail;
23256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23257 if (SWIG_arg_fail(2)) SWIG_fail;
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23261
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 {
23266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj;
23276 wxDateTime *arg1 = (wxDateTime *) 0 ;
23277 wxDateTime *arg2 = (wxDateTime *) 0 ;
23278 bool result;
23279 PyObject * obj0 = 0 ;
23280 PyObject * obj1 = 0 ;
23281 char *kwnames[] = {
23282 (char *) "self",(char *) "other", NULL
23283 };
23284
23285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23287 if (SWIG_arg_fail(1)) SWIG_fail;
23288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23289 if (SWIG_arg_fail(2)) SWIG_fail;
23290 {
23291 PyThreadState* __tstate = wxPyBeginAllowThreads();
23292 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23293
23294 wxPyEndAllowThreads(__tstate);
23295 if (PyErr_Occurred()) SWIG_fail;
23296 }
23297 {
23298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23299 }
23300 return resultobj;
23301 fail:
23302 return NULL;
23303 }
23304
23305
23306 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23307 PyObject *resultobj;
23308 wxDateTime *arg1 = (wxDateTime *) 0 ;
23309 wxDateTime *arg2 = (wxDateTime *) 0 ;
23310 bool result;
23311 PyObject * obj0 = 0 ;
23312 PyObject * obj1 = 0 ;
23313 char *kwnames[] = {
23314 (char *) "self",(char *) "other", NULL
23315 };
23316
23317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23319 if (SWIG_arg_fail(1)) SWIG_fail;
23320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23321 if (SWIG_arg_fail(2)) SWIG_fail;
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23325
23326 wxPyEndAllowThreads(__tstate);
23327 if (PyErr_Occurred()) SWIG_fail;
23328 }
23329 {
23330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23331 }
23332 return resultobj;
23333 fail:
23334 return NULL;
23335 }
23336
23337
23338 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23339 PyObject *resultobj;
23340 wxDateTime *arg1 = (wxDateTime *) 0 ;
23341 wxDateTime *arg2 = (wxDateTime *) 0 ;
23342 bool result;
23343 PyObject * obj0 = 0 ;
23344 PyObject * obj1 = 0 ;
23345 char *kwnames[] = {
23346 (char *) "self",(char *) "other", NULL
23347 };
23348
23349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23351 if (SWIG_arg_fail(1)) SWIG_fail;
23352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23353 if (SWIG_arg_fail(2)) SWIG_fail;
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23357
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 {
23362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23363 }
23364 return resultobj;
23365 fail:
23366 return NULL;
23367 }
23368
23369
23370 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23371 PyObject *resultobj;
23372 wxDateTime *arg1 = (wxDateTime *) 0 ;
23373 wxString *arg2 = 0 ;
23374 int result;
23375 bool temp2 = false ;
23376 PyObject * obj0 = 0 ;
23377 PyObject * obj1 = 0 ;
23378 char *kwnames[] = {
23379 (char *) "self",(char *) "date", NULL
23380 };
23381
23382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23384 if (SWIG_arg_fail(1)) SWIG_fail;
23385 {
23386 arg2 = wxString_in_helper(obj1);
23387 if (arg2 == NULL) SWIG_fail;
23388 temp2 = true;
23389 }
23390 {
23391 PyThreadState* __tstate = wxPyBeginAllowThreads();
23392 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23393
23394 wxPyEndAllowThreads(__tstate);
23395 if (PyErr_Occurred()) SWIG_fail;
23396 }
23397 {
23398 resultobj = SWIG_From_int((int)(result));
23399 }
23400 {
23401 if (temp2)
23402 delete arg2;
23403 }
23404 return resultobj;
23405 fail:
23406 {
23407 if (temp2)
23408 delete arg2;
23409 }
23410 return NULL;
23411 }
23412
23413
23414 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23415 PyObject *resultobj;
23416 wxDateTime *arg1 = (wxDateTime *) 0 ;
23417 wxString *arg2 = 0 ;
23418 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23419 wxString *arg3 = (wxString *) &arg3_defvalue ;
23420 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23421 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23422 int result;
23423 bool temp2 = false ;
23424 bool temp3 = false ;
23425 PyObject * obj0 = 0 ;
23426 PyObject * obj1 = 0 ;
23427 PyObject * obj2 = 0 ;
23428 PyObject * obj3 = 0 ;
23429 char *kwnames[] = {
23430 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23431 };
23432
23433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23435 if (SWIG_arg_fail(1)) SWIG_fail;
23436 {
23437 arg2 = wxString_in_helper(obj1);
23438 if (arg2 == NULL) SWIG_fail;
23439 temp2 = true;
23440 }
23441 if (obj2) {
23442 {
23443 arg3 = wxString_in_helper(obj2);
23444 if (arg3 == NULL) SWIG_fail;
23445 temp3 = true;
23446 }
23447 }
23448 if (obj3) {
23449 {
23450 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23451 if (SWIG_arg_fail(4)) SWIG_fail;
23452 if (arg4 == NULL) {
23453 SWIG_null_ref("wxDateTime");
23454 }
23455 if (SWIG_arg_fail(4)) SWIG_fail;
23456 }
23457 }
23458 {
23459 PyThreadState* __tstate = wxPyBeginAllowThreads();
23460 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23461
23462 wxPyEndAllowThreads(__tstate);
23463 if (PyErr_Occurred()) SWIG_fail;
23464 }
23465 {
23466 resultobj = SWIG_From_int((int)(result));
23467 }
23468 {
23469 if (temp2)
23470 delete arg2;
23471 }
23472 {
23473 if (temp3)
23474 delete arg3;
23475 }
23476 return resultobj;
23477 fail:
23478 {
23479 if (temp2)
23480 delete arg2;
23481 }
23482 {
23483 if (temp3)
23484 delete arg3;
23485 }
23486 return NULL;
23487 }
23488
23489
23490 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23491 PyObject *resultobj;
23492 wxDateTime *arg1 = (wxDateTime *) 0 ;
23493 wxString *arg2 = 0 ;
23494 int result;
23495 bool temp2 = false ;
23496 PyObject * obj0 = 0 ;
23497 PyObject * obj1 = 0 ;
23498 char *kwnames[] = {
23499 (char *) "self",(char *) "datetime", NULL
23500 };
23501
23502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23504 if (SWIG_arg_fail(1)) SWIG_fail;
23505 {
23506 arg2 = wxString_in_helper(obj1);
23507 if (arg2 == NULL) SWIG_fail;
23508 temp2 = true;
23509 }
23510 {
23511 PyThreadState* __tstate = wxPyBeginAllowThreads();
23512 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23513
23514 wxPyEndAllowThreads(__tstate);
23515 if (PyErr_Occurred()) SWIG_fail;
23516 }
23517 {
23518 resultobj = SWIG_From_int((int)(result));
23519 }
23520 {
23521 if (temp2)
23522 delete arg2;
23523 }
23524 return resultobj;
23525 fail:
23526 {
23527 if (temp2)
23528 delete arg2;
23529 }
23530 return NULL;
23531 }
23532
23533
23534 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23535 PyObject *resultobj;
23536 wxDateTime *arg1 = (wxDateTime *) 0 ;
23537 wxString *arg2 = 0 ;
23538 int result;
23539 bool temp2 = false ;
23540 PyObject * obj0 = 0 ;
23541 PyObject * obj1 = 0 ;
23542 char *kwnames[] = {
23543 (char *) "self",(char *) "date", NULL
23544 };
23545
23546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23548 if (SWIG_arg_fail(1)) SWIG_fail;
23549 {
23550 arg2 = wxString_in_helper(obj1);
23551 if (arg2 == NULL) SWIG_fail;
23552 temp2 = true;
23553 }
23554 {
23555 PyThreadState* __tstate = wxPyBeginAllowThreads();
23556 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23557
23558 wxPyEndAllowThreads(__tstate);
23559 if (PyErr_Occurred()) SWIG_fail;
23560 }
23561 {
23562 resultobj = SWIG_From_int((int)(result));
23563 }
23564 {
23565 if (temp2)
23566 delete arg2;
23567 }
23568 return resultobj;
23569 fail:
23570 {
23571 if (temp2)
23572 delete arg2;
23573 }
23574 return NULL;
23575 }
23576
23577
23578 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23579 PyObject *resultobj;
23580 wxDateTime *arg1 = (wxDateTime *) 0 ;
23581 wxString *arg2 = 0 ;
23582 int result;
23583 bool temp2 = false ;
23584 PyObject * obj0 = 0 ;
23585 PyObject * obj1 = 0 ;
23586 char *kwnames[] = {
23587 (char *) "self",(char *) "time", NULL
23588 };
23589
23590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23592 if (SWIG_arg_fail(1)) SWIG_fail;
23593 {
23594 arg2 = wxString_in_helper(obj1);
23595 if (arg2 == NULL) SWIG_fail;
23596 temp2 = true;
23597 }
23598 {
23599 PyThreadState* __tstate = wxPyBeginAllowThreads();
23600 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23601
23602 wxPyEndAllowThreads(__tstate);
23603 if (PyErr_Occurred()) SWIG_fail;
23604 }
23605 {
23606 resultobj = SWIG_From_int((int)(result));
23607 }
23608 {
23609 if (temp2)
23610 delete arg2;
23611 }
23612 return resultobj;
23613 fail:
23614 {
23615 if (temp2)
23616 delete arg2;
23617 }
23618 return NULL;
23619 }
23620
23621
23622 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23623 PyObject *resultobj;
23624 wxDateTime *arg1 = (wxDateTime *) 0 ;
23625 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23626 wxString *arg2 = (wxString *) &arg2_defvalue ;
23627 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23628 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23629 wxString result;
23630 bool temp2 = false ;
23631 bool temp3 = false ;
23632 PyObject * obj0 = 0 ;
23633 PyObject * obj1 = 0 ;
23634 PyObject * obj2 = 0 ;
23635 char *kwnames[] = {
23636 (char *) "self",(char *) "format",(char *) "tz", NULL
23637 };
23638
23639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23641 if (SWIG_arg_fail(1)) SWIG_fail;
23642 if (obj1) {
23643 {
23644 arg2 = wxString_in_helper(obj1);
23645 if (arg2 == NULL) SWIG_fail;
23646 temp2 = true;
23647 }
23648 }
23649 if (obj2) {
23650 {
23651 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23652 temp3 = true;
23653 }
23654 }
23655 {
23656 PyThreadState* __tstate = wxPyBeginAllowThreads();
23657 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23658
23659 wxPyEndAllowThreads(__tstate);
23660 if (PyErr_Occurred()) SWIG_fail;
23661 }
23662 {
23663 #if wxUSE_UNICODE
23664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23665 #else
23666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23667 #endif
23668 }
23669 {
23670 if (temp2)
23671 delete arg2;
23672 }
23673 {
23674 if (temp3) delete arg3;
23675 }
23676 return resultobj;
23677 fail:
23678 {
23679 if (temp2)
23680 delete arg2;
23681 }
23682 {
23683 if (temp3) delete arg3;
23684 }
23685 return NULL;
23686 }
23687
23688
23689 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23690 PyObject *resultobj;
23691 wxDateTime *arg1 = (wxDateTime *) 0 ;
23692 wxString result;
23693 PyObject * obj0 = 0 ;
23694 char *kwnames[] = {
23695 (char *) "self", NULL
23696 };
23697
23698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23700 if (SWIG_arg_fail(1)) SWIG_fail;
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 result = ((wxDateTime const *)arg1)->FormatDate();
23704
23705 wxPyEndAllowThreads(__tstate);
23706 if (PyErr_Occurred()) SWIG_fail;
23707 }
23708 {
23709 #if wxUSE_UNICODE
23710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23711 #else
23712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23713 #endif
23714 }
23715 return resultobj;
23716 fail:
23717 return NULL;
23718 }
23719
23720
23721 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23722 PyObject *resultobj;
23723 wxDateTime *arg1 = (wxDateTime *) 0 ;
23724 wxString result;
23725 PyObject * obj0 = 0 ;
23726 char *kwnames[] = {
23727 (char *) "self", NULL
23728 };
23729
23730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23732 if (SWIG_arg_fail(1)) SWIG_fail;
23733 {
23734 PyThreadState* __tstate = wxPyBeginAllowThreads();
23735 result = ((wxDateTime const *)arg1)->FormatTime();
23736
23737 wxPyEndAllowThreads(__tstate);
23738 if (PyErr_Occurred()) SWIG_fail;
23739 }
23740 {
23741 #if wxUSE_UNICODE
23742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23743 #else
23744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23745 #endif
23746 }
23747 return resultobj;
23748 fail:
23749 return NULL;
23750 }
23751
23752
23753 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23754 PyObject *resultobj;
23755 wxDateTime *arg1 = (wxDateTime *) 0 ;
23756 wxString result;
23757 PyObject * obj0 = 0 ;
23758 char *kwnames[] = {
23759 (char *) "self", NULL
23760 };
23761
23762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23764 if (SWIG_arg_fail(1)) SWIG_fail;
23765 {
23766 PyThreadState* __tstate = wxPyBeginAllowThreads();
23767 result = ((wxDateTime const *)arg1)->FormatISODate();
23768
23769 wxPyEndAllowThreads(__tstate);
23770 if (PyErr_Occurred()) SWIG_fail;
23771 }
23772 {
23773 #if wxUSE_UNICODE
23774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23775 #else
23776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23777 #endif
23778 }
23779 return resultobj;
23780 fail:
23781 return NULL;
23782 }
23783
23784
23785 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23786 PyObject *resultobj;
23787 wxDateTime *arg1 = (wxDateTime *) 0 ;
23788 wxString result;
23789 PyObject * obj0 = 0 ;
23790 char *kwnames[] = {
23791 (char *) "self", NULL
23792 };
23793
23794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23796 if (SWIG_arg_fail(1)) SWIG_fail;
23797 {
23798 PyThreadState* __tstate = wxPyBeginAllowThreads();
23799 result = ((wxDateTime const *)arg1)->FormatISOTime();
23800
23801 wxPyEndAllowThreads(__tstate);
23802 if (PyErr_Occurred()) SWIG_fail;
23803 }
23804 {
23805 #if wxUSE_UNICODE
23806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23807 #else
23808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23809 #endif
23810 }
23811 return resultobj;
23812 fail:
23813 return NULL;
23814 }
23815
23816
23817 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23818 PyObject *obj;
23819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23820 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23821 Py_INCREF(obj);
23822 return Py_BuildValue((char *)"");
23823 }
23824 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23825 PyObject *resultobj;
23826 long arg1 ;
23827 wxTimeSpan result;
23828 PyObject * obj0 = 0 ;
23829 char *kwnames[] = {
23830 (char *) "sec", NULL
23831 };
23832
23833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23834 {
23835 arg1 = (long)(SWIG_As_long(obj0));
23836 if (SWIG_arg_fail(1)) SWIG_fail;
23837 }
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = wxTimeSpan::Seconds(arg1);
23841
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 {
23846 wxTimeSpan * resultptr;
23847 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23848 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23849 }
23850 return resultobj;
23851 fail:
23852 return NULL;
23853 }
23854
23855
23856 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj;
23858 wxTimeSpan result;
23859 char *kwnames[] = {
23860 NULL
23861 };
23862
23863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23864 {
23865 PyThreadState* __tstate = wxPyBeginAllowThreads();
23866 result = wxTimeSpan::Second();
23867
23868 wxPyEndAllowThreads(__tstate);
23869 if (PyErr_Occurred()) SWIG_fail;
23870 }
23871 {
23872 wxTimeSpan * resultptr;
23873 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23874 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23875 }
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23883 PyObject *resultobj;
23884 long arg1 ;
23885 wxTimeSpan result;
23886 PyObject * obj0 = 0 ;
23887 char *kwnames[] = {
23888 (char *) "min", NULL
23889 };
23890
23891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23892 {
23893 arg1 = (long)(SWIG_As_long(obj0));
23894 if (SWIG_arg_fail(1)) SWIG_fail;
23895 }
23896 {
23897 PyThreadState* __tstate = wxPyBeginAllowThreads();
23898 result = wxTimeSpan::Minutes(arg1);
23899
23900 wxPyEndAllowThreads(__tstate);
23901 if (PyErr_Occurred()) SWIG_fail;
23902 }
23903 {
23904 wxTimeSpan * resultptr;
23905 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23907 }
23908 return resultobj;
23909 fail:
23910 return NULL;
23911 }
23912
23913
23914 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23915 PyObject *resultobj;
23916 wxTimeSpan result;
23917 char *kwnames[] = {
23918 NULL
23919 };
23920
23921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 result = wxTimeSpan::Minute();
23925
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 {
23930 wxTimeSpan * resultptr;
23931 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23933 }
23934 return resultobj;
23935 fail:
23936 return NULL;
23937 }
23938
23939
23940 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23941 PyObject *resultobj;
23942 long arg1 ;
23943 wxTimeSpan result;
23944 PyObject * obj0 = 0 ;
23945 char *kwnames[] = {
23946 (char *) "hours", NULL
23947 };
23948
23949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23950 {
23951 arg1 = (long)(SWIG_As_long(obj0));
23952 if (SWIG_arg_fail(1)) SWIG_fail;
23953 }
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 result = wxTimeSpan::Hours(arg1);
23957
23958 wxPyEndAllowThreads(__tstate);
23959 if (PyErr_Occurred()) SWIG_fail;
23960 }
23961 {
23962 wxTimeSpan * resultptr;
23963 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23964 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23965 }
23966 return resultobj;
23967 fail:
23968 return NULL;
23969 }
23970
23971
23972 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23973 PyObject *resultobj;
23974 wxTimeSpan result;
23975 char *kwnames[] = {
23976 NULL
23977 };
23978
23979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23980 {
23981 PyThreadState* __tstate = wxPyBeginAllowThreads();
23982 result = wxTimeSpan::Hour();
23983
23984 wxPyEndAllowThreads(__tstate);
23985 if (PyErr_Occurred()) SWIG_fail;
23986 }
23987 {
23988 wxTimeSpan * resultptr;
23989 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23991 }
23992 return resultobj;
23993 fail:
23994 return NULL;
23995 }
23996
23997
23998 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23999 PyObject *resultobj;
24000 long arg1 ;
24001 wxTimeSpan result;
24002 PyObject * obj0 = 0 ;
24003 char *kwnames[] = {
24004 (char *) "days", NULL
24005 };
24006
24007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24008 {
24009 arg1 = (long)(SWIG_As_long(obj0));
24010 if (SWIG_arg_fail(1)) SWIG_fail;
24011 }
24012 {
24013 PyThreadState* __tstate = wxPyBeginAllowThreads();
24014 result = wxTimeSpan::Days(arg1);
24015
24016 wxPyEndAllowThreads(__tstate);
24017 if (PyErr_Occurred()) SWIG_fail;
24018 }
24019 {
24020 wxTimeSpan * resultptr;
24021 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24023 }
24024 return resultobj;
24025 fail:
24026 return NULL;
24027 }
24028
24029
24030 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24031 PyObject *resultobj;
24032 wxTimeSpan result;
24033 char *kwnames[] = {
24034 NULL
24035 };
24036
24037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24038 {
24039 PyThreadState* __tstate = wxPyBeginAllowThreads();
24040 result = wxTimeSpan::Day();
24041
24042 wxPyEndAllowThreads(__tstate);
24043 if (PyErr_Occurred()) SWIG_fail;
24044 }
24045 {
24046 wxTimeSpan * resultptr;
24047 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24049 }
24050 return resultobj;
24051 fail:
24052 return NULL;
24053 }
24054
24055
24056 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24057 PyObject *resultobj;
24058 long arg1 ;
24059 wxTimeSpan result;
24060 PyObject * obj0 = 0 ;
24061 char *kwnames[] = {
24062 (char *) "days", NULL
24063 };
24064
24065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24066 {
24067 arg1 = (long)(SWIG_As_long(obj0));
24068 if (SWIG_arg_fail(1)) SWIG_fail;
24069 }
24070 {
24071 PyThreadState* __tstate = wxPyBeginAllowThreads();
24072 result = wxTimeSpan::Weeks(arg1);
24073
24074 wxPyEndAllowThreads(__tstate);
24075 if (PyErr_Occurred()) SWIG_fail;
24076 }
24077 {
24078 wxTimeSpan * resultptr;
24079 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24081 }
24082 return resultobj;
24083 fail:
24084 return NULL;
24085 }
24086
24087
24088 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24089 PyObject *resultobj;
24090 wxTimeSpan result;
24091 char *kwnames[] = {
24092 NULL
24093 };
24094
24095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24096 {
24097 PyThreadState* __tstate = wxPyBeginAllowThreads();
24098 result = wxTimeSpan::Week();
24099
24100 wxPyEndAllowThreads(__tstate);
24101 if (PyErr_Occurred()) SWIG_fail;
24102 }
24103 {
24104 wxTimeSpan * resultptr;
24105 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24107 }
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24115 PyObject *resultobj;
24116 long arg1 = (long) 0 ;
24117 long arg2 = (long) 0 ;
24118 long arg3 = (long) 0 ;
24119 long arg4 = (long) 0 ;
24120 wxTimeSpan *result;
24121 PyObject * obj0 = 0 ;
24122 PyObject * obj1 = 0 ;
24123 PyObject * obj2 = 0 ;
24124 PyObject * obj3 = 0 ;
24125 char *kwnames[] = {
24126 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24127 };
24128
24129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24130 if (obj0) {
24131 {
24132 arg1 = (long)(SWIG_As_long(obj0));
24133 if (SWIG_arg_fail(1)) SWIG_fail;
24134 }
24135 }
24136 if (obj1) {
24137 {
24138 arg2 = (long)(SWIG_As_long(obj1));
24139 if (SWIG_arg_fail(2)) SWIG_fail;
24140 }
24141 }
24142 if (obj2) {
24143 {
24144 arg3 = (long)(SWIG_As_long(obj2));
24145 if (SWIG_arg_fail(3)) SWIG_fail;
24146 }
24147 }
24148 if (obj3) {
24149 {
24150 arg4 = (long)(SWIG_As_long(obj3));
24151 if (SWIG_arg_fail(4)) SWIG_fail;
24152 }
24153 }
24154 {
24155 PyThreadState* __tstate = wxPyBeginAllowThreads();
24156 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24157
24158 wxPyEndAllowThreads(__tstate);
24159 if (PyErr_Occurred()) SWIG_fail;
24160 }
24161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24162 return resultobj;
24163 fail:
24164 return NULL;
24165 }
24166
24167
24168 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24169 PyObject *resultobj;
24170 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24171 PyObject * obj0 = 0 ;
24172 char *kwnames[] = {
24173 (char *) "self", NULL
24174 };
24175
24176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24178 if (SWIG_arg_fail(1)) SWIG_fail;
24179 {
24180 PyThreadState* __tstate = wxPyBeginAllowThreads();
24181 delete arg1;
24182
24183 wxPyEndAllowThreads(__tstate);
24184 if (PyErr_Occurred()) SWIG_fail;
24185 }
24186 Py_INCREF(Py_None); resultobj = Py_None;
24187 return resultobj;
24188 fail:
24189 return NULL;
24190 }
24191
24192
24193 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24194 PyObject *resultobj;
24195 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24196 wxTimeSpan *arg2 = 0 ;
24197 wxTimeSpan *result;
24198 PyObject * obj0 = 0 ;
24199 PyObject * obj1 = 0 ;
24200 char *kwnames[] = {
24201 (char *) "self",(char *) "diff", NULL
24202 };
24203
24204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24206 if (SWIG_arg_fail(1)) SWIG_fail;
24207 {
24208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24209 if (SWIG_arg_fail(2)) SWIG_fail;
24210 if (arg2 == NULL) {
24211 SWIG_null_ref("wxTimeSpan");
24212 }
24213 if (SWIG_arg_fail(2)) SWIG_fail;
24214 }
24215 {
24216 PyThreadState* __tstate = wxPyBeginAllowThreads();
24217 {
24218 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24219 result = (wxTimeSpan *) &_result_ref;
24220 }
24221
24222 wxPyEndAllowThreads(__tstate);
24223 if (PyErr_Occurred()) SWIG_fail;
24224 }
24225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24226 return resultobj;
24227 fail:
24228 return NULL;
24229 }
24230
24231
24232 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24233 PyObject *resultobj;
24234 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24235 wxTimeSpan *arg2 = 0 ;
24236 wxTimeSpan *result;
24237 PyObject * obj0 = 0 ;
24238 PyObject * obj1 = 0 ;
24239 char *kwnames[] = {
24240 (char *) "self",(char *) "diff", NULL
24241 };
24242
24243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24245 if (SWIG_arg_fail(1)) SWIG_fail;
24246 {
24247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24248 if (SWIG_arg_fail(2)) SWIG_fail;
24249 if (arg2 == NULL) {
24250 SWIG_null_ref("wxTimeSpan");
24251 }
24252 if (SWIG_arg_fail(2)) SWIG_fail;
24253 }
24254 {
24255 PyThreadState* __tstate = wxPyBeginAllowThreads();
24256 {
24257 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24258 result = (wxTimeSpan *) &_result_ref;
24259 }
24260
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24272 PyObject *resultobj;
24273 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24274 int arg2 ;
24275 wxTimeSpan *result;
24276 PyObject * obj0 = 0 ;
24277 PyObject * obj1 = 0 ;
24278 char *kwnames[] = {
24279 (char *) "self",(char *) "n", NULL
24280 };
24281
24282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24284 if (SWIG_arg_fail(1)) SWIG_fail;
24285 {
24286 arg2 = (int)(SWIG_As_int(obj1));
24287 if (SWIG_arg_fail(2)) SWIG_fail;
24288 }
24289 {
24290 PyThreadState* __tstate = wxPyBeginAllowThreads();
24291 {
24292 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24293 result = (wxTimeSpan *) &_result_ref;
24294 }
24295
24296 wxPyEndAllowThreads(__tstate);
24297 if (PyErr_Occurred()) SWIG_fail;
24298 }
24299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24300 return resultobj;
24301 fail:
24302 return NULL;
24303 }
24304
24305
24306 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24307 PyObject *resultobj;
24308 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24309 wxTimeSpan *result;
24310 PyObject * obj0 = 0 ;
24311 char *kwnames[] = {
24312 (char *) "self", NULL
24313 };
24314
24315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24317 if (SWIG_arg_fail(1)) SWIG_fail;
24318 {
24319 PyThreadState* __tstate = wxPyBeginAllowThreads();
24320 {
24321 wxTimeSpan &_result_ref = (arg1)->Neg();
24322 result = (wxTimeSpan *) &_result_ref;
24323 }
24324
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj;
24337 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24338 wxTimeSpan result;
24339 PyObject * obj0 = 0 ;
24340 char *kwnames[] = {
24341 (char *) "self", NULL
24342 };
24343
24344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24346 if (SWIG_arg_fail(1)) SWIG_fail;
24347 {
24348 PyThreadState* __tstate = wxPyBeginAllowThreads();
24349 result = ((wxTimeSpan const *)arg1)->Abs();
24350
24351 wxPyEndAllowThreads(__tstate);
24352 if (PyErr_Occurred()) SWIG_fail;
24353 }
24354 {
24355 wxTimeSpan * resultptr;
24356 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24358 }
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24366 PyObject *resultobj;
24367 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24368 wxTimeSpan *arg2 = 0 ;
24369 wxTimeSpan *result;
24370 PyObject * obj0 = 0 ;
24371 PyObject * obj1 = 0 ;
24372 char *kwnames[] = {
24373 (char *) "self",(char *) "diff", NULL
24374 };
24375
24376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24378 if (SWIG_arg_fail(1)) SWIG_fail;
24379 {
24380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24381 if (SWIG_arg_fail(2)) SWIG_fail;
24382 if (arg2 == NULL) {
24383 SWIG_null_ref("wxTimeSpan");
24384 }
24385 if (SWIG_arg_fail(2)) SWIG_fail;
24386 }
24387 {
24388 PyThreadState* __tstate = wxPyBeginAllowThreads();
24389 {
24390 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24391 result = (wxTimeSpan *) &_result_ref;
24392 }
24393
24394 wxPyEndAllowThreads(__tstate);
24395 if (PyErr_Occurred()) SWIG_fail;
24396 }
24397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24405 PyObject *resultobj;
24406 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24407 wxTimeSpan *arg2 = 0 ;
24408 wxTimeSpan *result;
24409 PyObject * obj0 = 0 ;
24410 PyObject * obj1 = 0 ;
24411 char *kwnames[] = {
24412 (char *) "self",(char *) "diff", NULL
24413 };
24414
24415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24417 if (SWIG_arg_fail(1)) SWIG_fail;
24418 {
24419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24420 if (SWIG_arg_fail(2)) SWIG_fail;
24421 if (arg2 == NULL) {
24422 SWIG_null_ref("wxTimeSpan");
24423 }
24424 if (SWIG_arg_fail(2)) SWIG_fail;
24425 }
24426 {
24427 PyThreadState* __tstate = wxPyBeginAllowThreads();
24428 {
24429 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24430 result = (wxTimeSpan *) &_result_ref;
24431 }
24432
24433 wxPyEndAllowThreads(__tstate);
24434 if (PyErr_Occurred()) SWIG_fail;
24435 }
24436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24437 return resultobj;
24438 fail:
24439 return NULL;
24440 }
24441
24442
24443 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj;
24445 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24446 int arg2 ;
24447 wxTimeSpan *result;
24448 PyObject * obj0 = 0 ;
24449 PyObject * obj1 = 0 ;
24450 char *kwnames[] = {
24451 (char *) "self",(char *) "n", NULL
24452 };
24453
24454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24456 if (SWIG_arg_fail(1)) SWIG_fail;
24457 {
24458 arg2 = (int)(SWIG_As_int(obj1));
24459 if (SWIG_arg_fail(2)) SWIG_fail;
24460 }
24461 {
24462 PyThreadState* __tstate = wxPyBeginAllowThreads();
24463 {
24464 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24465 result = (wxTimeSpan *) &_result_ref;
24466 }
24467
24468 wxPyEndAllowThreads(__tstate);
24469 if (PyErr_Occurred()) SWIG_fail;
24470 }
24471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24472 return resultobj;
24473 fail:
24474 return NULL;
24475 }
24476
24477
24478 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24479 PyObject *resultobj;
24480 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24481 wxTimeSpan *result;
24482 PyObject * obj0 = 0 ;
24483 char *kwnames[] = {
24484 (char *) "self", NULL
24485 };
24486
24487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24489 if (SWIG_arg_fail(1)) SWIG_fail;
24490 {
24491 PyThreadState* __tstate = wxPyBeginAllowThreads();
24492 {
24493 wxTimeSpan &_result_ref = (arg1)->operator -();
24494 result = (wxTimeSpan *) &_result_ref;
24495 }
24496
24497 wxPyEndAllowThreads(__tstate);
24498 if (PyErr_Occurred()) SWIG_fail;
24499 }
24500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24501 return resultobj;
24502 fail:
24503 return NULL;
24504 }
24505
24506
24507 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24508 PyObject *resultobj;
24509 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24510 wxTimeSpan *arg2 = 0 ;
24511 wxTimeSpan result;
24512 PyObject * obj0 = 0 ;
24513 PyObject * obj1 = 0 ;
24514 char *kwnames[] = {
24515 (char *) "self",(char *) "other", NULL
24516 };
24517
24518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24520 if (SWIG_arg_fail(1)) SWIG_fail;
24521 {
24522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24523 if (SWIG_arg_fail(2)) SWIG_fail;
24524 if (arg2 == NULL) {
24525 SWIG_null_ref("wxTimeSpan");
24526 }
24527 if (SWIG_arg_fail(2)) SWIG_fail;
24528 }
24529 {
24530 PyThreadState* __tstate = wxPyBeginAllowThreads();
24531 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24532
24533 wxPyEndAllowThreads(__tstate);
24534 if (PyErr_Occurred()) SWIG_fail;
24535 }
24536 {
24537 wxTimeSpan * resultptr;
24538 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24540 }
24541 return resultobj;
24542 fail:
24543 return NULL;
24544 }
24545
24546
24547 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24548 PyObject *resultobj;
24549 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24550 wxTimeSpan *arg2 = 0 ;
24551 wxTimeSpan result;
24552 PyObject * obj0 = 0 ;
24553 PyObject * obj1 = 0 ;
24554 char *kwnames[] = {
24555 (char *) "self",(char *) "other", NULL
24556 };
24557
24558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24563 if (SWIG_arg_fail(2)) SWIG_fail;
24564 if (arg2 == NULL) {
24565 SWIG_null_ref("wxTimeSpan");
24566 }
24567 if (SWIG_arg_fail(2)) SWIG_fail;
24568 }
24569 {
24570 PyThreadState* __tstate = wxPyBeginAllowThreads();
24571 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24572
24573 wxPyEndAllowThreads(__tstate);
24574 if (PyErr_Occurred()) SWIG_fail;
24575 }
24576 {
24577 wxTimeSpan * resultptr;
24578 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24580 }
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj;
24589 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24590 int arg2 ;
24591 wxTimeSpan result;
24592 PyObject * obj0 = 0 ;
24593 PyObject * obj1 = 0 ;
24594 char *kwnames[] = {
24595 (char *) "self",(char *) "n", NULL
24596 };
24597
24598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24600 if (SWIG_arg_fail(1)) SWIG_fail;
24601 {
24602 arg2 = (int)(SWIG_As_int(obj1));
24603 if (SWIG_arg_fail(2)) SWIG_fail;
24604 }
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 result = wxTimeSpan___mul__(arg1,arg2);
24608
24609 wxPyEndAllowThreads(__tstate);
24610 if (PyErr_Occurred()) SWIG_fail;
24611 }
24612 {
24613 wxTimeSpan * resultptr;
24614 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24615 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24616 }
24617 return resultobj;
24618 fail:
24619 return NULL;
24620 }
24621
24622
24623 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24624 PyObject *resultobj;
24625 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24626 int arg2 ;
24627 wxTimeSpan result;
24628 PyObject * obj0 = 0 ;
24629 PyObject * obj1 = 0 ;
24630 char *kwnames[] = {
24631 (char *) "self",(char *) "n", NULL
24632 };
24633
24634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24636 if (SWIG_arg_fail(1)) SWIG_fail;
24637 {
24638 arg2 = (int)(SWIG_As_int(obj1));
24639 if (SWIG_arg_fail(2)) SWIG_fail;
24640 }
24641 {
24642 PyThreadState* __tstate = wxPyBeginAllowThreads();
24643 result = wxTimeSpan___rmul__(arg1,arg2);
24644
24645 wxPyEndAllowThreads(__tstate);
24646 if (PyErr_Occurred()) SWIG_fail;
24647 }
24648 {
24649 wxTimeSpan * resultptr;
24650 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24652 }
24653 return resultobj;
24654 fail:
24655 return NULL;
24656 }
24657
24658
24659 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24660 PyObject *resultobj;
24661 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24662 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24663 bool result;
24664 PyObject * obj0 = 0 ;
24665 PyObject * obj1 = 0 ;
24666 char *kwnames[] = {
24667 (char *) "self",(char *) "other", NULL
24668 };
24669
24670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24672 if (SWIG_arg_fail(1)) SWIG_fail;
24673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24674 if (SWIG_arg_fail(2)) SWIG_fail;
24675 {
24676 PyThreadState* __tstate = wxPyBeginAllowThreads();
24677 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24678
24679 wxPyEndAllowThreads(__tstate);
24680 if (PyErr_Occurred()) SWIG_fail;
24681 }
24682 {
24683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24684 }
24685 return resultobj;
24686 fail:
24687 return NULL;
24688 }
24689
24690
24691 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24692 PyObject *resultobj;
24693 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24694 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24695 bool result;
24696 PyObject * obj0 = 0 ;
24697 PyObject * obj1 = 0 ;
24698 char *kwnames[] = {
24699 (char *) "self",(char *) "other", NULL
24700 };
24701
24702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24704 if (SWIG_arg_fail(1)) SWIG_fail;
24705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24706 if (SWIG_arg_fail(2)) SWIG_fail;
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24710
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 {
24715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24716 }
24717 return resultobj;
24718 fail:
24719 return NULL;
24720 }
24721
24722
24723 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24724 PyObject *resultobj;
24725 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24726 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24727 bool result;
24728 PyObject * obj0 = 0 ;
24729 PyObject * obj1 = 0 ;
24730 char *kwnames[] = {
24731 (char *) "self",(char *) "other", NULL
24732 };
24733
24734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24736 if (SWIG_arg_fail(1)) SWIG_fail;
24737 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24738 if (SWIG_arg_fail(2)) SWIG_fail;
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24742
24743 wxPyEndAllowThreads(__tstate);
24744 if (PyErr_Occurred()) SWIG_fail;
24745 }
24746 {
24747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24748 }
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj;
24757 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24758 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24759 bool result;
24760 PyObject * obj0 = 0 ;
24761 PyObject * obj1 = 0 ;
24762 char *kwnames[] = {
24763 (char *) "self",(char *) "other", NULL
24764 };
24765
24766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24768 if (SWIG_arg_fail(1)) SWIG_fail;
24769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24770 if (SWIG_arg_fail(2)) SWIG_fail;
24771 {
24772 PyThreadState* __tstate = wxPyBeginAllowThreads();
24773 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24774
24775 wxPyEndAllowThreads(__tstate);
24776 if (PyErr_Occurred()) SWIG_fail;
24777 }
24778 {
24779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24780 }
24781 return resultobj;
24782 fail:
24783 return NULL;
24784 }
24785
24786
24787 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24788 PyObject *resultobj;
24789 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24790 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24791 bool result;
24792 PyObject * obj0 = 0 ;
24793 PyObject * obj1 = 0 ;
24794 char *kwnames[] = {
24795 (char *) "self",(char *) "other", NULL
24796 };
24797
24798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24800 if (SWIG_arg_fail(1)) SWIG_fail;
24801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24802 if (SWIG_arg_fail(2)) SWIG_fail;
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24806
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 {
24811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24812 }
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24820 PyObject *resultobj;
24821 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24822 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24823 bool result;
24824 PyObject * obj0 = 0 ;
24825 PyObject * obj1 = 0 ;
24826 char *kwnames[] = {
24827 (char *) "self",(char *) "other", NULL
24828 };
24829
24830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24832 if (SWIG_arg_fail(1)) SWIG_fail;
24833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24834 if (SWIG_arg_fail(2)) SWIG_fail;
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24838
24839 wxPyEndAllowThreads(__tstate);
24840 if (PyErr_Occurred()) SWIG_fail;
24841 }
24842 {
24843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24844 }
24845 return resultobj;
24846 fail:
24847 return NULL;
24848 }
24849
24850
24851 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24852 PyObject *resultobj;
24853 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24854 bool result;
24855 PyObject * obj0 = 0 ;
24856 char *kwnames[] = {
24857 (char *) "self", NULL
24858 };
24859
24860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24862 if (SWIG_arg_fail(1)) SWIG_fail;
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24866
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 {
24871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24872 }
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24880 PyObject *resultobj;
24881 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24882 bool result;
24883 PyObject * obj0 = 0 ;
24884 char *kwnames[] = {
24885 (char *) "self", NULL
24886 };
24887
24888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24890 if (SWIG_arg_fail(1)) SWIG_fail;
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24894
24895 wxPyEndAllowThreads(__tstate);
24896 if (PyErr_Occurred()) SWIG_fail;
24897 }
24898 {
24899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24900 }
24901 return resultobj;
24902 fail:
24903 return NULL;
24904 }
24905
24906
24907 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24908 PyObject *resultobj;
24909 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24910 bool result;
24911 PyObject * obj0 = 0 ;
24912 char *kwnames[] = {
24913 (char *) "self", NULL
24914 };
24915
24916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24918 if (SWIG_arg_fail(1)) SWIG_fail;
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24922
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 {
24927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24928 }
24929 return resultobj;
24930 fail:
24931 return NULL;
24932 }
24933
24934
24935 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24936 PyObject *resultobj;
24937 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24938 wxTimeSpan *arg2 = 0 ;
24939 bool result;
24940 PyObject * obj0 = 0 ;
24941 PyObject * obj1 = 0 ;
24942 char *kwnames[] = {
24943 (char *) "self",(char *) "ts", NULL
24944 };
24945
24946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24948 if (SWIG_arg_fail(1)) SWIG_fail;
24949 {
24950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24951 if (SWIG_arg_fail(2)) SWIG_fail;
24952 if (arg2 == NULL) {
24953 SWIG_null_ref("wxTimeSpan");
24954 }
24955 if (SWIG_arg_fail(2)) SWIG_fail;
24956 }
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24960
24961 wxPyEndAllowThreads(__tstate);
24962 if (PyErr_Occurred()) SWIG_fail;
24963 }
24964 {
24965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24966 }
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24974 PyObject *resultobj;
24975 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24976 wxTimeSpan *arg2 = 0 ;
24977 bool result;
24978 PyObject * obj0 = 0 ;
24979 PyObject * obj1 = 0 ;
24980 char *kwnames[] = {
24981 (char *) "self",(char *) "ts", NULL
24982 };
24983
24984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24986 if (SWIG_arg_fail(1)) SWIG_fail;
24987 {
24988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24989 if (SWIG_arg_fail(2)) SWIG_fail;
24990 if (arg2 == NULL) {
24991 SWIG_null_ref("wxTimeSpan");
24992 }
24993 if (SWIG_arg_fail(2)) SWIG_fail;
24994 }
24995 {
24996 PyThreadState* __tstate = wxPyBeginAllowThreads();
24997 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24998
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 {
25003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25004 }
25005 return resultobj;
25006 fail:
25007 return NULL;
25008 }
25009
25010
25011 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25012 PyObject *resultobj;
25013 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25014 wxTimeSpan *arg2 = 0 ;
25015 bool result;
25016 PyObject * obj0 = 0 ;
25017 PyObject * obj1 = 0 ;
25018 char *kwnames[] = {
25019 (char *) "self",(char *) "t", NULL
25020 };
25021
25022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25024 if (SWIG_arg_fail(1)) SWIG_fail;
25025 {
25026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25027 if (SWIG_arg_fail(2)) SWIG_fail;
25028 if (arg2 == NULL) {
25029 SWIG_null_ref("wxTimeSpan");
25030 }
25031 if (SWIG_arg_fail(2)) SWIG_fail;
25032 }
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25036
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 {
25041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25042 }
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25050 PyObject *resultobj;
25051 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25052 int result;
25053 PyObject * obj0 = 0 ;
25054 char *kwnames[] = {
25055 (char *) "self", NULL
25056 };
25057
25058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25060 if (SWIG_arg_fail(1)) SWIG_fail;
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25064
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 {
25069 resultobj = SWIG_From_int((int)(result));
25070 }
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25078 PyObject *resultobj;
25079 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25080 int result;
25081 PyObject * obj0 = 0 ;
25082 char *kwnames[] = {
25083 (char *) "self", NULL
25084 };
25085
25086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25088 if (SWIG_arg_fail(1)) SWIG_fail;
25089 {
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25092
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 {
25097 resultobj = SWIG_From_int((int)(result));
25098 }
25099 return resultobj;
25100 fail:
25101 return NULL;
25102 }
25103
25104
25105 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25106 PyObject *resultobj;
25107 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25108 int result;
25109 PyObject * obj0 = 0 ;
25110 char *kwnames[] = {
25111 (char *) "self", NULL
25112 };
25113
25114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25116 if (SWIG_arg_fail(1)) SWIG_fail;
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25120
25121 wxPyEndAllowThreads(__tstate);
25122 if (PyErr_Occurred()) SWIG_fail;
25123 }
25124 {
25125 resultobj = SWIG_From_int((int)(result));
25126 }
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25134 PyObject *resultobj;
25135 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25136 int result;
25137 PyObject * obj0 = 0 ;
25138 char *kwnames[] = {
25139 (char *) "self", NULL
25140 };
25141
25142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25144 if (SWIG_arg_fail(1)) SWIG_fail;
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 {
25153 resultobj = SWIG_From_int((int)(result));
25154 }
25155 return resultobj;
25156 fail:
25157 return NULL;
25158 }
25159
25160
25161 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25162 PyObject *resultobj;
25163 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25164 wxLongLong result;
25165 PyObject * obj0 = 0 ;
25166 char *kwnames[] = {
25167 (char *) "self", NULL
25168 };
25169
25170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25172 if (SWIG_arg_fail(1)) SWIG_fail;
25173 {
25174 PyThreadState* __tstate = wxPyBeginAllowThreads();
25175 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25176
25177 wxPyEndAllowThreads(__tstate);
25178 if (PyErr_Occurred()) SWIG_fail;
25179 }
25180 {
25181 PyObject *hi, *lo, *shifter, *shifted;
25182 hi = PyLong_FromLong( (&result)->GetHi() );
25183 lo = PyLong_FromLong( (&result)->GetLo() );
25184 shifter = PyLong_FromLong(32);
25185 shifted = PyNumber_Lshift(hi, shifter);
25186 resultobj = PyNumber_Or(shifted, lo);
25187 Py_DECREF(hi);
25188 Py_DECREF(lo);
25189 Py_DECREF(shifter);
25190 Py_DECREF(shifted);
25191 }
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj;
25200 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25201 wxLongLong result;
25202 PyObject * obj0 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "self", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(1)) SWIG_fail;
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25213
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 PyObject *hi, *lo, *shifter, *shifted;
25219 hi = PyLong_FromLong( (&result)->GetHi() );
25220 lo = PyLong_FromLong( (&result)->GetLo() );
25221 shifter = PyLong_FromLong(32);
25222 shifted = PyNumber_Lshift(hi, shifter);
25223 resultobj = PyNumber_Or(shifted, lo);
25224 Py_DECREF(hi);
25225 Py_DECREF(lo);
25226 Py_DECREF(shifter);
25227 Py_DECREF(shifted);
25228 }
25229 return resultobj;
25230 fail:
25231 return NULL;
25232 }
25233
25234
25235 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25236 PyObject *resultobj;
25237 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25238 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25239 wxString *arg2 = (wxString *) &arg2_defvalue ;
25240 wxString result;
25241 bool temp2 = false ;
25242 PyObject * obj0 = 0 ;
25243 PyObject * obj1 = 0 ;
25244 char *kwnames[] = {
25245 (char *) "self",(char *) "format", NULL
25246 };
25247
25248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25250 if (SWIG_arg_fail(1)) SWIG_fail;
25251 if (obj1) {
25252 {
25253 arg2 = wxString_in_helper(obj1);
25254 if (arg2 == NULL) SWIG_fail;
25255 temp2 = true;
25256 }
25257 }
25258 {
25259 PyThreadState* __tstate = wxPyBeginAllowThreads();
25260 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25261
25262 wxPyEndAllowThreads(__tstate);
25263 if (PyErr_Occurred()) SWIG_fail;
25264 }
25265 {
25266 #if wxUSE_UNICODE
25267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25268 #else
25269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25270 #endif
25271 }
25272 {
25273 if (temp2)
25274 delete arg2;
25275 }
25276 return resultobj;
25277 fail:
25278 {
25279 if (temp2)
25280 delete arg2;
25281 }
25282 return NULL;
25283 }
25284
25285
25286 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25287 PyObject *obj;
25288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25289 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25290 Py_INCREF(obj);
25291 return Py_BuildValue((char *)"");
25292 }
25293 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25294 PyObject *resultobj;
25295 int arg1 = (int) 0 ;
25296 int arg2 = (int) 0 ;
25297 int arg3 = (int) 0 ;
25298 int arg4 = (int) 0 ;
25299 wxDateSpan *result;
25300 PyObject * obj0 = 0 ;
25301 PyObject * obj1 = 0 ;
25302 PyObject * obj2 = 0 ;
25303 PyObject * obj3 = 0 ;
25304 char *kwnames[] = {
25305 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25306 };
25307
25308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25309 if (obj0) {
25310 {
25311 arg1 = (int)(SWIG_As_int(obj0));
25312 if (SWIG_arg_fail(1)) SWIG_fail;
25313 }
25314 }
25315 if (obj1) {
25316 {
25317 arg2 = (int)(SWIG_As_int(obj1));
25318 if (SWIG_arg_fail(2)) SWIG_fail;
25319 }
25320 }
25321 if (obj2) {
25322 {
25323 arg3 = (int)(SWIG_As_int(obj2));
25324 if (SWIG_arg_fail(3)) SWIG_fail;
25325 }
25326 }
25327 if (obj3) {
25328 {
25329 arg4 = (int)(SWIG_As_int(obj3));
25330 if (SWIG_arg_fail(4)) SWIG_fail;
25331 }
25332 }
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25336
25337 wxPyEndAllowThreads(__tstate);
25338 if (PyErr_Occurred()) SWIG_fail;
25339 }
25340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25341 return resultobj;
25342 fail:
25343 return NULL;
25344 }
25345
25346
25347 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25348 PyObject *resultobj;
25349 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25350 PyObject * obj0 = 0 ;
25351 char *kwnames[] = {
25352 (char *) "self", NULL
25353 };
25354
25355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25357 if (SWIG_arg_fail(1)) SWIG_fail;
25358 {
25359 PyThreadState* __tstate = wxPyBeginAllowThreads();
25360 delete arg1;
25361
25362 wxPyEndAllowThreads(__tstate);
25363 if (PyErr_Occurred()) SWIG_fail;
25364 }
25365 Py_INCREF(Py_None); resultobj = Py_None;
25366 return resultobj;
25367 fail:
25368 return NULL;
25369 }
25370
25371
25372 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25373 PyObject *resultobj;
25374 int arg1 ;
25375 wxDateSpan result;
25376 PyObject * obj0 = 0 ;
25377 char *kwnames[] = {
25378 (char *) "days", NULL
25379 };
25380
25381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25382 {
25383 arg1 = (int)(SWIG_As_int(obj0));
25384 if (SWIG_arg_fail(1)) SWIG_fail;
25385 }
25386 {
25387 PyThreadState* __tstate = wxPyBeginAllowThreads();
25388 result = wxDateSpan::Days(arg1);
25389
25390 wxPyEndAllowThreads(__tstate);
25391 if (PyErr_Occurred()) SWIG_fail;
25392 }
25393 {
25394 wxDateSpan * resultptr;
25395 resultptr = new wxDateSpan((wxDateSpan &)(result));
25396 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25397 }
25398 return resultobj;
25399 fail:
25400 return NULL;
25401 }
25402
25403
25404 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25405 PyObject *resultobj;
25406 wxDateSpan result;
25407 char *kwnames[] = {
25408 NULL
25409 };
25410
25411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25412 {
25413 PyThreadState* __tstate = wxPyBeginAllowThreads();
25414 result = wxDateSpan::Day();
25415
25416 wxPyEndAllowThreads(__tstate);
25417 if (PyErr_Occurred()) SWIG_fail;
25418 }
25419 {
25420 wxDateSpan * resultptr;
25421 resultptr = new wxDateSpan((wxDateSpan &)(result));
25422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25423 }
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25431 PyObject *resultobj;
25432 int arg1 ;
25433 wxDateSpan result;
25434 PyObject * obj0 = 0 ;
25435 char *kwnames[] = {
25436 (char *) "weeks", NULL
25437 };
25438
25439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25440 {
25441 arg1 = (int)(SWIG_As_int(obj0));
25442 if (SWIG_arg_fail(1)) SWIG_fail;
25443 }
25444 {
25445 PyThreadState* __tstate = wxPyBeginAllowThreads();
25446 result = wxDateSpan::Weeks(arg1);
25447
25448 wxPyEndAllowThreads(__tstate);
25449 if (PyErr_Occurred()) SWIG_fail;
25450 }
25451 {
25452 wxDateSpan * resultptr;
25453 resultptr = new wxDateSpan((wxDateSpan &)(result));
25454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25455 }
25456 return resultobj;
25457 fail:
25458 return NULL;
25459 }
25460
25461
25462 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25463 PyObject *resultobj;
25464 wxDateSpan result;
25465 char *kwnames[] = {
25466 NULL
25467 };
25468
25469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25470 {
25471 PyThreadState* __tstate = wxPyBeginAllowThreads();
25472 result = wxDateSpan::Week();
25473
25474 wxPyEndAllowThreads(__tstate);
25475 if (PyErr_Occurred()) SWIG_fail;
25476 }
25477 {
25478 wxDateSpan * resultptr;
25479 resultptr = new wxDateSpan((wxDateSpan &)(result));
25480 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25481 }
25482 return resultobj;
25483 fail:
25484 return NULL;
25485 }
25486
25487
25488 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25489 PyObject *resultobj;
25490 int arg1 ;
25491 wxDateSpan result;
25492 PyObject * obj0 = 0 ;
25493 char *kwnames[] = {
25494 (char *) "mon", NULL
25495 };
25496
25497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25498 {
25499 arg1 = (int)(SWIG_As_int(obj0));
25500 if (SWIG_arg_fail(1)) SWIG_fail;
25501 }
25502 {
25503 PyThreadState* __tstate = wxPyBeginAllowThreads();
25504 result = wxDateSpan::Months(arg1);
25505
25506 wxPyEndAllowThreads(__tstate);
25507 if (PyErr_Occurred()) SWIG_fail;
25508 }
25509 {
25510 wxDateSpan * resultptr;
25511 resultptr = new wxDateSpan((wxDateSpan &)(result));
25512 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25513 }
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25521 PyObject *resultobj;
25522 wxDateSpan result;
25523 char *kwnames[] = {
25524 NULL
25525 };
25526
25527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25528 {
25529 PyThreadState* __tstate = wxPyBeginAllowThreads();
25530 result = wxDateSpan::Month();
25531
25532 wxPyEndAllowThreads(__tstate);
25533 if (PyErr_Occurred()) SWIG_fail;
25534 }
25535 {
25536 wxDateSpan * resultptr;
25537 resultptr = new wxDateSpan((wxDateSpan &)(result));
25538 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25539 }
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj;
25548 int arg1 ;
25549 wxDateSpan result;
25550 PyObject * obj0 = 0 ;
25551 char *kwnames[] = {
25552 (char *) "years", NULL
25553 };
25554
25555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25556 {
25557 arg1 = (int)(SWIG_As_int(obj0));
25558 if (SWIG_arg_fail(1)) SWIG_fail;
25559 }
25560 {
25561 PyThreadState* __tstate = wxPyBeginAllowThreads();
25562 result = wxDateSpan::Years(arg1);
25563
25564 wxPyEndAllowThreads(__tstate);
25565 if (PyErr_Occurred()) SWIG_fail;
25566 }
25567 {
25568 wxDateSpan * resultptr;
25569 resultptr = new wxDateSpan((wxDateSpan &)(result));
25570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25571 }
25572 return resultobj;
25573 fail:
25574 return NULL;
25575 }
25576
25577
25578 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25579 PyObject *resultobj;
25580 wxDateSpan result;
25581 char *kwnames[] = {
25582 NULL
25583 };
25584
25585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25586 {
25587 PyThreadState* __tstate = wxPyBeginAllowThreads();
25588 result = wxDateSpan::Year();
25589
25590 wxPyEndAllowThreads(__tstate);
25591 if (PyErr_Occurred()) SWIG_fail;
25592 }
25593 {
25594 wxDateSpan * resultptr;
25595 resultptr = new wxDateSpan((wxDateSpan &)(result));
25596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25597 }
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25605 PyObject *resultobj;
25606 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25607 int arg2 ;
25608 wxDateSpan *result;
25609 PyObject * obj0 = 0 ;
25610 PyObject * obj1 = 0 ;
25611 char *kwnames[] = {
25612 (char *) "self",(char *) "n", NULL
25613 };
25614
25615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25617 if (SWIG_arg_fail(1)) SWIG_fail;
25618 {
25619 arg2 = (int)(SWIG_As_int(obj1));
25620 if (SWIG_arg_fail(2)) SWIG_fail;
25621 }
25622 {
25623 PyThreadState* __tstate = wxPyBeginAllowThreads();
25624 {
25625 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25626 result = (wxDateSpan *) &_result_ref;
25627 }
25628
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25640 PyObject *resultobj;
25641 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25642 int arg2 ;
25643 wxDateSpan *result;
25644 PyObject * obj0 = 0 ;
25645 PyObject * obj1 = 0 ;
25646 char *kwnames[] = {
25647 (char *) "self",(char *) "n", NULL
25648 };
25649
25650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25652 if (SWIG_arg_fail(1)) SWIG_fail;
25653 {
25654 arg2 = (int)(SWIG_As_int(obj1));
25655 if (SWIG_arg_fail(2)) SWIG_fail;
25656 }
25657 {
25658 PyThreadState* __tstate = wxPyBeginAllowThreads();
25659 {
25660 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25661 result = (wxDateSpan *) &_result_ref;
25662 }
25663
25664 wxPyEndAllowThreads(__tstate);
25665 if (PyErr_Occurred()) SWIG_fail;
25666 }
25667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25675 PyObject *resultobj;
25676 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25677 int arg2 ;
25678 wxDateSpan *result;
25679 PyObject * obj0 = 0 ;
25680 PyObject * obj1 = 0 ;
25681 char *kwnames[] = {
25682 (char *) "self",(char *) "n", NULL
25683 };
25684
25685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25687 if (SWIG_arg_fail(1)) SWIG_fail;
25688 {
25689 arg2 = (int)(SWIG_As_int(obj1));
25690 if (SWIG_arg_fail(2)) SWIG_fail;
25691 }
25692 {
25693 PyThreadState* __tstate = wxPyBeginAllowThreads();
25694 {
25695 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25696 result = (wxDateSpan *) &_result_ref;
25697 }
25698
25699 wxPyEndAllowThreads(__tstate);
25700 if (PyErr_Occurred()) SWIG_fail;
25701 }
25702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25703 return resultobj;
25704 fail:
25705 return NULL;
25706 }
25707
25708
25709 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25710 PyObject *resultobj;
25711 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25712 int arg2 ;
25713 wxDateSpan *result;
25714 PyObject * obj0 = 0 ;
25715 PyObject * obj1 = 0 ;
25716 char *kwnames[] = {
25717 (char *) "self",(char *) "n", NULL
25718 };
25719
25720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25722 if (SWIG_arg_fail(1)) SWIG_fail;
25723 {
25724 arg2 = (int)(SWIG_As_int(obj1));
25725 if (SWIG_arg_fail(2)) SWIG_fail;
25726 }
25727 {
25728 PyThreadState* __tstate = wxPyBeginAllowThreads();
25729 {
25730 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25731 result = (wxDateSpan *) &_result_ref;
25732 }
25733
25734 wxPyEndAllowThreads(__tstate);
25735 if (PyErr_Occurred()) SWIG_fail;
25736 }
25737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25738 return resultobj;
25739 fail:
25740 return NULL;
25741 }
25742
25743
25744 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25745 PyObject *resultobj;
25746 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25747 int result;
25748 PyObject * obj0 = 0 ;
25749 char *kwnames[] = {
25750 (char *) "self", NULL
25751 };
25752
25753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25755 if (SWIG_arg_fail(1)) SWIG_fail;
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 result = (int)((wxDateSpan const *)arg1)->GetYears();
25759
25760 wxPyEndAllowThreads(__tstate);
25761 if (PyErr_Occurred()) SWIG_fail;
25762 }
25763 {
25764 resultobj = SWIG_From_int((int)(result));
25765 }
25766 return resultobj;
25767 fail:
25768 return NULL;
25769 }
25770
25771
25772 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25773 PyObject *resultobj;
25774 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25775 int result;
25776 PyObject * obj0 = 0 ;
25777 char *kwnames[] = {
25778 (char *) "self", NULL
25779 };
25780
25781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25783 if (SWIG_arg_fail(1)) SWIG_fail;
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25787
25788 wxPyEndAllowThreads(__tstate);
25789 if (PyErr_Occurred()) SWIG_fail;
25790 }
25791 {
25792 resultobj = SWIG_From_int((int)(result));
25793 }
25794 return resultobj;
25795 fail:
25796 return NULL;
25797 }
25798
25799
25800 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25801 PyObject *resultobj;
25802 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25803 int result;
25804 PyObject * obj0 = 0 ;
25805 char *kwnames[] = {
25806 (char *) "self", NULL
25807 };
25808
25809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25811 if (SWIG_arg_fail(1)) SWIG_fail;
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25815
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 {
25820 resultobj = SWIG_From_int((int)(result));
25821 }
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25829 PyObject *resultobj;
25830 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25831 int result;
25832 PyObject * obj0 = 0 ;
25833 char *kwnames[] = {
25834 (char *) "self", NULL
25835 };
25836
25837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25839 if (SWIG_arg_fail(1)) SWIG_fail;
25840 {
25841 PyThreadState* __tstate = wxPyBeginAllowThreads();
25842 result = (int)((wxDateSpan const *)arg1)->GetDays();
25843
25844 wxPyEndAllowThreads(__tstate);
25845 if (PyErr_Occurred()) SWIG_fail;
25846 }
25847 {
25848 resultobj = SWIG_From_int((int)(result));
25849 }
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj;
25858 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25859 int result;
25860 PyObject * obj0 = 0 ;
25861 char *kwnames[] = {
25862 (char *) "self", NULL
25863 };
25864
25865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25867 if (SWIG_arg_fail(1)) SWIG_fail;
25868 {
25869 PyThreadState* __tstate = wxPyBeginAllowThreads();
25870 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25871
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 {
25876 resultobj = SWIG_From_int((int)(result));
25877 }
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25885 PyObject *resultobj;
25886 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25887 wxDateSpan *arg2 = 0 ;
25888 wxDateSpan *result;
25889 PyObject * obj0 = 0 ;
25890 PyObject * obj1 = 0 ;
25891 char *kwnames[] = {
25892 (char *) "self",(char *) "other", NULL
25893 };
25894
25895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25897 if (SWIG_arg_fail(1)) SWIG_fail;
25898 {
25899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25900 if (SWIG_arg_fail(2)) SWIG_fail;
25901 if (arg2 == NULL) {
25902 SWIG_null_ref("wxDateSpan");
25903 }
25904 if (SWIG_arg_fail(2)) SWIG_fail;
25905 }
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 {
25909 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25910 result = (wxDateSpan *) &_result_ref;
25911 }
25912
25913 wxPyEndAllowThreads(__tstate);
25914 if (PyErr_Occurred()) SWIG_fail;
25915 }
25916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25917 return resultobj;
25918 fail:
25919 return NULL;
25920 }
25921
25922
25923 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25924 PyObject *resultobj;
25925 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25926 wxDateSpan *arg2 = 0 ;
25927 wxDateSpan *result;
25928 PyObject * obj0 = 0 ;
25929 PyObject * obj1 = 0 ;
25930 char *kwnames[] = {
25931 (char *) "self",(char *) "other", NULL
25932 };
25933
25934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25936 if (SWIG_arg_fail(1)) SWIG_fail;
25937 {
25938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25939 if (SWIG_arg_fail(2)) SWIG_fail;
25940 if (arg2 == NULL) {
25941 SWIG_null_ref("wxDateSpan");
25942 }
25943 if (SWIG_arg_fail(2)) SWIG_fail;
25944 }
25945 {
25946 PyThreadState* __tstate = wxPyBeginAllowThreads();
25947 {
25948 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25949 result = (wxDateSpan *) &_result_ref;
25950 }
25951
25952 wxPyEndAllowThreads(__tstate);
25953 if (PyErr_Occurred()) SWIG_fail;
25954 }
25955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25956 return resultobj;
25957 fail:
25958 return NULL;
25959 }
25960
25961
25962 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25963 PyObject *resultobj;
25964 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25965 wxDateSpan *result;
25966 PyObject * obj0 = 0 ;
25967 char *kwnames[] = {
25968 (char *) "self", NULL
25969 };
25970
25971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25973 if (SWIG_arg_fail(1)) SWIG_fail;
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 {
25977 wxDateSpan &_result_ref = (arg1)->Neg();
25978 result = (wxDateSpan *) &_result_ref;
25979 }
25980
25981 wxPyEndAllowThreads(__tstate);
25982 if (PyErr_Occurred()) SWIG_fail;
25983 }
25984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25985 return resultobj;
25986 fail:
25987 return NULL;
25988 }
25989
25990
25991 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25992 PyObject *resultobj;
25993 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25994 int arg2 ;
25995 wxDateSpan *result;
25996 PyObject * obj0 = 0 ;
25997 PyObject * obj1 = 0 ;
25998 char *kwnames[] = {
25999 (char *) "self",(char *) "factor", NULL
26000 };
26001
26002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26004 if (SWIG_arg_fail(1)) SWIG_fail;
26005 {
26006 arg2 = (int)(SWIG_As_int(obj1));
26007 if (SWIG_arg_fail(2)) SWIG_fail;
26008 }
26009 {
26010 PyThreadState* __tstate = wxPyBeginAllowThreads();
26011 {
26012 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26013 result = (wxDateSpan *) &_result_ref;
26014 }
26015
26016 wxPyEndAllowThreads(__tstate);
26017 if (PyErr_Occurred()) SWIG_fail;
26018 }
26019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26020 return resultobj;
26021 fail:
26022 return NULL;
26023 }
26024
26025
26026 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26027 PyObject *resultobj;
26028 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26029 wxDateSpan *arg2 = 0 ;
26030 wxDateSpan *result;
26031 PyObject * obj0 = 0 ;
26032 PyObject * obj1 = 0 ;
26033 char *kwnames[] = {
26034 (char *) "self",(char *) "other", NULL
26035 };
26036
26037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26039 if (SWIG_arg_fail(1)) SWIG_fail;
26040 {
26041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26042 if (SWIG_arg_fail(2)) SWIG_fail;
26043 if (arg2 == NULL) {
26044 SWIG_null_ref("wxDateSpan");
26045 }
26046 if (SWIG_arg_fail(2)) SWIG_fail;
26047 }
26048 {
26049 PyThreadState* __tstate = wxPyBeginAllowThreads();
26050 {
26051 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26052 result = (wxDateSpan *) &_result_ref;
26053 }
26054
26055 wxPyEndAllowThreads(__tstate);
26056 if (PyErr_Occurred()) SWIG_fail;
26057 }
26058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26059 return resultobj;
26060 fail:
26061 return NULL;
26062 }
26063
26064
26065 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26066 PyObject *resultobj;
26067 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26068 wxDateSpan *arg2 = 0 ;
26069 wxDateSpan *result;
26070 PyObject * obj0 = 0 ;
26071 PyObject * obj1 = 0 ;
26072 char *kwnames[] = {
26073 (char *) "self",(char *) "other", NULL
26074 };
26075
26076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26078 if (SWIG_arg_fail(1)) SWIG_fail;
26079 {
26080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26081 if (SWIG_arg_fail(2)) SWIG_fail;
26082 if (arg2 == NULL) {
26083 SWIG_null_ref("wxDateSpan");
26084 }
26085 if (SWIG_arg_fail(2)) SWIG_fail;
26086 }
26087 {
26088 PyThreadState* __tstate = wxPyBeginAllowThreads();
26089 {
26090 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26091 result = (wxDateSpan *) &_result_ref;
26092 }
26093
26094 wxPyEndAllowThreads(__tstate);
26095 if (PyErr_Occurred()) SWIG_fail;
26096 }
26097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26105 PyObject *resultobj;
26106 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26107 wxDateSpan *result;
26108 PyObject * obj0 = 0 ;
26109 char *kwnames[] = {
26110 (char *) "self", NULL
26111 };
26112
26113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26115 if (SWIG_arg_fail(1)) SWIG_fail;
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 {
26119 wxDateSpan &_result_ref = (arg1)->operator -();
26120 result = (wxDateSpan *) &_result_ref;
26121 }
26122
26123 wxPyEndAllowThreads(__tstate);
26124 if (PyErr_Occurred()) SWIG_fail;
26125 }
26126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26127 return resultobj;
26128 fail:
26129 return NULL;
26130 }
26131
26132
26133 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26134 PyObject *resultobj;
26135 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26136 int arg2 ;
26137 wxDateSpan *result;
26138 PyObject * obj0 = 0 ;
26139 PyObject * obj1 = 0 ;
26140 char *kwnames[] = {
26141 (char *) "self",(char *) "factor", NULL
26142 };
26143
26144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26146 if (SWIG_arg_fail(1)) SWIG_fail;
26147 {
26148 arg2 = (int)(SWIG_As_int(obj1));
26149 if (SWIG_arg_fail(2)) SWIG_fail;
26150 }
26151 {
26152 PyThreadState* __tstate = wxPyBeginAllowThreads();
26153 {
26154 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26155 result = (wxDateSpan *) &_result_ref;
26156 }
26157
26158 wxPyEndAllowThreads(__tstate);
26159 if (PyErr_Occurred()) SWIG_fail;
26160 }
26161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26162 return resultobj;
26163 fail:
26164 return NULL;
26165 }
26166
26167
26168 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26169 PyObject *resultobj;
26170 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26171 wxDateSpan *arg2 = 0 ;
26172 wxDateSpan result;
26173 PyObject * obj0 = 0 ;
26174 PyObject * obj1 = 0 ;
26175 char *kwnames[] = {
26176 (char *) "self",(char *) "other", NULL
26177 };
26178
26179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26181 if (SWIG_arg_fail(1)) SWIG_fail;
26182 {
26183 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26184 if (SWIG_arg_fail(2)) SWIG_fail;
26185 if (arg2 == NULL) {
26186 SWIG_null_ref("wxDateSpan");
26187 }
26188 if (SWIG_arg_fail(2)) SWIG_fail;
26189 }
26190 {
26191 PyThreadState* __tstate = wxPyBeginAllowThreads();
26192 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26193
26194 wxPyEndAllowThreads(__tstate);
26195 if (PyErr_Occurred()) SWIG_fail;
26196 }
26197 {
26198 wxDateSpan * resultptr;
26199 resultptr = new wxDateSpan((wxDateSpan &)(result));
26200 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26201 }
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26209 PyObject *resultobj;
26210 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26211 wxDateSpan *arg2 = 0 ;
26212 wxDateSpan result;
26213 PyObject * obj0 = 0 ;
26214 PyObject * obj1 = 0 ;
26215 char *kwnames[] = {
26216 (char *) "self",(char *) "other", NULL
26217 };
26218
26219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26221 if (SWIG_arg_fail(1)) SWIG_fail;
26222 {
26223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26224 if (SWIG_arg_fail(2)) SWIG_fail;
26225 if (arg2 == NULL) {
26226 SWIG_null_ref("wxDateSpan");
26227 }
26228 if (SWIG_arg_fail(2)) SWIG_fail;
26229 }
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26233
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 {
26238 wxDateSpan * resultptr;
26239 resultptr = new wxDateSpan((wxDateSpan &)(result));
26240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26241 }
26242 return resultobj;
26243 fail:
26244 return NULL;
26245 }
26246
26247
26248 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26249 PyObject *resultobj;
26250 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26251 int arg2 ;
26252 wxDateSpan result;
26253 PyObject * obj0 = 0 ;
26254 PyObject * obj1 = 0 ;
26255 char *kwnames[] = {
26256 (char *) "self",(char *) "n", NULL
26257 };
26258
26259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26261 if (SWIG_arg_fail(1)) SWIG_fail;
26262 {
26263 arg2 = (int)(SWIG_As_int(obj1));
26264 if (SWIG_arg_fail(2)) SWIG_fail;
26265 }
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 result = wxDateSpan___mul__(arg1,arg2);
26269
26270 wxPyEndAllowThreads(__tstate);
26271 if (PyErr_Occurred()) SWIG_fail;
26272 }
26273 {
26274 wxDateSpan * resultptr;
26275 resultptr = new wxDateSpan((wxDateSpan &)(result));
26276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26277 }
26278 return resultobj;
26279 fail:
26280 return NULL;
26281 }
26282
26283
26284 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26285 PyObject *resultobj;
26286 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26287 int arg2 ;
26288 wxDateSpan result;
26289 PyObject * obj0 = 0 ;
26290 PyObject * obj1 = 0 ;
26291 char *kwnames[] = {
26292 (char *) "self",(char *) "n", NULL
26293 };
26294
26295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26297 if (SWIG_arg_fail(1)) SWIG_fail;
26298 {
26299 arg2 = (int)(SWIG_As_int(obj1));
26300 if (SWIG_arg_fail(2)) SWIG_fail;
26301 }
26302 {
26303 PyThreadState* __tstate = wxPyBeginAllowThreads();
26304 result = wxDateSpan___rmul__(arg1,arg2);
26305
26306 wxPyEndAllowThreads(__tstate);
26307 if (PyErr_Occurred()) SWIG_fail;
26308 }
26309 {
26310 wxDateSpan * resultptr;
26311 resultptr = new wxDateSpan((wxDateSpan &)(result));
26312 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26313 }
26314 return resultobj;
26315 fail:
26316 return NULL;
26317 }
26318
26319
26320 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26321 PyObject *resultobj;
26322 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26323 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26324 bool result;
26325 PyObject * obj0 = 0 ;
26326 PyObject * obj1 = 0 ;
26327 char *kwnames[] = {
26328 (char *) "self",(char *) "other", NULL
26329 };
26330
26331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26333 if (SWIG_arg_fail(1)) SWIG_fail;
26334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26335 if (SWIG_arg_fail(2)) SWIG_fail;
26336 {
26337 PyThreadState* __tstate = wxPyBeginAllowThreads();
26338 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26339
26340 wxPyEndAllowThreads(__tstate);
26341 if (PyErr_Occurred()) SWIG_fail;
26342 }
26343 {
26344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26345 }
26346 return resultobj;
26347 fail:
26348 return NULL;
26349 }
26350
26351
26352 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26353 PyObject *resultobj;
26354 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26355 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26356 bool result;
26357 PyObject * obj0 = 0 ;
26358 PyObject * obj1 = 0 ;
26359 char *kwnames[] = {
26360 (char *) "self",(char *) "other", NULL
26361 };
26362
26363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26365 if (SWIG_arg_fail(1)) SWIG_fail;
26366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26367 if (SWIG_arg_fail(2)) SWIG_fail;
26368 {
26369 PyThreadState* __tstate = wxPyBeginAllowThreads();
26370 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26371
26372 wxPyEndAllowThreads(__tstate);
26373 if (PyErr_Occurred()) SWIG_fail;
26374 }
26375 {
26376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26377 }
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26385 PyObject *obj;
26386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26387 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26388 Py_INCREF(obj);
26389 return Py_BuildValue((char *)"");
26390 }
26391 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26392 PyObject *resultobj;
26393 long result;
26394 char *kwnames[] = {
26395 NULL
26396 };
26397
26398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26399 {
26400 PyThreadState* __tstate = wxPyBeginAllowThreads();
26401 result = (long)wxGetLocalTime();
26402
26403 wxPyEndAllowThreads(__tstate);
26404 if (PyErr_Occurred()) SWIG_fail;
26405 }
26406 {
26407 resultobj = SWIG_From_long((long)(result));
26408 }
26409 return resultobj;
26410 fail:
26411 return NULL;
26412 }
26413
26414
26415 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj;
26417 long result;
26418 char *kwnames[] = {
26419 NULL
26420 };
26421
26422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26423 {
26424 PyThreadState* __tstate = wxPyBeginAllowThreads();
26425 result = (long)wxGetUTCTime();
26426
26427 wxPyEndAllowThreads(__tstate);
26428 if (PyErr_Occurred()) SWIG_fail;
26429 }
26430 {
26431 resultobj = SWIG_From_long((long)(result));
26432 }
26433 return resultobj;
26434 fail:
26435 return NULL;
26436 }
26437
26438
26439 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26440 PyObject *resultobj;
26441 long result;
26442 char *kwnames[] = {
26443 NULL
26444 };
26445
26446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26447 {
26448 PyThreadState* __tstate = wxPyBeginAllowThreads();
26449 result = (long)wxGetCurrentTime();
26450
26451 wxPyEndAllowThreads(__tstate);
26452 if (PyErr_Occurred()) SWIG_fail;
26453 }
26454 {
26455 resultobj = SWIG_From_long((long)(result));
26456 }
26457 return resultobj;
26458 fail:
26459 return NULL;
26460 }
26461
26462
26463 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26464 PyObject *resultobj;
26465 wxLongLong result;
26466 char *kwnames[] = {
26467 NULL
26468 };
26469
26470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26471 {
26472 PyThreadState* __tstate = wxPyBeginAllowThreads();
26473 result = wxGetLocalTimeMillis();
26474
26475 wxPyEndAllowThreads(__tstate);
26476 if (PyErr_Occurred()) SWIG_fail;
26477 }
26478 {
26479 PyObject *hi, *lo, *shifter, *shifted;
26480 hi = PyLong_FromLong( (&result)->GetHi() );
26481 lo = PyLong_FromLong( (&result)->GetLo() );
26482 shifter = PyLong_FromLong(32);
26483 shifted = PyNumber_Lshift(hi, shifter);
26484 resultobj = PyNumber_Or(shifted, lo);
26485 Py_DECREF(hi);
26486 Py_DECREF(lo);
26487 Py_DECREF(shifter);
26488 Py_DECREF(shifted);
26489 }
26490 return resultobj;
26491 fail:
26492 return NULL;
26493 }
26494
26495
26496 static int _wrap_DefaultDateTime_set(PyObject *) {
26497 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26498 return 1;
26499 }
26500
26501
26502 static PyObject *_wrap_DefaultDateTime_get(void) {
26503 PyObject *pyobj;
26504
26505 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26506 return pyobj;
26507 }
26508
26509
26510 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26511 PyObject *resultobj;
26512 wxDataFormatId arg1 ;
26513 wxDataFormat *result;
26514 PyObject * obj0 = 0 ;
26515 char *kwnames[] = {
26516 (char *) "type", NULL
26517 };
26518
26519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26520 {
26521 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26522 if (SWIG_arg_fail(1)) SWIG_fail;
26523 }
26524 {
26525 PyThreadState* __tstate = wxPyBeginAllowThreads();
26526 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26527
26528 wxPyEndAllowThreads(__tstate);
26529 if (PyErr_Occurred()) SWIG_fail;
26530 }
26531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26532 return resultobj;
26533 fail:
26534 return NULL;
26535 }
26536
26537
26538 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26539 PyObject *resultobj;
26540 wxString *arg1 = 0 ;
26541 wxDataFormat *result;
26542 bool temp1 = false ;
26543 PyObject * obj0 = 0 ;
26544 char *kwnames[] = {
26545 (char *) "format", NULL
26546 };
26547
26548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26549 {
26550 arg1 = wxString_in_helper(obj0);
26551 if (arg1 == NULL) SWIG_fail;
26552 temp1 = true;
26553 }
26554 {
26555 PyThreadState* __tstate = wxPyBeginAllowThreads();
26556 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26557
26558 wxPyEndAllowThreads(__tstate);
26559 if (PyErr_Occurred()) SWIG_fail;
26560 }
26561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26562 {
26563 if (temp1)
26564 delete arg1;
26565 }
26566 return resultobj;
26567 fail:
26568 {
26569 if (temp1)
26570 delete arg1;
26571 }
26572 return NULL;
26573 }
26574
26575
26576 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26577 PyObject *resultobj;
26578 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26579 PyObject * obj0 = 0 ;
26580 char *kwnames[] = {
26581 (char *) "self", NULL
26582 };
26583
26584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26586 if (SWIG_arg_fail(1)) SWIG_fail;
26587 {
26588 PyThreadState* __tstate = wxPyBeginAllowThreads();
26589 delete arg1;
26590
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 Py_INCREF(Py_None); resultobj = Py_None;
26595 return resultobj;
26596 fail:
26597 return NULL;
26598 }
26599
26600
26601 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26602 PyObject *resultobj;
26603 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26604 wxDataFormatId arg2 ;
26605 bool result;
26606 PyObject * obj0 = 0 ;
26607 PyObject * obj1 = 0 ;
26608
26609 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26611 if (SWIG_arg_fail(1)) SWIG_fail;
26612 {
26613 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26614 if (SWIG_arg_fail(2)) SWIG_fail;
26615 }
26616 {
26617 PyThreadState* __tstate = wxPyBeginAllowThreads();
26618 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26619
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 {
26624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26625 }
26626 return resultobj;
26627 fail:
26628 return NULL;
26629 }
26630
26631
26632 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26633 PyObject *resultobj;
26634 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26635 wxDataFormatId arg2 ;
26636 bool result;
26637 PyObject * obj0 = 0 ;
26638 PyObject * obj1 = 0 ;
26639
26640 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26642 if (SWIG_arg_fail(1)) SWIG_fail;
26643 {
26644 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26645 if (SWIG_arg_fail(2)) SWIG_fail;
26646 }
26647 {
26648 PyThreadState* __tstate = wxPyBeginAllowThreads();
26649 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26650
26651 wxPyEndAllowThreads(__tstate);
26652 if (PyErr_Occurred()) SWIG_fail;
26653 }
26654 {
26655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26656 }
26657 return resultobj;
26658 fail:
26659 return NULL;
26660 }
26661
26662
26663 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26664 PyObject *resultobj;
26665 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26666 wxDataFormat *arg2 = 0 ;
26667 bool result;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670
26671 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26673 if (SWIG_arg_fail(1)) SWIG_fail;
26674 {
26675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26676 if (SWIG_arg_fail(2)) SWIG_fail;
26677 if (arg2 == NULL) {
26678 SWIG_null_ref("wxDataFormat");
26679 }
26680 if (SWIG_arg_fail(2)) SWIG_fail;
26681 }
26682 {
26683 PyThreadState* __tstate = wxPyBeginAllowThreads();
26684 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26685
26686 wxPyEndAllowThreads(__tstate);
26687 if (PyErr_Occurred()) SWIG_fail;
26688 }
26689 {
26690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26691 }
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26699 int argc;
26700 PyObject *argv[3];
26701 int ii;
26702
26703 argc = PyObject_Length(args);
26704 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26705 argv[ii] = PyTuple_GetItem(args,ii);
26706 }
26707 if (argc == 2) {
26708 int _v;
26709 {
26710 void *ptr;
26711 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26712 _v = 0;
26713 PyErr_Clear();
26714 } else {
26715 _v = 1;
26716 }
26717 }
26718 if (_v) {
26719 {
26720 void *ptr = 0;
26721 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26722 _v = 0;
26723 PyErr_Clear();
26724 } else {
26725 _v = (ptr != 0);
26726 }
26727 }
26728 if (_v) {
26729 return _wrap_DataFormat___eq____SWIG_1(self,args);
26730 }
26731 }
26732 }
26733 if (argc == 2) {
26734 int _v;
26735 {
26736 void *ptr;
26737 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26738 _v = 0;
26739 PyErr_Clear();
26740 } else {
26741 _v = 1;
26742 }
26743 }
26744 if (_v) {
26745 _v = SWIG_Check_int(argv[1]);
26746 if (_v) {
26747 return _wrap_DataFormat___eq____SWIG_0(self,args);
26748 }
26749 }
26750 }
26751
26752 Py_INCREF(Py_NotImplemented);
26753 return Py_NotImplemented;
26754 }
26755
26756
26757 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26758 PyObject *resultobj;
26759 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26760 wxDataFormat *arg2 = 0 ;
26761 bool result;
26762 PyObject * obj0 = 0 ;
26763 PyObject * obj1 = 0 ;
26764
26765 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26767 if (SWIG_arg_fail(1)) SWIG_fail;
26768 {
26769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26770 if (SWIG_arg_fail(2)) SWIG_fail;
26771 if (arg2 == NULL) {
26772 SWIG_null_ref("wxDataFormat");
26773 }
26774 if (SWIG_arg_fail(2)) SWIG_fail;
26775 }
26776 {
26777 PyThreadState* __tstate = wxPyBeginAllowThreads();
26778 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26779
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 {
26784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26785 }
26786 return resultobj;
26787 fail:
26788 return NULL;
26789 }
26790
26791
26792 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26793 int argc;
26794 PyObject *argv[3];
26795 int ii;
26796
26797 argc = PyObject_Length(args);
26798 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26799 argv[ii] = PyTuple_GetItem(args,ii);
26800 }
26801 if (argc == 2) {
26802 int _v;
26803 {
26804 void *ptr;
26805 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26806 _v = 0;
26807 PyErr_Clear();
26808 } else {
26809 _v = 1;
26810 }
26811 }
26812 if (_v) {
26813 {
26814 void *ptr = 0;
26815 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26816 _v = 0;
26817 PyErr_Clear();
26818 } else {
26819 _v = (ptr != 0);
26820 }
26821 }
26822 if (_v) {
26823 return _wrap_DataFormat___ne____SWIG_1(self,args);
26824 }
26825 }
26826 }
26827 if (argc == 2) {
26828 int _v;
26829 {
26830 void *ptr;
26831 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26832 _v = 0;
26833 PyErr_Clear();
26834 } else {
26835 _v = 1;
26836 }
26837 }
26838 if (_v) {
26839 _v = SWIG_Check_int(argv[1]);
26840 if (_v) {
26841 return _wrap_DataFormat___ne____SWIG_0(self,args);
26842 }
26843 }
26844 }
26845
26846 Py_INCREF(Py_NotImplemented);
26847 return Py_NotImplemented;
26848 }
26849
26850
26851 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26852 PyObject *resultobj;
26853 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26854 wxDataFormatId arg2 ;
26855 PyObject * obj0 = 0 ;
26856 PyObject * obj1 = 0 ;
26857 char *kwnames[] = {
26858 (char *) "self",(char *) "format", NULL
26859 };
26860
26861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26863 if (SWIG_arg_fail(1)) SWIG_fail;
26864 {
26865 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26866 if (SWIG_arg_fail(2)) SWIG_fail;
26867 }
26868 {
26869 PyThreadState* __tstate = wxPyBeginAllowThreads();
26870 (arg1)->SetType((wxDataFormatId )arg2);
26871
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 Py_INCREF(Py_None); resultobj = Py_None;
26876 return resultobj;
26877 fail:
26878 return NULL;
26879 }
26880
26881
26882 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26883 PyObject *resultobj;
26884 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26885 wxDataFormatId result;
26886 PyObject * obj0 = 0 ;
26887 char *kwnames[] = {
26888 (char *) "self", NULL
26889 };
26890
26891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26893 if (SWIG_arg_fail(1)) SWIG_fail;
26894 {
26895 PyThreadState* __tstate = wxPyBeginAllowThreads();
26896 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26897
26898 wxPyEndAllowThreads(__tstate);
26899 if (PyErr_Occurred()) SWIG_fail;
26900 }
26901 resultobj = SWIG_From_int((result));
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26909 PyObject *resultobj;
26910 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26911 wxString result;
26912 PyObject * obj0 = 0 ;
26913 char *kwnames[] = {
26914 (char *) "self", NULL
26915 };
26916
26917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26919 if (SWIG_arg_fail(1)) SWIG_fail;
26920 {
26921 PyThreadState* __tstate = wxPyBeginAllowThreads();
26922 result = ((wxDataFormat const *)arg1)->GetId();
26923
26924 wxPyEndAllowThreads(__tstate);
26925 if (PyErr_Occurred()) SWIG_fail;
26926 }
26927 {
26928 #if wxUSE_UNICODE
26929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26930 #else
26931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26932 #endif
26933 }
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26941 PyObject *resultobj;
26942 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26943 wxString *arg2 = 0 ;
26944 bool temp2 = false ;
26945 PyObject * obj0 = 0 ;
26946 PyObject * obj1 = 0 ;
26947 char *kwnames[] = {
26948 (char *) "self",(char *) "format", NULL
26949 };
26950
26951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26953 if (SWIG_arg_fail(1)) SWIG_fail;
26954 {
26955 arg2 = wxString_in_helper(obj1);
26956 if (arg2 == NULL) SWIG_fail;
26957 temp2 = true;
26958 }
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 (arg1)->SetId((wxString const &)*arg2);
26962
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 Py_INCREF(Py_None); resultobj = Py_None;
26967 {
26968 if (temp2)
26969 delete arg2;
26970 }
26971 return resultobj;
26972 fail:
26973 {
26974 if (temp2)
26975 delete arg2;
26976 }
26977 return NULL;
26978 }
26979
26980
26981 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26982 PyObject *obj;
26983 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26984 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26985 Py_INCREF(obj);
26986 return Py_BuildValue((char *)"");
26987 }
26988 static int _wrap_FormatInvalid_set(PyObject *) {
26989 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26990 return 1;
26991 }
26992
26993
26994 static PyObject *_wrap_FormatInvalid_get(void) {
26995 PyObject *pyobj;
26996
26997 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26998 return pyobj;
26999 }
27000
27001
27002 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27003 PyObject *resultobj;
27004 wxDataObject *arg1 = (wxDataObject *) 0 ;
27005 PyObject * obj0 = 0 ;
27006 char *kwnames[] = {
27007 (char *) "self", NULL
27008 };
27009
27010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27012 if (SWIG_arg_fail(1)) SWIG_fail;
27013 {
27014 PyThreadState* __tstate = wxPyBeginAllowThreads();
27015 delete arg1;
27016
27017 wxPyEndAllowThreads(__tstate);
27018 if (PyErr_Occurred()) SWIG_fail;
27019 }
27020 Py_INCREF(Py_None); resultobj = Py_None;
27021 return resultobj;
27022 fail:
27023 return NULL;
27024 }
27025
27026
27027 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27028 PyObject *resultobj;
27029 wxDataObject *arg1 = (wxDataObject *) 0 ;
27030 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27031 SwigValueWrapper<wxDataFormat > result;
27032 PyObject * obj0 = 0 ;
27033 PyObject * obj1 = 0 ;
27034 char *kwnames[] = {
27035 (char *) "self",(char *) "dir", NULL
27036 };
27037
27038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27040 if (SWIG_arg_fail(1)) SWIG_fail;
27041 if (obj1) {
27042 {
27043 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27044 if (SWIG_arg_fail(2)) SWIG_fail;
27045 }
27046 }
27047 {
27048 PyThreadState* __tstate = wxPyBeginAllowThreads();
27049 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27050
27051 wxPyEndAllowThreads(__tstate);
27052 if (PyErr_Occurred()) SWIG_fail;
27053 }
27054 {
27055 wxDataFormat * resultptr;
27056 resultptr = new wxDataFormat((wxDataFormat &)(result));
27057 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27058 }
27059 return resultobj;
27060 fail:
27061 return NULL;
27062 }
27063
27064
27065 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27066 PyObject *resultobj;
27067 wxDataObject *arg1 = (wxDataObject *) 0 ;
27068 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27069 size_t result;
27070 PyObject * obj0 = 0 ;
27071 PyObject * obj1 = 0 ;
27072 char *kwnames[] = {
27073 (char *) "self",(char *) "dir", NULL
27074 };
27075
27076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27078 if (SWIG_arg_fail(1)) SWIG_fail;
27079 if (obj1) {
27080 {
27081 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27082 if (SWIG_arg_fail(2)) SWIG_fail;
27083 }
27084 }
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27088
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 {
27093 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27094 }
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27102 PyObject *resultobj;
27103 wxDataObject *arg1 = (wxDataObject *) 0 ;
27104 wxDataFormat *arg2 = 0 ;
27105 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27106 bool result;
27107 PyObject * obj0 = 0 ;
27108 PyObject * obj1 = 0 ;
27109 PyObject * obj2 = 0 ;
27110 char *kwnames[] = {
27111 (char *) "self",(char *) "format",(char *) "dir", NULL
27112 };
27113
27114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27116 if (SWIG_arg_fail(1)) SWIG_fail;
27117 {
27118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27119 if (SWIG_arg_fail(2)) SWIG_fail;
27120 if (arg2 == NULL) {
27121 SWIG_null_ref("wxDataFormat");
27122 }
27123 if (SWIG_arg_fail(2)) SWIG_fail;
27124 }
27125 if (obj2) {
27126 {
27127 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27128 if (SWIG_arg_fail(3)) SWIG_fail;
27129 }
27130 }
27131 {
27132 PyThreadState* __tstate = wxPyBeginAllowThreads();
27133 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27134
27135 wxPyEndAllowThreads(__tstate);
27136 if (PyErr_Occurred()) SWIG_fail;
27137 }
27138 {
27139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27140 }
27141 return resultobj;
27142 fail:
27143 return NULL;
27144 }
27145
27146
27147 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27148 PyObject *resultobj;
27149 wxDataObject *arg1 = (wxDataObject *) 0 ;
27150 wxDataFormat *arg2 = 0 ;
27151 size_t result;
27152 PyObject * obj0 = 0 ;
27153 PyObject * obj1 = 0 ;
27154 char *kwnames[] = {
27155 (char *) "self",(char *) "format", NULL
27156 };
27157
27158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27160 if (SWIG_arg_fail(1)) SWIG_fail;
27161 {
27162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27163 if (SWIG_arg_fail(2)) SWIG_fail;
27164 if (arg2 == NULL) {
27165 SWIG_null_ref("wxDataFormat");
27166 }
27167 if (SWIG_arg_fail(2)) SWIG_fail;
27168 }
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27172
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 {
27177 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27178 }
27179 return resultobj;
27180 fail:
27181 return NULL;
27182 }
27183
27184
27185 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27186 PyObject *resultobj;
27187 wxDataObject *arg1 = (wxDataObject *) 0 ;
27188 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27189 PyObject *result;
27190 PyObject * obj0 = 0 ;
27191 PyObject * obj1 = 0 ;
27192 char *kwnames[] = {
27193 (char *) "self",(char *) "dir", NULL
27194 };
27195
27196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27198 if (SWIG_arg_fail(1)) SWIG_fail;
27199 if (obj1) {
27200 {
27201 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27202 if (SWIG_arg_fail(2)) SWIG_fail;
27203 }
27204 }
27205 {
27206 PyThreadState* __tstate = wxPyBeginAllowThreads();
27207 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27208
27209 wxPyEndAllowThreads(__tstate);
27210 if (PyErr_Occurred()) SWIG_fail;
27211 }
27212 resultobj = result;
27213 return resultobj;
27214 fail:
27215 return NULL;
27216 }
27217
27218
27219 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27220 PyObject *resultobj;
27221 wxDataObject *arg1 = (wxDataObject *) 0 ;
27222 wxDataFormat *arg2 = 0 ;
27223 PyObject *result;
27224 PyObject * obj0 = 0 ;
27225 PyObject * obj1 = 0 ;
27226 char *kwnames[] = {
27227 (char *) "self",(char *) "format", NULL
27228 };
27229
27230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27232 if (SWIG_arg_fail(1)) SWIG_fail;
27233 {
27234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27235 if (SWIG_arg_fail(2)) SWIG_fail;
27236 if (arg2 == NULL) {
27237 SWIG_null_ref("wxDataFormat");
27238 }
27239 if (SWIG_arg_fail(2)) SWIG_fail;
27240 }
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27244
27245 wxPyEndAllowThreads(__tstate);
27246 if (PyErr_Occurred()) SWIG_fail;
27247 }
27248 resultobj = result;
27249 return resultobj;
27250 fail:
27251 return NULL;
27252 }
27253
27254
27255 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27256 PyObject *resultobj;
27257 wxDataObject *arg1 = (wxDataObject *) 0 ;
27258 wxDataFormat *arg2 = 0 ;
27259 PyObject *arg3 = (PyObject *) 0 ;
27260 bool result;
27261 PyObject * obj0 = 0 ;
27262 PyObject * obj1 = 0 ;
27263 PyObject * obj2 = 0 ;
27264 char *kwnames[] = {
27265 (char *) "self",(char *) "format",(char *) "data", NULL
27266 };
27267
27268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27270 if (SWIG_arg_fail(1)) SWIG_fail;
27271 {
27272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27273 if (SWIG_arg_fail(2)) SWIG_fail;
27274 if (arg2 == NULL) {
27275 SWIG_null_ref("wxDataFormat");
27276 }
27277 if (SWIG_arg_fail(2)) SWIG_fail;
27278 }
27279 arg3 = obj2;
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27283
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 {
27288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27289 }
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27297 PyObject *obj;
27298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27299 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27300 Py_INCREF(obj);
27301 return Py_BuildValue((char *)"");
27302 }
27303 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27304 PyObject *resultobj;
27305 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27306 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27307 wxDataObjectSimple *result;
27308 PyObject * obj0 = 0 ;
27309 char *kwnames[] = {
27310 (char *) "format", NULL
27311 };
27312
27313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27314 if (obj0) {
27315 {
27316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27317 if (SWIG_arg_fail(1)) SWIG_fail;
27318 if (arg1 == NULL) {
27319 SWIG_null_ref("wxDataFormat");
27320 }
27321 if (SWIG_arg_fail(1)) SWIG_fail;
27322 }
27323 }
27324 {
27325 PyThreadState* __tstate = wxPyBeginAllowThreads();
27326 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27327
27328 wxPyEndAllowThreads(__tstate);
27329 if (PyErr_Occurred()) SWIG_fail;
27330 }
27331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27332 return resultobj;
27333 fail:
27334 return NULL;
27335 }
27336
27337
27338 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27339 PyObject *resultobj;
27340 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27341 wxDataFormat *result;
27342 PyObject * obj0 = 0 ;
27343 char *kwnames[] = {
27344 (char *) "self", NULL
27345 };
27346
27347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27349 if (SWIG_arg_fail(1)) SWIG_fail;
27350 {
27351 PyThreadState* __tstate = wxPyBeginAllowThreads();
27352 {
27353 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27354 result = (wxDataFormat *) &_result_ref;
27355 }
27356
27357 wxPyEndAllowThreads(__tstate);
27358 if (PyErr_Occurred()) SWIG_fail;
27359 }
27360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27368 PyObject *resultobj;
27369 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27370 wxDataFormat *arg2 = 0 ;
27371 PyObject * obj0 = 0 ;
27372 PyObject * obj1 = 0 ;
27373 char *kwnames[] = {
27374 (char *) "self",(char *) "format", NULL
27375 };
27376
27377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27379 if (SWIG_arg_fail(1)) SWIG_fail;
27380 {
27381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27382 if (SWIG_arg_fail(2)) SWIG_fail;
27383 if (arg2 == NULL) {
27384 SWIG_null_ref("wxDataFormat");
27385 }
27386 if (SWIG_arg_fail(2)) SWIG_fail;
27387 }
27388 {
27389 PyThreadState* __tstate = wxPyBeginAllowThreads();
27390 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27391
27392 wxPyEndAllowThreads(__tstate);
27393 if (PyErr_Occurred()) SWIG_fail;
27394 }
27395 Py_INCREF(Py_None); resultobj = Py_None;
27396 return resultobj;
27397 fail:
27398 return NULL;
27399 }
27400
27401
27402 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27403 PyObject *resultobj;
27404 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27405 size_t result;
27406 PyObject * obj0 = 0 ;
27407 char *kwnames[] = {
27408 (char *) "self", NULL
27409 };
27410
27411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27413 if (SWIG_arg_fail(1)) SWIG_fail;
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27417
27418 wxPyEndAllowThreads(__tstate);
27419 if (PyErr_Occurred()) SWIG_fail;
27420 }
27421 {
27422 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27423 }
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj;
27432 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27433 PyObject *result;
27434 PyObject * obj0 = 0 ;
27435 char *kwnames[] = {
27436 (char *) "self", NULL
27437 };
27438
27439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27441 if (SWIG_arg_fail(1)) SWIG_fail;
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27445
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 resultobj = result;
27450 return resultobj;
27451 fail:
27452 return NULL;
27453 }
27454
27455
27456 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27457 PyObject *resultobj;
27458 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27459 PyObject *arg2 = (PyObject *) 0 ;
27460 bool result;
27461 PyObject * obj0 = 0 ;
27462 PyObject * obj1 = 0 ;
27463 char *kwnames[] = {
27464 (char *) "self",(char *) "data", NULL
27465 };
27466
27467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27469 if (SWIG_arg_fail(1)) SWIG_fail;
27470 arg2 = obj1;
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27474
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 {
27479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27480 }
27481 return resultobj;
27482 fail:
27483 return NULL;
27484 }
27485
27486
27487 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27488 PyObject *obj;
27489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27490 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27491 Py_INCREF(obj);
27492 return Py_BuildValue((char *)"");
27493 }
27494 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27495 PyObject *resultobj;
27496 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27497 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27498 wxPyDataObjectSimple *result;
27499 PyObject * obj0 = 0 ;
27500 char *kwnames[] = {
27501 (char *) "format", NULL
27502 };
27503
27504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27505 if (obj0) {
27506 {
27507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27508 if (SWIG_arg_fail(1)) SWIG_fail;
27509 if (arg1 == NULL) {
27510 SWIG_null_ref("wxDataFormat");
27511 }
27512 if (SWIG_arg_fail(1)) SWIG_fail;
27513 }
27514 }
27515 {
27516 PyThreadState* __tstate = wxPyBeginAllowThreads();
27517 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27518
27519 wxPyEndAllowThreads(__tstate);
27520 if (PyErr_Occurred()) SWIG_fail;
27521 }
27522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27523 return resultobj;
27524 fail:
27525 return NULL;
27526 }
27527
27528
27529 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27530 PyObject *resultobj;
27531 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27532 PyObject *arg2 = (PyObject *) 0 ;
27533 PyObject *arg3 = (PyObject *) 0 ;
27534 PyObject * obj0 = 0 ;
27535 PyObject * obj1 = 0 ;
27536 PyObject * obj2 = 0 ;
27537 char *kwnames[] = {
27538 (char *) "self",(char *) "self",(char *) "_class", NULL
27539 };
27540
27541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27543 if (SWIG_arg_fail(1)) SWIG_fail;
27544 arg2 = obj1;
27545 arg3 = obj2;
27546 {
27547 PyThreadState* __tstate = wxPyBeginAllowThreads();
27548 (arg1)->_setCallbackInfo(arg2,arg3);
27549
27550 wxPyEndAllowThreads(__tstate);
27551 if (PyErr_Occurred()) SWIG_fail;
27552 }
27553 Py_INCREF(Py_None); resultobj = Py_None;
27554 return resultobj;
27555 fail:
27556 return NULL;
27557 }
27558
27559
27560 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27561 PyObject *obj;
27562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27563 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27564 Py_INCREF(obj);
27565 return Py_BuildValue((char *)"");
27566 }
27567 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27568 PyObject *resultobj;
27569 wxDataObjectComposite *result;
27570 char *kwnames[] = {
27571 NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27575 {
27576 PyThreadState* __tstate = wxPyBeginAllowThreads();
27577 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27578
27579 wxPyEndAllowThreads(__tstate);
27580 if (PyErr_Occurred()) SWIG_fail;
27581 }
27582 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27590 PyObject *resultobj;
27591 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27592 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27593 bool arg3 = (bool) false ;
27594 PyObject * obj0 = 0 ;
27595 PyObject * obj1 = 0 ;
27596 PyObject * obj2 = 0 ;
27597 char *kwnames[] = {
27598 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27599 };
27600
27601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27603 if (SWIG_arg_fail(1)) SWIG_fail;
27604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27605 if (SWIG_arg_fail(2)) SWIG_fail;
27606 if (obj2) {
27607 {
27608 arg3 = (bool)(SWIG_As_bool(obj2));
27609 if (SWIG_arg_fail(3)) SWIG_fail;
27610 }
27611 }
27612 {
27613 PyThreadState* __tstate = wxPyBeginAllowThreads();
27614 (arg1)->Add(arg2,arg3);
27615
27616 wxPyEndAllowThreads(__tstate);
27617 if (PyErr_Occurred()) SWIG_fail;
27618 }
27619 Py_INCREF(Py_None); resultobj = Py_None;
27620 return resultobj;
27621 fail:
27622 return NULL;
27623 }
27624
27625
27626 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27627 PyObject *obj;
27628 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27629 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27630 Py_INCREF(obj);
27631 return Py_BuildValue((char *)"");
27632 }
27633 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27634 PyObject *resultobj;
27635 wxString const &arg1_defvalue = wxPyEmptyString ;
27636 wxString *arg1 = (wxString *) &arg1_defvalue ;
27637 wxTextDataObject *result;
27638 bool temp1 = false ;
27639 PyObject * obj0 = 0 ;
27640 char *kwnames[] = {
27641 (char *) "text", NULL
27642 };
27643
27644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27645 if (obj0) {
27646 {
27647 arg1 = wxString_in_helper(obj0);
27648 if (arg1 == NULL) SWIG_fail;
27649 temp1 = true;
27650 }
27651 }
27652 {
27653 PyThreadState* __tstate = wxPyBeginAllowThreads();
27654 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27655
27656 wxPyEndAllowThreads(__tstate);
27657 if (PyErr_Occurred()) SWIG_fail;
27658 }
27659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27660 {
27661 if (temp1)
27662 delete arg1;
27663 }
27664 return resultobj;
27665 fail:
27666 {
27667 if (temp1)
27668 delete arg1;
27669 }
27670 return NULL;
27671 }
27672
27673
27674 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27675 PyObject *resultobj;
27676 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27677 size_t result;
27678 PyObject * obj0 = 0 ;
27679 char *kwnames[] = {
27680 (char *) "self", NULL
27681 };
27682
27683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27685 if (SWIG_arg_fail(1)) SWIG_fail;
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 result = (size_t)(arg1)->GetTextLength();
27689
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 {
27694 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27695 }
27696 return resultobj;
27697 fail:
27698 return NULL;
27699 }
27700
27701
27702 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27703 PyObject *resultobj;
27704 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27705 wxString result;
27706 PyObject * obj0 = 0 ;
27707 char *kwnames[] = {
27708 (char *) "self", NULL
27709 };
27710
27711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27713 if (SWIG_arg_fail(1)) SWIG_fail;
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 result = (arg1)->GetText();
27717
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 {
27722 #if wxUSE_UNICODE
27723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27724 #else
27725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27726 #endif
27727 }
27728 return resultobj;
27729 fail:
27730 return NULL;
27731 }
27732
27733
27734 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27735 PyObject *resultobj;
27736 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27737 wxString *arg2 = 0 ;
27738 bool temp2 = false ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 char *kwnames[] = {
27742 (char *) "self",(char *) "text", NULL
27743 };
27744
27745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27747 if (SWIG_arg_fail(1)) SWIG_fail;
27748 {
27749 arg2 = wxString_in_helper(obj1);
27750 if (arg2 == NULL) SWIG_fail;
27751 temp2 = true;
27752 }
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 (arg1)->SetText((wxString const &)*arg2);
27756
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 Py_INCREF(Py_None); resultobj = Py_None;
27761 {
27762 if (temp2)
27763 delete arg2;
27764 }
27765 return resultobj;
27766 fail:
27767 {
27768 if (temp2)
27769 delete arg2;
27770 }
27771 return NULL;
27772 }
27773
27774
27775 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27776 PyObject *obj;
27777 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27778 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27779 Py_INCREF(obj);
27780 return Py_BuildValue((char *)"");
27781 }
27782 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27783 PyObject *resultobj;
27784 wxString const &arg1_defvalue = wxPyEmptyString ;
27785 wxString *arg1 = (wxString *) &arg1_defvalue ;
27786 wxPyTextDataObject *result;
27787 bool temp1 = false ;
27788 PyObject * obj0 = 0 ;
27789 char *kwnames[] = {
27790 (char *) "text", NULL
27791 };
27792
27793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27794 if (obj0) {
27795 {
27796 arg1 = wxString_in_helper(obj0);
27797 if (arg1 == NULL) SWIG_fail;
27798 temp1 = true;
27799 }
27800 }
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27804
27805 wxPyEndAllowThreads(__tstate);
27806 if (PyErr_Occurred()) SWIG_fail;
27807 }
27808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27809 {
27810 if (temp1)
27811 delete arg1;
27812 }
27813 return resultobj;
27814 fail:
27815 {
27816 if (temp1)
27817 delete arg1;
27818 }
27819 return NULL;
27820 }
27821
27822
27823 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27824 PyObject *resultobj;
27825 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27826 PyObject *arg2 = (PyObject *) 0 ;
27827 PyObject *arg3 = (PyObject *) 0 ;
27828 PyObject * obj0 = 0 ;
27829 PyObject * obj1 = 0 ;
27830 PyObject * obj2 = 0 ;
27831 char *kwnames[] = {
27832 (char *) "self",(char *) "self",(char *) "_class", NULL
27833 };
27834
27835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27837 if (SWIG_arg_fail(1)) SWIG_fail;
27838 arg2 = obj1;
27839 arg3 = obj2;
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 (arg1)->_setCallbackInfo(arg2,arg3);
27843
27844 wxPyEndAllowThreads(__tstate);
27845 if (PyErr_Occurred()) SWIG_fail;
27846 }
27847 Py_INCREF(Py_None); resultobj = Py_None;
27848 return resultobj;
27849 fail:
27850 return NULL;
27851 }
27852
27853
27854 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27855 PyObject *obj;
27856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27857 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27858 Py_INCREF(obj);
27859 return Py_BuildValue((char *)"");
27860 }
27861 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27862 PyObject *resultobj;
27863 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27864 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27865 wxBitmapDataObject *result;
27866 PyObject * obj0 = 0 ;
27867 char *kwnames[] = {
27868 (char *) "bitmap", NULL
27869 };
27870
27871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27872 if (obj0) {
27873 {
27874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27875 if (SWIG_arg_fail(1)) SWIG_fail;
27876 if (arg1 == NULL) {
27877 SWIG_null_ref("wxBitmap");
27878 }
27879 if (SWIG_arg_fail(1)) SWIG_fail;
27880 }
27881 }
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27885
27886 wxPyEndAllowThreads(__tstate);
27887 if (PyErr_Occurred()) SWIG_fail;
27888 }
27889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27890 return resultobj;
27891 fail:
27892 return NULL;
27893 }
27894
27895
27896 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27897 PyObject *resultobj;
27898 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27899 wxBitmap result;
27900 PyObject * obj0 = 0 ;
27901 char *kwnames[] = {
27902 (char *) "self", NULL
27903 };
27904
27905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27907 if (SWIG_arg_fail(1)) SWIG_fail;
27908 {
27909 PyThreadState* __tstate = wxPyBeginAllowThreads();
27910 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27911
27912 wxPyEndAllowThreads(__tstate);
27913 if (PyErr_Occurred()) SWIG_fail;
27914 }
27915 {
27916 wxBitmap * resultptr;
27917 resultptr = new wxBitmap((wxBitmap &)(result));
27918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27919 }
27920 return resultobj;
27921 fail:
27922 return NULL;
27923 }
27924
27925
27926 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27927 PyObject *resultobj;
27928 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27929 wxBitmap *arg2 = 0 ;
27930 PyObject * obj0 = 0 ;
27931 PyObject * obj1 = 0 ;
27932 char *kwnames[] = {
27933 (char *) "self",(char *) "bitmap", NULL
27934 };
27935
27936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27938 if (SWIG_arg_fail(1)) SWIG_fail;
27939 {
27940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27941 if (SWIG_arg_fail(2)) SWIG_fail;
27942 if (arg2 == NULL) {
27943 SWIG_null_ref("wxBitmap");
27944 }
27945 if (SWIG_arg_fail(2)) SWIG_fail;
27946 }
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27950
27951 wxPyEndAllowThreads(__tstate);
27952 if (PyErr_Occurred()) SWIG_fail;
27953 }
27954 Py_INCREF(Py_None); resultobj = Py_None;
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27962 PyObject *obj;
27963 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27964 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27965 Py_INCREF(obj);
27966 return Py_BuildValue((char *)"");
27967 }
27968 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27969 PyObject *resultobj;
27970 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27971 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27972 wxPyBitmapDataObject *result;
27973 PyObject * obj0 = 0 ;
27974 char *kwnames[] = {
27975 (char *) "bitmap", NULL
27976 };
27977
27978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27979 if (obj0) {
27980 {
27981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27982 if (SWIG_arg_fail(1)) SWIG_fail;
27983 if (arg1 == NULL) {
27984 SWIG_null_ref("wxBitmap");
27985 }
27986 if (SWIG_arg_fail(1)) SWIG_fail;
27987 }
27988 }
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27992
27993 wxPyEndAllowThreads(__tstate);
27994 if (PyErr_Occurred()) SWIG_fail;
27995 }
27996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27997 return resultobj;
27998 fail:
27999 return NULL;
28000 }
28001
28002
28003 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28004 PyObject *resultobj;
28005 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28006 PyObject *arg2 = (PyObject *) 0 ;
28007 PyObject *arg3 = (PyObject *) 0 ;
28008 PyObject * obj0 = 0 ;
28009 PyObject * obj1 = 0 ;
28010 PyObject * obj2 = 0 ;
28011 char *kwnames[] = {
28012 (char *) "self",(char *) "self",(char *) "_class", NULL
28013 };
28014
28015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28017 if (SWIG_arg_fail(1)) SWIG_fail;
28018 arg2 = obj1;
28019 arg3 = obj2;
28020 {
28021 PyThreadState* __tstate = wxPyBeginAllowThreads();
28022 (arg1)->_setCallbackInfo(arg2,arg3);
28023
28024 wxPyEndAllowThreads(__tstate);
28025 if (PyErr_Occurred()) SWIG_fail;
28026 }
28027 Py_INCREF(Py_None); resultobj = Py_None;
28028 return resultobj;
28029 fail:
28030 return NULL;
28031 }
28032
28033
28034 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28035 PyObject *obj;
28036 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28037 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28038 Py_INCREF(obj);
28039 return Py_BuildValue((char *)"");
28040 }
28041 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28042 PyObject *resultobj;
28043 wxFileDataObject *result;
28044 char *kwnames[] = {
28045 NULL
28046 };
28047
28048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28049 {
28050 PyThreadState* __tstate = wxPyBeginAllowThreads();
28051 result = (wxFileDataObject *)new wxFileDataObject();
28052
28053 wxPyEndAllowThreads(__tstate);
28054 if (PyErr_Occurred()) SWIG_fail;
28055 }
28056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28057 return resultobj;
28058 fail:
28059 return NULL;
28060 }
28061
28062
28063 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28064 PyObject *resultobj;
28065 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28066 wxArrayString *result;
28067 PyObject * obj0 = 0 ;
28068 char *kwnames[] = {
28069 (char *) "self", NULL
28070 };
28071
28072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28074 if (SWIG_arg_fail(1)) SWIG_fail;
28075 {
28076 PyThreadState* __tstate = wxPyBeginAllowThreads();
28077 {
28078 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28079 result = (wxArrayString *) &_result_ref;
28080 }
28081
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 {
28086 resultobj = wxArrayString2PyList_helper(*result);
28087 }
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28095 PyObject *resultobj;
28096 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28097 wxString *arg2 = 0 ;
28098 bool temp2 = false ;
28099 PyObject * obj0 = 0 ;
28100 PyObject * obj1 = 0 ;
28101 char *kwnames[] = {
28102 (char *) "self",(char *) "filename", NULL
28103 };
28104
28105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28107 if (SWIG_arg_fail(1)) SWIG_fail;
28108 {
28109 arg2 = wxString_in_helper(obj1);
28110 if (arg2 == NULL) SWIG_fail;
28111 temp2 = true;
28112 }
28113 {
28114 PyThreadState* __tstate = wxPyBeginAllowThreads();
28115 (arg1)->AddFile((wxString const &)*arg2);
28116
28117 wxPyEndAllowThreads(__tstate);
28118 if (PyErr_Occurred()) SWIG_fail;
28119 }
28120 Py_INCREF(Py_None); resultobj = Py_None;
28121 {
28122 if (temp2)
28123 delete arg2;
28124 }
28125 return resultobj;
28126 fail:
28127 {
28128 if (temp2)
28129 delete arg2;
28130 }
28131 return NULL;
28132 }
28133
28134
28135 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28136 PyObject *obj;
28137 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28138 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28139 Py_INCREF(obj);
28140 return Py_BuildValue((char *)"");
28141 }
28142 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28143 PyObject *resultobj;
28144 wxDataFormat *arg1 = 0 ;
28145 wxCustomDataObject *result;
28146 PyObject * obj0 = 0 ;
28147
28148 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28149 {
28150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28151 if (SWIG_arg_fail(1)) SWIG_fail;
28152 if (arg1 == NULL) {
28153 SWIG_null_ref("wxDataFormat");
28154 }
28155 if (SWIG_arg_fail(1)) SWIG_fail;
28156 }
28157 {
28158 PyThreadState* __tstate = wxPyBeginAllowThreads();
28159 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28160
28161 wxPyEndAllowThreads(__tstate);
28162 if (PyErr_Occurred()) SWIG_fail;
28163 }
28164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28165 return resultobj;
28166 fail:
28167 return NULL;
28168 }
28169
28170
28171 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28172 PyObject *resultobj;
28173 wxString *arg1 = 0 ;
28174 wxCustomDataObject *result;
28175 bool temp1 = false ;
28176 PyObject * obj0 = 0 ;
28177
28178 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28179 {
28180 arg1 = wxString_in_helper(obj0);
28181 if (arg1 == NULL) SWIG_fail;
28182 temp1 = true;
28183 }
28184 {
28185 PyThreadState* __tstate = wxPyBeginAllowThreads();
28186 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28187
28188 wxPyEndAllowThreads(__tstate);
28189 if (PyErr_Occurred()) SWIG_fail;
28190 }
28191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28192 {
28193 if (temp1)
28194 delete arg1;
28195 }
28196 return resultobj;
28197 fail:
28198 {
28199 if (temp1)
28200 delete arg1;
28201 }
28202 return NULL;
28203 }
28204
28205
28206 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28207 PyObject *resultobj;
28208 wxCustomDataObject *result;
28209
28210 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28211 {
28212 PyThreadState* __tstate = wxPyBeginAllowThreads();
28213 result = (wxCustomDataObject *)new wxCustomDataObject();
28214
28215 wxPyEndAllowThreads(__tstate);
28216 if (PyErr_Occurred()) SWIG_fail;
28217 }
28218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28219 return resultobj;
28220 fail:
28221 return NULL;
28222 }
28223
28224
28225 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28226 int argc;
28227 PyObject *argv[2];
28228 int ii;
28229
28230 argc = PyObject_Length(args);
28231 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28232 argv[ii] = PyTuple_GetItem(args,ii);
28233 }
28234 if (argc == 0) {
28235 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28236 }
28237 if (argc == 1) {
28238 int _v;
28239 {
28240 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28241 }
28242 if (_v) {
28243 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28244 }
28245 }
28246 if (argc == 1) {
28247 int _v;
28248 {
28249 void *ptr = 0;
28250 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28251 _v = 0;
28252 PyErr_Clear();
28253 } else {
28254 _v = (ptr != 0);
28255 }
28256 }
28257 if (_v) {
28258 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28259 }
28260 }
28261
28262 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28263 return NULL;
28264 }
28265
28266
28267 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28268 PyObject *resultobj;
28269 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28270 PyObject *arg2 = (PyObject *) 0 ;
28271 bool result;
28272 PyObject * obj0 = 0 ;
28273 PyObject * obj1 = 0 ;
28274 char *kwnames[] = {
28275 (char *) "self",(char *) "data", NULL
28276 };
28277
28278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28280 if (SWIG_arg_fail(1)) SWIG_fail;
28281 arg2 = obj1;
28282 {
28283 PyThreadState* __tstate = wxPyBeginAllowThreads();
28284 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28285
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 {
28290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28291 }
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28299 PyObject *resultobj;
28300 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28301 size_t result;
28302 PyObject * obj0 = 0 ;
28303 char *kwnames[] = {
28304 (char *) "self", NULL
28305 };
28306
28307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28309 if (SWIG_arg_fail(1)) SWIG_fail;
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (size_t)(arg1)->GetSize();
28313
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 {
28318 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28319 }
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28327 PyObject *resultobj;
28328 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28329 PyObject *result;
28330 PyObject * obj0 = 0 ;
28331 char *kwnames[] = {
28332 (char *) "self", NULL
28333 };
28334
28335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28337 if (SWIG_arg_fail(1)) SWIG_fail;
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28341
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 resultobj = result;
28346 return resultobj;
28347 fail:
28348 return NULL;
28349 }
28350
28351
28352 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28353 PyObject *obj;
28354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28355 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28356 Py_INCREF(obj);
28357 return Py_BuildValue((char *)"");
28358 }
28359 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj;
28361 wxURLDataObject *result;
28362 char *kwnames[] = {
28363 NULL
28364 };
28365
28366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 result = (wxURLDataObject *)new wxURLDataObject();
28370
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28375 return resultobj;
28376 fail:
28377 return NULL;
28378 }
28379
28380
28381 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28382 PyObject *resultobj;
28383 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28384 wxString result;
28385 PyObject * obj0 = 0 ;
28386 char *kwnames[] = {
28387 (char *) "self", NULL
28388 };
28389
28390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28392 if (SWIG_arg_fail(1)) SWIG_fail;
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (arg1)->GetURL();
28396
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 {
28401 #if wxUSE_UNICODE
28402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28403 #else
28404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28405 #endif
28406 }
28407 return resultobj;
28408 fail:
28409 return NULL;
28410 }
28411
28412
28413 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28414 PyObject *resultobj;
28415 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28416 wxString *arg2 = 0 ;
28417 bool temp2 = false ;
28418 PyObject * obj0 = 0 ;
28419 PyObject * obj1 = 0 ;
28420 char *kwnames[] = {
28421 (char *) "self",(char *) "url", NULL
28422 };
28423
28424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28426 if (SWIG_arg_fail(1)) SWIG_fail;
28427 {
28428 arg2 = wxString_in_helper(obj1);
28429 if (arg2 == NULL) SWIG_fail;
28430 temp2 = true;
28431 }
28432 {
28433 PyThreadState* __tstate = wxPyBeginAllowThreads();
28434 (arg1)->SetURL((wxString const &)*arg2);
28435
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 Py_INCREF(Py_None); resultobj = Py_None;
28440 {
28441 if (temp2)
28442 delete arg2;
28443 }
28444 return resultobj;
28445 fail:
28446 {
28447 if (temp2)
28448 delete arg2;
28449 }
28450 return NULL;
28451 }
28452
28453
28454 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28455 PyObject *obj;
28456 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28457 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28458 Py_INCREF(obj);
28459 return Py_BuildValue((char *)"");
28460 }
28461 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28462 PyObject *resultobj;
28463 wxMetafileDataObject *result;
28464 char *kwnames[] = {
28465 NULL
28466 };
28467
28468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28469 {
28470 PyThreadState* __tstate = wxPyBeginAllowThreads();
28471 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28472
28473 wxPyEndAllowThreads(__tstate);
28474 if (PyErr_Occurred()) SWIG_fail;
28475 }
28476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28477 return resultobj;
28478 fail:
28479 return NULL;
28480 }
28481
28482
28483 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28484 PyObject *obj;
28485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28486 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28487 Py_INCREF(obj);
28488 return Py_BuildValue((char *)"");
28489 }
28490 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28491 PyObject *resultobj;
28492 wxDragResult arg1 ;
28493 bool result;
28494 PyObject * obj0 = 0 ;
28495 char *kwnames[] = {
28496 (char *) "res", NULL
28497 };
28498
28499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28500 {
28501 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28502 if (SWIG_arg_fail(1)) SWIG_fail;
28503 }
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28507
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 {
28512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28513 }
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28521 PyObject *resultobj;
28522 wxWindow *arg1 = (wxWindow *) 0 ;
28523 wxIcon const &arg2_defvalue = wxNullIcon ;
28524 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28525 wxIcon const &arg3_defvalue = wxNullIcon ;
28526 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28527 wxIcon const &arg4_defvalue = wxNullIcon ;
28528 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28529 wxPyDropSource *result;
28530 PyObject * obj0 = 0 ;
28531 PyObject * obj1 = 0 ;
28532 PyObject * obj2 = 0 ;
28533 PyObject * obj3 = 0 ;
28534 char *kwnames[] = {
28535 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28536 };
28537
28538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28540 if (SWIG_arg_fail(1)) SWIG_fail;
28541 if (obj1) {
28542 {
28543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28544 if (SWIG_arg_fail(2)) SWIG_fail;
28545 if (arg2 == NULL) {
28546 SWIG_null_ref("wxIcon");
28547 }
28548 if (SWIG_arg_fail(2)) SWIG_fail;
28549 }
28550 }
28551 if (obj2) {
28552 {
28553 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28554 if (SWIG_arg_fail(3)) SWIG_fail;
28555 if (arg3 == NULL) {
28556 SWIG_null_ref("wxIcon");
28557 }
28558 if (SWIG_arg_fail(3)) SWIG_fail;
28559 }
28560 }
28561 if (obj3) {
28562 {
28563 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28564 if (SWIG_arg_fail(4)) SWIG_fail;
28565 if (arg4 == NULL) {
28566 SWIG_null_ref("wxIcon");
28567 }
28568 if (SWIG_arg_fail(4)) SWIG_fail;
28569 }
28570 }
28571 {
28572 PyThreadState* __tstate = wxPyBeginAllowThreads();
28573 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28574
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28579 return resultobj;
28580 fail:
28581 return NULL;
28582 }
28583
28584
28585 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28586 PyObject *resultobj;
28587 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28588 PyObject *arg2 = (PyObject *) 0 ;
28589 PyObject *arg3 = (PyObject *) 0 ;
28590 int arg4 ;
28591 PyObject * obj0 = 0 ;
28592 PyObject * obj1 = 0 ;
28593 PyObject * obj2 = 0 ;
28594 PyObject * obj3 = 0 ;
28595 char *kwnames[] = {
28596 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28597 };
28598
28599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28601 if (SWIG_arg_fail(1)) SWIG_fail;
28602 arg2 = obj1;
28603 arg3 = obj2;
28604 {
28605 arg4 = (int)(SWIG_As_int(obj3));
28606 if (SWIG_arg_fail(4)) SWIG_fail;
28607 }
28608 {
28609 PyThreadState* __tstate = wxPyBeginAllowThreads();
28610 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28611
28612 wxPyEndAllowThreads(__tstate);
28613 if (PyErr_Occurred()) SWIG_fail;
28614 }
28615 Py_INCREF(Py_None); resultobj = Py_None;
28616 return resultobj;
28617 fail:
28618 return NULL;
28619 }
28620
28621
28622 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28623 PyObject *resultobj;
28624 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28625 PyObject * obj0 = 0 ;
28626 char *kwnames[] = {
28627 (char *) "self", NULL
28628 };
28629
28630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28632 if (SWIG_arg_fail(1)) SWIG_fail;
28633 {
28634 PyThreadState* __tstate = wxPyBeginAllowThreads();
28635 delete arg1;
28636
28637 wxPyEndAllowThreads(__tstate);
28638 if (PyErr_Occurred()) SWIG_fail;
28639 }
28640 Py_INCREF(Py_None); resultobj = Py_None;
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28648 PyObject *resultobj;
28649 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28650 wxDataObject *arg2 = 0 ;
28651 PyObject * obj0 = 0 ;
28652 PyObject * obj1 = 0 ;
28653 char *kwnames[] = {
28654 (char *) "self",(char *) "data", NULL
28655 };
28656
28657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28659 if (SWIG_arg_fail(1)) SWIG_fail;
28660 {
28661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28662 if (SWIG_arg_fail(2)) SWIG_fail;
28663 if (arg2 == NULL) {
28664 SWIG_null_ref("wxDataObject");
28665 }
28666 if (SWIG_arg_fail(2)) SWIG_fail;
28667 }
28668 {
28669 PyThreadState* __tstate = wxPyBeginAllowThreads();
28670 (arg1)->SetData(*arg2);
28671
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 Py_INCREF(Py_None); resultobj = Py_None;
28676 return resultobj;
28677 fail:
28678 return NULL;
28679 }
28680
28681
28682 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28683 PyObject *resultobj;
28684 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28685 wxDataObject *result;
28686 PyObject * obj0 = 0 ;
28687 char *kwnames[] = {
28688 (char *) "self", NULL
28689 };
28690
28691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28693 if (SWIG_arg_fail(1)) SWIG_fail;
28694 {
28695 PyThreadState* __tstate = wxPyBeginAllowThreads();
28696 result = (wxDataObject *)(arg1)->GetDataObject();
28697
28698 wxPyEndAllowThreads(__tstate);
28699 if (PyErr_Occurred()) SWIG_fail;
28700 }
28701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28702 return resultobj;
28703 fail:
28704 return NULL;
28705 }
28706
28707
28708 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28709 PyObject *resultobj;
28710 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28711 wxDragResult arg2 ;
28712 wxCursor *arg3 = 0 ;
28713 PyObject * obj0 = 0 ;
28714 PyObject * obj1 = 0 ;
28715 PyObject * obj2 = 0 ;
28716 char *kwnames[] = {
28717 (char *) "self",(char *) "res",(char *) "cursor", NULL
28718 };
28719
28720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28722 if (SWIG_arg_fail(1)) SWIG_fail;
28723 {
28724 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28725 if (SWIG_arg_fail(2)) SWIG_fail;
28726 }
28727 {
28728 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28729 if (SWIG_arg_fail(3)) SWIG_fail;
28730 if (arg3 == NULL) {
28731 SWIG_null_ref("wxCursor");
28732 }
28733 if (SWIG_arg_fail(3)) SWIG_fail;
28734 }
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28738
28739 wxPyEndAllowThreads(__tstate);
28740 if (PyErr_Occurred()) SWIG_fail;
28741 }
28742 Py_INCREF(Py_None); resultobj = Py_None;
28743 return resultobj;
28744 fail:
28745 return NULL;
28746 }
28747
28748
28749 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28750 PyObject *resultobj;
28751 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28752 int arg2 = (int) wxDrag_CopyOnly ;
28753 wxDragResult result;
28754 PyObject * obj0 = 0 ;
28755 PyObject * obj1 = 0 ;
28756 char *kwnames[] = {
28757 (char *) "self",(char *) "flags", NULL
28758 };
28759
28760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28762 if (SWIG_arg_fail(1)) SWIG_fail;
28763 if (obj1) {
28764 {
28765 arg2 = (int)(SWIG_As_int(obj1));
28766 if (SWIG_arg_fail(2)) SWIG_fail;
28767 }
28768 }
28769 {
28770 PyThreadState* __tstate = wxPyBeginAllowThreads();
28771 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28772
28773 wxPyEndAllowThreads(__tstate);
28774 if (PyErr_Occurred()) SWIG_fail;
28775 }
28776 resultobj = SWIG_From_int((result));
28777 return resultobj;
28778 fail:
28779 return NULL;
28780 }
28781
28782
28783 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28784 PyObject *resultobj;
28785 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28786 wxDragResult arg2 ;
28787 bool result;
28788 PyObject * obj0 = 0 ;
28789 PyObject * obj1 = 0 ;
28790 char *kwnames[] = {
28791 (char *) "self",(char *) "effect", NULL
28792 };
28793
28794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28796 if (SWIG_arg_fail(1)) SWIG_fail;
28797 {
28798 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28799 if (SWIG_arg_fail(2)) SWIG_fail;
28800 }
28801 {
28802 PyThreadState* __tstate = wxPyBeginAllowThreads();
28803 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28804
28805 wxPyEndAllowThreads(__tstate);
28806 if (PyErr_Occurred()) SWIG_fail;
28807 }
28808 {
28809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28810 }
28811 return resultobj;
28812 fail:
28813 return NULL;
28814 }
28815
28816
28817 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28818 PyObject *obj;
28819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28820 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28821 Py_INCREF(obj);
28822 return Py_BuildValue((char *)"");
28823 }
28824 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28825 PyObject *resultobj;
28826 wxDataObject *arg1 = (wxDataObject *) NULL ;
28827 wxPyDropTarget *result;
28828 PyObject * obj0 = 0 ;
28829 char *kwnames[] = {
28830 (char *) "dataObject", NULL
28831 };
28832
28833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28834 if (obj0) {
28835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28836 if (SWIG_arg_fail(1)) SWIG_fail;
28837 }
28838 {
28839 PyThreadState* __tstate = wxPyBeginAllowThreads();
28840 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28841
28842 wxPyEndAllowThreads(__tstate);
28843 if (PyErr_Occurred()) SWIG_fail;
28844 }
28845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28846 return resultobj;
28847 fail:
28848 return NULL;
28849 }
28850
28851
28852 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28853 PyObject *resultobj;
28854 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28855 PyObject *arg2 = (PyObject *) 0 ;
28856 PyObject *arg3 = (PyObject *) 0 ;
28857 PyObject * obj0 = 0 ;
28858 PyObject * obj1 = 0 ;
28859 PyObject * obj2 = 0 ;
28860 char *kwnames[] = {
28861 (char *) "self",(char *) "self",(char *) "_class", NULL
28862 };
28863
28864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28866 if (SWIG_arg_fail(1)) SWIG_fail;
28867 arg2 = obj1;
28868 arg3 = obj2;
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 (arg1)->_setCallbackInfo(arg2,arg3);
28872
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 Py_INCREF(Py_None); resultobj = Py_None;
28877 return resultobj;
28878 fail:
28879 return NULL;
28880 }
28881
28882
28883 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28884 PyObject *resultobj;
28885 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28886 PyObject * obj0 = 0 ;
28887 char *kwnames[] = {
28888 (char *) "self", NULL
28889 };
28890
28891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28893 if (SWIG_arg_fail(1)) SWIG_fail;
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 delete arg1;
28897
28898 wxPyEndAllowThreads(__tstate);
28899 if (PyErr_Occurred()) SWIG_fail;
28900 }
28901 Py_INCREF(Py_None); resultobj = Py_None;
28902 return resultobj;
28903 fail:
28904 return NULL;
28905 }
28906
28907
28908 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28909 PyObject *resultobj;
28910 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28911 wxDataObject *result;
28912 PyObject * obj0 = 0 ;
28913 char *kwnames[] = {
28914 (char *) "self", NULL
28915 };
28916
28917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28919 if (SWIG_arg_fail(1)) SWIG_fail;
28920 {
28921 PyThreadState* __tstate = wxPyBeginAllowThreads();
28922 result = (wxDataObject *)(arg1)->GetDataObject();
28923
28924 wxPyEndAllowThreads(__tstate);
28925 if (PyErr_Occurred()) SWIG_fail;
28926 }
28927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28928 return resultobj;
28929 fail:
28930 return NULL;
28931 }
28932
28933
28934 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28935 PyObject *resultobj;
28936 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28937 wxDataObject *arg2 = (wxDataObject *) 0 ;
28938 PyObject * obj0 = 0 ;
28939 PyObject * obj1 = 0 ;
28940 char *kwnames[] = {
28941 (char *) "self",(char *) "dataObject", NULL
28942 };
28943
28944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28946 if (SWIG_arg_fail(1)) SWIG_fail;
28947 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28948 if (SWIG_arg_fail(2)) SWIG_fail;
28949 {
28950 PyThreadState* __tstate = wxPyBeginAllowThreads();
28951 (arg1)->SetDataObject(arg2);
28952
28953 wxPyEndAllowThreads(__tstate);
28954 if (PyErr_Occurred()) SWIG_fail;
28955 }
28956 Py_INCREF(Py_None); resultobj = Py_None;
28957 return resultobj;
28958 fail:
28959 return NULL;
28960 }
28961
28962
28963 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28964 PyObject *resultobj;
28965 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28966 int arg2 ;
28967 int arg3 ;
28968 wxDragResult arg4 ;
28969 wxDragResult result;
28970 PyObject * obj0 = 0 ;
28971 PyObject * obj1 = 0 ;
28972 PyObject * obj2 = 0 ;
28973 PyObject * obj3 = 0 ;
28974 char *kwnames[] = {
28975 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28976 };
28977
28978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28980 if (SWIG_arg_fail(1)) SWIG_fail;
28981 {
28982 arg2 = (int)(SWIG_As_int(obj1));
28983 if (SWIG_arg_fail(2)) SWIG_fail;
28984 }
28985 {
28986 arg3 = (int)(SWIG_As_int(obj2));
28987 if (SWIG_arg_fail(3)) SWIG_fail;
28988 }
28989 {
28990 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28991 if (SWIG_arg_fail(4)) SWIG_fail;
28992 }
28993 {
28994 PyThreadState* __tstate = wxPyBeginAllowThreads();
28995 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28996
28997 wxPyEndAllowThreads(__tstate);
28998 if (PyErr_Occurred()) SWIG_fail;
28999 }
29000 resultobj = SWIG_From_int((result));
29001 return resultobj;
29002 fail:
29003 return NULL;
29004 }
29005
29006
29007 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29008 PyObject *resultobj;
29009 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29010 int arg2 ;
29011 int arg3 ;
29012 wxDragResult arg4 ;
29013 wxDragResult result;
29014 PyObject * obj0 = 0 ;
29015 PyObject * obj1 = 0 ;
29016 PyObject * obj2 = 0 ;
29017 PyObject * obj3 = 0 ;
29018 char *kwnames[] = {
29019 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29020 };
29021
29022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29024 if (SWIG_arg_fail(1)) SWIG_fail;
29025 {
29026 arg2 = (int)(SWIG_As_int(obj1));
29027 if (SWIG_arg_fail(2)) SWIG_fail;
29028 }
29029 {
29030 arg3 = (int)(SWIG_As_int(obj2));
29031 if (SWIG_arg_fail(3)) SWIG_fail;
29032 }
29033 {
29034 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29035 if (SWIG_arg_fail(4)) SWIG_fail;
29036 }
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29040
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 resultobj = SWIG_From_int((result));
29045 return resultobj;
29046 fail:
29047 return NULL;
29048 }
29049
29050
29051 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29052 PyObject *resultobj;
29053 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29054 PyObject * obj0 = 0 ;
29055 char *kwnames[] = {
29056 (char *) "self", NULL
29057 };
29058
29059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29061 if (SWIG_arg_fail(1)) SWIG_fail;
29062 {
29063 PyThreadState* __tstate = wxPyBeginAllowThreads();
29064 (arg1)->base_OnLeave();
29065
29066 wxPyEndAllowThreads(__tstate);
29067 if (PyErr_Occurred()) SWIG_fail;
29068 }
29069 Py_INCREF(Py_None); resultobj = Py_None;
29070 return resultobj;
29071 fail:
29072 return NULL;
29073 }
29074
29075
29076 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29077 PyObject *resultobj;
29078 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29079 int arg2 ;
29080 int arg3 ;
29081 bool result;
29082 PyObject * obj0 = 0 ;
29083 PyObject * obj1 = 0 ;
29084 PyObject * obj2 = 0 ;
29085 char *kwnames[] = {
29086 (char *) "self",(char *) "x",(char *) "y", NULL
29087 };
29088
29089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29091 if (SWIG_arg_fail(1)) SWIG_fail;
29092 {
29093 arg2 = (int)(SWIG_As_int(obj1));
29094 if (SWIG_arg_fail(2)) SWIG_fail;
29095 }
29096 {
29097 arg3 = (int)(SWIG_As_int(obj2));
29098 if (SWIG_arg_fail(3)) SWIG_fail;
29099 }
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29103
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 {
29108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29109 }
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29117 PyObject *resultobj;
29118 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29119 bool result;
29120 PyObject * obj0 = 0 ;
29121 char *kwnames[] = {
29122 (char *) "self", NULL
29123 };
29124
29125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29127 if (SWIG_arg_fail(1)) SWIG_fail;
29128 {
29129 PyThreadState* __tstate = wxPyBeginAllowThreads();
29130 result = (bool)(arg1)->GetData();
29131
29132 wxPyEndAllowThreads(__tstate);
29133 if (PyErr_Occurred()) SWIG_fail;
29134 }
29135 {
29136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29137 }
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29145 PyObject *resultobj;
29146 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29147 wxDragResult arg2 ;
29148 PyObject * obj0 = 0 ;
29149 PyObject * obj1 = 0 ;
29150 char *kwnames[] = {
29151 (char *) "self",(char *) "action", NULL
29152 };
29153
29154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29156 if (SWIG_arg_fail(1)) SWIG_fail;
29157 {
29158 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29159 if (SWIG_arg_fail(2)) SWIG_fail;
29160 }
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 (arg1)->SetDefaultAction((wxDragResult )arg2);
29164
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 Py_INCREF(Py_None); resultobj = Py_None;
29169 return resultobj;
29170 fail:
29171 return NULL;
29172 }
29173
29174
29175 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29176 PyObject *resultobj;
29177 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29178 wxDragResult result;
29179 PyObject * obj0 = 0 ;
29180 char *kwnames[] = {
29181 (char *) "self", NULL
29182 };
29183
29184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29186 if (SWIG_arg_fail(1)) SWIG_fail;
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 result = (wxDragResult)(arg1)->GetDefaultAction();
29190
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 resultobj = SWIG_From_int((result));
29195 return resultobj;
29196 fail:
29197 return NULL;
29198 }
29199
29200
29201 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29202 PyObject *obj;
29203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29204 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29205 Py_INCREF(obj);
29206 return Py_BuildValue((char *)"");
29207 }
29208 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29209 PyObject *resultobj;
29210 wxPyTextDropTarget *result;
29211 char *kwnames[] = {
29212 NULL
29213 };
29214
29215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29216 {
29217 PyThreadState* __tstate = wxPyBeginAllowThreads();
29218 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29219
29220 wxPyEndAllowThreads(__tstate);
29221 if (PyErr_Occurred()) SWIG_fail;
29222 }
29223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29224 return resultobj;
29225 fail:
29226 return NULL;
29227 }
29228
29229
29230 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29231 PyObject *resultobj;
29232 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29233 PyObject *arg2 = (PyObject *) 0 ;
29234 PyObject *arg3 = (PyObject *) 0 ;
29235 PyObject * obj0 = 0 ;
29236 PyObject * obj1 = 0 ;
29237 PyObject * obj2 = 0 ;
29238 char *kwnames[] = {
29239 (char *) "self",(char *) "self",(char *) "_class", NULL
29240 };
29241
29242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29244 if (SWIG_arg_fail(1)) SWIG_fail;
29245 arg2 = obj1;
29246 arg3 = obj2;
29247 {
29248 PyThreadState* __tstate = wxPyBeginAllowThreads();
29249 (arg1)->_setCallbackInfo(arg2,arg3);
29250
29251 wxPyEndAllowThreads(__tstate);
29252 if (PyErr_Occurred()) SWIG_fail;
29253 }
29254 Py_INCREF(Py_None); resultobj = Py_None;
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29262 PyObject *resultobj;
29263 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29264 int arg2 ;
29265 int arg3 ;
29266 wxDragResult arg4 ;
29267 wxDragResult result;
29268 PyObject * obj0 = 0 ;
29269 PyObject * obj1 = 0 ;
29270 PyObject * obj2 = 0 ;
29271 PyObject * obj3 = 0 ;
29272 char *kwnames[] = {
29273 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29274 };
29275
29276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29278 if (SWIG_arg_fail(1)) SWIG_fail;
29279 {
29280 arg2 = (int)(SWIG_As_int(obj1));
29281 if (SWIG_arg_fail(2)) SWIG_fail;
29282 }
29283 {
29284 arg3 = (int)(SWIG_As_int(obj2));
29285 if (SWIG_arg_fail(3)) SWIG_fail;
29286 }
29287 {
29288 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29289 if (SWIG_arg_fail(4)) SWIG_fail;
29290 }
29291 {
29292 PyThreadState* __tstate = wxPyBeginAllowThreads();
29293 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29294
29295 wxPyEndAllowThreads(__tstate);
29296 if (PyErr_Occurred()) SWIG_fail;
29297 }
29298 resultobj = SWIG_From_int((result));
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29306 PyObject *resultobj;
29307 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29308 int arg2 ;
29309 int arg3 ;
29310 wxDragResult arg4 ;
29311 wxDragResult result;
29312 PyObject * obj0 = 0 ;
29313 PyObject * obj1 = 0 ;
29314 PyObject * obj2 = 0 ;
29315 PyObject * obj3 = 0 ;
29316 char *kwnames[] = {
29317 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29318 };
29319
29320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29322 if (SWIG_arg_fail(1)) SWIG_fail;
29323 {
29324 arg2 = (int)(SWIG_As_int(obj1));
29325 if (SWIG_arg_fail(2)) SWIG_fail;
29326 }
29327 {
29328 arg3 = (int)(SWIG_As_int(obj2));
29329 if (SWIG_arg_fail(3)) SWIG_fail;
29330 }
29331 {
29332 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29333 if (SWIG_arg_fail(4)) SWIG_fail;
29334 }
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29338
29339 wxPyEndAllowThreads(__tstate);
29340 if (PyErr_Occurred()) SWIG_fail;
29341 }
29342 resultobj = SWIG_From_int((result));
29343 return resultobj;
29344 fail:
29345 return NULL;
29346 }
29347
29348
29349 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29350 PyObject *resultobj;
29351 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29352 PyObject * obj0 = 0 ;
29353 char *kwnames[] = {
29354 (char *) "self", NULL
29355 };
29356
29357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29359 if (SWIG_arg_fail(1)) SWIG_fail;
29360 {
29361 PyThreadState* __tstate = wxPyBeginAllowThreads();
29362 (arg1)->base_OnLeave();
29363
29364 wxPyEndAllowThreads(__tstate);
29365 if (PyErr_Occurred()) SWIG_fail;
29366 }
29367 Py_INCREF(Py_None); resultobj = Py_None;
29368 return resultobj;
29369 fail:
29370 return NULL;
29371 }
29372
29373
29374 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29375 PyObject *resultobj;
29376 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29377 int arg2 ;
29378 int arg3 ;
29379 bool result;
29380 PyObject * obj0 = 0 ;
29381 PyObject * obj1 = 0 ;
29382 PyObject * obj2 = 0 ;
29383 char *kwnames[] = {
29384 (char *) "self",(char *) "x",(char *) "y", NULL
29385 };
29386
29387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29389 if (SWIG_arg_fail(1)) SWIG_fail;
29390 {
29391 arg2 = (int)(SWIG_As_int(obj1));
29392 if (SWIG_arg_fail(2)) SWIG_fail;
29393 }
29394 {
29395 arg3 = (int)(SWIG_As_int(obj2));
29396 if (SWIG_arg_fail(3)) SWIG_fail;
29397 }
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29401
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 {
29406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29407 }
29408 return resultobj;
29409 fail:
29410 return NULL;
29411 }
29412
29413
29414 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29415 PyObject *resultobj;
29416 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29417 int arg2 ;
29418 int arg3 ;
29419 wxDragResult arg4 ;
29420 wxDragResult result;
29421 PyObject * obj0 = 0 ;
29422 PyObject * obj1 = 0 ;
29423 PyObject * obj2 = 0 ;
29424 PyObject * obj3 = 0 ;
29425 char *kwnames[] = {
29426 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29427 };
29428
29429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29431 if (SWIG_arg_fail(1)) SWIG_fail;
29432 {
29433 arg2 = (int)(SWIG_As_int(obj1));
29434 if (SWIG_arg_fail(2)) SWIG_fail;
29435 }
29436 {
29437 arg3 = (int)(SWIG_As_int(obj2));
29438 if (SWIG_arg_fail(3)) SWIG_fail;
29439 }
29440 {
29441 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29442 if (SWIG_arg_fail(4)) SWIG_fail;
29443 }
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29447
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 resultobj = SWIG_From_int((result));
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29459 PyObject *obj;
29460 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29461 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29462 Py_INCREF(obj);
29463 return Py_BuildValue((char *)"");
29464 }
29465 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29466 PyObject *resultobj;
29467 wxPyFileDropTarget *result;
29468 char *kwnames[] = {
29469 NULL
29470 };
29471
29472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29473 {
29474 PyThreadState* __tstate = wxPyBeginAllowThreads();
29475 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29476
29477 wxPyEndAllowThreads(__tstate);
29478 if (PyErr_Occurred()) SWIG_fail;
29479 }
29480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29481 return resultobj;
29482 fail:
29483 return NULL;
29484 }
29485
29486
29487 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29488 PyObject *resultobj;
29489 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29490 PyObject *arg2 = (PyObject *) 0 ;
29491 PyObject *arg3 = (PyObject *) 0 ;
29492 PyObject * obj0 = 0 ;
29493 PyObject * obj1 = 0 ;
29494 PyObject * obj2 = 0 ;
29495 char *kwnames[] = {
29496 (char *) "self",(char *) "self",(char *) "_class", NULL
29497 };
29498
29499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29501 if (SWIG_arg_fail(1)) SWIG_fail;
29502 arg2 = obj1;
29503 arg3 = obj2;
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 (arg1)->_setCallbackInfo(arg2,arg3);
29507
29508 wxPyEndAllowThreads(__tstate);
29509 if (PyErr_Occurred()) SWIG_fail;
29510 }
29511 Py_INCREF(Py_None); resultobj = Py_None;
29512 return resultobj;
29513 fail:
29514 return NULL;
29515 }
29516
29517
29518 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29519 PyObject *resultobj;
29520 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29521 int arg2 ;
29522 int arg3 ;
29523 wxDragResult arg4 ;
29524 wxDragResult result;
29525 PyObject * obj0 = 0 ;
29526 PyObject * obj1 = 0 ;
29527 PyObject * obj2 = 0 ;
29528 PyObject * obj3 = 0 ;
29529 char *kwnames[] = {
29530 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29531 };
29532
29533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29535 if (SWIG_arg_fail(1)) SWIG_fail;
29536 {
29537 arg2 = (int)(SWIG_As_int(obj1));
29538 if (SWIG_arg_fail(2)) SWIG_fail;
29539 }
29540 {
29541 arg3 = (int)(SWIG_As_int(obj2));
29542 if (SWIG_arg_fail(3)) SWIG_fail;
29543 }
29544 {
29545 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29546 if (SWIG_arg_fail(4)) SWIG_fail;
29547 }
29548 {
29549 PyThreadState* __tstate = wxPyBeginAllowThreads();
29550 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29551
29552 wxPyEndAllowThreads(__tstate);
29553 if (PyErr_Occurred()) SWIG_fail;
29554 }
29555 resultobj = SWIG_From_int((result));
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29563 PyObject *resultobj;
29564 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29565 int arg2 ;
29566 int arg3 ;
29567 wxDragResult arg4 ;
29568 wxDragResult result;
29569 PyObject * obj0 = 0 ;
29570 PyObject * obj1 = 0 ;
29571 PyObject * obj2 = 0 ;
29572 PyObject * obj3 = 0 ;
29573 char *kwnames[] = {
29574 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29575 };
29576
29577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29579 if (SWIG_arg_fail(1)) SWIG_fail;
29580 {
29581 arg2 = (int)(SWIG_As_int(obj1));
29582 if (SWIG_arg_fail(2)) SWIG_fail;
29583 }
29584 {
29585 arg3 = (int)(SWIG_As_int(obj2));
29586 if (SWIG_arg_fail(3)) SWIG_fail;
29587 }
29588 {
29589 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29590 if (SWIG_arg_fail(4)) SWIG_fail;
29591 }
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29595
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 resultobj = SWIG_From_int((result));
29600 return resultobj;
29601 fail:
29602 return NULL;
29603 }
29604
29605
29606 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29607 PyObject *resultobj;
29608 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29609 PyObject * obj0 = 0 ;
29610 char *kwnames[] = {
29611 (char *) "self", NULL
29612 };
29613
29614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29616 if (SWIG_arg_fail(1)) SWIG_fail;
29617 {
29618 PyThreadState* __tstate = wxPyBeginAllowThreads();
29619 (arg1)->base_OnLeave();
29620
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 Py_INCREF(Py_None); resultobj = Py_None;
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj;
29633 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29634 int arg2 ;
29635 int arg3 ;
29636 bool result;
29637 PyObject * obj0 = 0 ;
29638 PyObject * obj1 = 0 ;
29639 PyObject * obj2 = 0 ;
29640 char *kwnames[] = {
29641 (char *) "self",(char *) "x",(char *) "y", NULL
29642 };
29643
29644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29646 if (SWIG_arg_fail(1)) SWIG_fail;
29647 {
29648 arg2 = (int)(SWIG_As_int(obj1));
29649 if (SWIG_arg_fail(2)) SWIG_fail;
29650 }
29651 {
29652 arg3 = (int)(SWIG_As_int(obj2));
29653 if (SWIG_arg_fail(3)) SWIG_fail;
29654 }
29655 {
29656 PyThreadState* __tstate = wxPyBeginAllowThreads();
29657 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29658
29659 wxPyEndAllowThreads(__tstate);
29660 if (PyErr_Occurred()) SWIG_fail;
29661 }
29662 {
29663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29664 }
29665 return resultobj;
29666 fail:
29667 return NULL;
29668 }
29669
29670
29671 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29672 PyObject *resultobj;
29673 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29674 int arg2 ;
29675 int arg3 ;
29676 wxDragResult arg4 ;
29677 wxDragResult result;
29678 PyObject * obj0 = 0 ;
29679 PyObject * obj1 = 0 ;
29680 PyObject * obj2 = 0 ;
29681 PyObject * obj3 = 0 ;
29682 char *kwnames[] = {
29683 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29684 };
29685
29686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29688 if (SWIG_arg_fail(1)) SWIG_fail;
29689 {
29690 arg2 = (int)(SWIG_As_int(obj1));
29691 if (SWIG_arg_fail(2)) SWIG_fail;
29692 }
29693 {
29694 arg3 = (int)(SWIG_As_int(obj2));
29695 if (SWIG_arg_fail(3)) SWIG_fail;
29696 }
29697 {
29698 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29699 if (SWIG_arg_fail(4)) SWIG_fail;
29700 }
29701 {
29702 PyThreadState* __tstate = wxPyBeginAllowThreads();
29703 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29704
29705 wxPyEndAllowThreads(__tstate);
29706 if (PyErr_Occurred()) SWIG_fail;
29707 }
29708 resultobj = SWIG_From_int((result));
29709 return resultobj;
29710 fail:
29711 return NULL;
29712 }
29713
29714
29715 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29716 PyObject *obj;
29717 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29718 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29719 Py_INCREF(obj);
29720 return Py_BuildValue((char *)"");
29721 }
29722 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29723 PyObject *resultobj;
29724 wxClipboard *result;
29725 char *kwnames[] = {
29726 NULL
29727 };
29728
29729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29730 {
29731 PyThreadState* __tstate = wxPyBeginAllowThreads();
29732 result = (wxClipboard *)new wxClipboard();
29733
29734 wxPyEndAllowThreads(__tstate);
29735 if (PyErr_Occurred()) SWIG_fail;
29736 }
29737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29738 return resultobj;
29739 fail:
29740 return NULL;
29741 }
29742
29743
29744 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29745 PyObject *resultobj;
29746 wxClipboard *arg1 = (wxClipboard *) 0 ;
29747 PyObject * obj0 = 0 ;
29748 char *kwnames[] = {
29749 (char *) "self", NULL
29750 };
29751
29752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29754 if (SWIG_arg_fail(1)) SWIG_fail;
29755 {
29756 PyThreadState* __tstate = wxPyBeginAllowThreads();
29757 delete arg1;
29758
29759 wxPyEndAllowThreads(__tstate);
29760 if (PyErr_Occurred()) SWIG_fail;
29761 }
29762 Py_INCREF(Py_None); resultobj = Py_None;
29763 return resultobj;
29764 fail:
29765 return NULL;
29766 }
29767
29768
29769 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29770 PyObject *resultobj;
29771 wxClipboard *arg1 = (wxClipboard *) 0 ;
29772 bool result;
29773 PyObject * obj0 = 0 ;
29774 char *kwnames[] = {
29775 (char *) "self", NULL
29776 };
29777
29778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29780 if (SWIG_arg_fail(1)) SWIG_fail;
29781 {
29782 PyThreadState* __tstate = wxPyBeginAllowThreads();
29783 result = (bool)(arg1)->Open();
29784
29785 wxPyEndAllowThreads(__tstate);
29786 if (PyErr_Occurred()) SWIG_fail;
29787 }
29788 {
29789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29790 }
29791 return resultobj;
29792 fail:
29793 return NULL;
29794 }
29795
29796
29797 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29798 PyObject *resultobj;
29799 wxClipboard *arg1 = (wxClipboard *) 0 ;
29800 PyObject * obj0 = 0 ;
29801 char *kwnames[] = {
29802 (char *) "self", NULL
29803 };
29804
29805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29807 if (SWIG_arg_fail(1)) SWIG_fail;
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 (arg1)->Close();
29811
29812 wxPyEndAllowThreads(__tstate);
29813 if (PyErr_Occurred()) SWIG_fail;
29814 }
29815 Py_INCREF(Py_None); resultobj = Py_None;
29816 return resultobj;
29817 fail:
29818 return NULL;
29819 }
29820
29821
29822 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29823 PyObject *resultobj;
29824 wxClipboard *arg1 = (wxClipboard *) 0 ;
29825 bool result;
29826 PyObject * obj0 = 0 ;
29827 char *kwnames[] = {
29828 (char *) "self", NULL
29829 };
29830
29831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29833 if (SWIG_arg_fail(1)) SWIG_fail;
29834 {
29835 PyThreadState* __tstate = wxPyBeginAllowThreads();
29836 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29837
29838 wxPyEndAllowThreads(__tstate);
29839 if (PyErr_Occurred()) SWIG_fail;
29840 }
29841 {
29842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29843 }
29844 return resultobj;
29845 fail:
29846 return NULL;
29847 }
29848
29849
29850 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29851 PyObject *resultobj;
29852 wxClipboard *arg1 = (wxClipboard *) 0 ;
29853 wxDataObject *arg2 = (wxDataObject *) 0 ;
29854 bool result;
29855 PyObject * obj0 = 0 ;
29856 PyObject * obj1 = 0 ;
29857 char *kwnames[] = {
29858 (char *) "self",(char *) "data", NULL
29859 };
29860
29861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29863 if (SWIG_arg_fail(1)) SWIG_fail;
29864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29865 if (SWIG_arg_fail(2)) SWIG_fail;
29866 {
29867 PyThreadState* __tstate = wxPyBeginAllowThreads();
29868 result = (bool)(arg1)->AddData(arg2);
29869
29870 wxPyEndAllowThreads(__tstate);
29871 if (PyErr_Occurred()) SWIG_fail;
29872 }
29873 {
29874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29875 }
29876 return resultobj;
29877 fail:
29878 return NULL;
29879 }
29880
29881
29882 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29883 PyObject *resultobj;
29884 wxClipboard *arg1 = (wxClipboard *) 0 ;
29885 wxDataObject *arg2 = (wxDataObject *) 0 ;
29886 bool result;
29887 PyObject * obj0 = 0 ;
29888 PyObject * obj1 = 0 ;
29889 char *kwnames[] = {
29890 (char *) "self",(char *) "data", NULL
29891 };
29892
29893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29895 if (SWIG_arg_fail(1)) SWIG_fail;
29896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29897 if (SWIG_arg_fail(2)) SWIG_fail;
29898 {
29899 PyThreadState* __tstate = wxPyBeginAllowThreads();
29900 result = (bool)(arg1)->SetData(arg2);
29901
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 {
29906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29907 }
29908 return resultobj;
29909 fail:
29910 return NULL;
29911 }
29912
29913
29914 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29915 PyObject *resultobj;
29916 wxClipboard *arg1 = (wxClipboard *) 0 ;
29917 wxDataFormat *arg2 = 0 ;
29918 bool result;
29919 PyObject * obj0 = 0 ;
29920 PyObject * obj1 = 0 ;
29921 char *kwnames[] = {
29922 (char *) "self",(char *) "format", NULL
29923 };
29924
29925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29927 if (SWIG_arg_fail(1)) SWIG_fail;
29928 {
29929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29930 if (SWIG_arg_fail(2)) SWIG_fail;
29931 if (arg2 == NULL) {
29932 SWIG_null_ref("wxDataFormat");
29933 }
29934 if (SWIG_arg_fail(2)) SWIG_fail;
29935 }
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29939
29940 wxPyEndAllowThreads(__tstate);
29941 if (PyErr_Occurred()) SWIG_fail;
29942 }
29943 {
29944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29945 }
29946 return resultobj;
29947 fail:
29948 return NULL;
29949 }
29950
29951
29952 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29953 PyObject *resultobj;
29954 wxClipboard *arg1 = (wxClipboard *) 0 ;
29955 wxDataObject *arg2 = 0 ;
29956 bool result;
29957 PyObject * obj0 = 0 ;
29958 PyObject * obj1 = 0 ;
29959 char *kwnames[] = {
29960 (char *) "self",(char *) "data", NULL
29961 };
29962
29963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29965 if (SWIG_arg_fail(1)) SWIG_fail;
29966 {
29967 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29968 if (SWIG_arg_fail(2)) SWIG_fail;
29969 if (arg2 == NULL) {
29970 SWIG_null_ref("wxDataObject");
29971 }
29972 if (SWIG_arg_fail(2)) SWIG_fail;
29973 }
29974 {
29975 PyThreadState* __tstate = wxPyBeginAllowThreads();
29976 result = (bool)(arg1)->GetData(*arg2);
29977
29978 wxPyEndAllowThreads(__tstate);
29979 if (PyErr_Occurred()) SWIG_fail;
29980 }
29981 {
29982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29983 }
29984 return resultobj;
29985 fail:
29986 return NULL;
29987 }
29988
29989
29990 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29991 PyObject *resultobj;
29992 wxClipboard *arg1 = (wxClipboard *) 0 ;
29993 PyObject * obj0 = 0 ;
29994 char *kwnames[] = {
29995 (char *) "self", NULL
29996 };
29997
29998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30000 if (SWIG_arg_fail(1)) SWIG_fail;
30001 {
30002 PyThreadState* __tstate = wxPyBeginAllowThreads();
30003 (arg1)->Clear();
30004
30005 wxPyEndAllowThreads(__tstate);
30006 if (PyErr_Occurred()) SWIG_fail;
30007 }
30008 Py_INCREF(Py_None); resultobj = Py_None;
30009 return resultobj;
30010 fail:
30011 return NULL;
30012 }
30013
30014
30015 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30016 PyObject *resultobj;
30017 wxClipboard *arg1 = (wxClipboard *) 0 ;
30018 bool result;
30019 PyObject * obj0 = 0 ;
30020 char *kwnames[] = {
30021 (char *) "self", NULL
30022 };
30023
30024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30026 if (SWIG_arg_fail(1)) SWIG_fail;
30027 {
30028 PyThreadState* __tstate = wxPyBeginAllowThreads();
30029 result = (bool)(arg1)->Flush();
30030
30031 wxPyEndAllowThreads(__tstate);
30032 if (PyErr_Occurred()) SWIG_fail;
30033 }
30034 {
30035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30036 }
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30044 PyObject *resultobj;
30045 wxClipboard *arg1 = (wxClipboard *) 0 ;
30046 bool arg2 = (bool) true ;
30047 PyObject * obj0 = 0 ;
30048 PyObject * obj1 = 0 ;
30049 char *kwnames[] = {
30050 (char *) "self",(char *) "primary", NULL
30051 };
30052
30053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30055 if (SWIG_arg_fail(1)) SWIG_fail;
30056 if (obj1) {
30057 {
30058 arg2 = (bool)(SWIG_As_bool(obj1));
30059 if (SWIG_arg_fail(2)) SWIG_fail;
30060 }
30061 }
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 (arg1)->UsePrimarySelection(arg2);
30065
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 Py_INCREF(Py_None); resultobj = Py_None;
30070 return resultobj;
30071 fail:
30072 return NULL;
30073 }
30074
30075
30076 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30077 PyObject *resultobj;
30078 wxClipboard *result;
30079 char *kwnames[] = {
30080 NULL
30081 };
30082
30083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 result = (wxClipboard *)wxClipboard::Get();
30087
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30099 PyObject *obj;
30100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30101 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30102 Py_INCREF(obj);
30103 return Py_BuildValue((char *)"");
30104 }
30105 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30106 PyObject *resultobj;
30107 wxClipboard *arg1 = (wxClipboard *) NULL ;
30108 wxClipboardLocker *result;
30109 PyObject * obj0 = 0 ;
30110 char *kwnames[] = {
30111 (char *) "clipboard", NULL
30112 };
30113
30114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30115 if (obj0) {
30116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30117 if (SWIG_arg_fail(1)) SWIG_fail;
30118 }
30119 {
30120 PyThreadState* __tstate = wxPyBeginAllowThreads();
30121 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30122
30123 wxPyEndAllowThreads(__tstate);
30124 if (PyErr_Occurred()) SWIG_fail;
30125 }
30126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30127 return resultobj;
30128 fail:
30129 return NULL;
30130 }
30131
30132
30133 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30134 PyObject *resultobj;
30135 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30136 PyObject * obj0 = 0 ;
30137 char *kwnames[] = {
30138 (char *) "self", NULL
30139 };
30140
30141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30143 if (SWIG_arg_fail(1)) SWIG_fail;
30144 {
30145 PyThreadState* __tstate = wxPyBeginAllowThreads();
30146 delete arg1;
30147
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 Py_INCREF(Py_None); resultobj = Py_None;
30152 return resultobj;
30153 fail:
30154 return NULL;
30155 }
30156
30157
30158 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30159 PyObject *resultobj;
30160 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30161 bool result;
30162 PyObject * obj0 = 0 ;
30163 char *kwnames[] = {
30164 (char *) "self", NULL
30165 };
30166
30167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30169 if (SWIG_arg_fail(1)) SWIG_fail;
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = (bool)wxClipboardLocker___nonzero__(arg1);
30173
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 {
30178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30179 }
30180 return resultobj;
30181 fail:
30182 return NULL;
30183 }
30184
30185
30186 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30187 PyObject *obj;
30188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30189 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30190 Py_INCREF(obj);
30191 return Py_BuildValue((char *)"");
30192 }
30193 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30194 PyObject *resultobj;
30195 int arg1 = (int) 0 ;
30196 int arg2 = (int) 0 ;
30197 int arg3 = (int) 0 ;
30198 int arg4 = (int) 0 ;
30199 wxVideoMode *result;
30200 PyObject * obj0 = 0 ;
30201 PyObject * obj1 = 0 ;
30202 PyObject * obj2 = 0 ;
30203 PyObject * obj3 = 0 ;
30204 char *kwnames[] = {
30205 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30206 };
30207
30208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30209 if (obj0) {
30210 {
30211 arg1 = (int)(SWIG_As_int(obj0));
30212 if (SWIG_arg_fail(1)) SWIG_fail;
30213 }
30214 }
30215 if (obj1) {
30216 {
30217 arg2 = (int)(SWIG_As_int(obj1));
30218 if (SWIG_arg_fail(2)) SWIG_fail;
30219 }
30220 }
30221 if (obj2) {
30222 {
30223 arg3 = (int)(SWIG_As_int(obj2));
30224 if (SWIG_arg_fail(3)) SWIG_fail;
30225 }
30226 }
30227 if (obj3) {
30228 {
30229 arg4 = (int)(SWIG_As_int(obj3));
30230 if (SWIG_arg_fail(4)) SWIG_fail;
30231 }
30232 }
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30236
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30241 return resultobj;
30242 fail:
30243 return NULL;
30244 }
30245
30246
30247 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30248 PyObject *resultobj;
30249 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30250 PyObject * obj0 = 0 ;
30251 char *kwnames[] = {
30252 (char *) "self", NULL
30253 };
30254
30255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30257 if (SWIG_arg_fail(1)) SWIG_fail;
30258 {
30259 PyThreadState* __tstate = wxPyBeginAllowThreads();
30260 delete arg1;
30261
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 Py_INCREF(Py_None); resultobj = Py_None;
30266 return resultobj;
30267 fail:
30268 return NULL;
30269 }
30270
30271
30272 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30273 PyObject *resultobj;
30274 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30275 wxVideoMode *arg2 = 0 ;
30276 bool result;
30277 PyObject * obj0 = 0 ;
30278 PyObject * obj1 = 0 ;
30279 char *kwnames[] = {
30280 (char *) "self",(char *) "other", NULL
30281 };
30282
30283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30285 if (SWIG_arg_fail(1)) SWIG_fail;
30286 {
30287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30288 if (SWIG_arg_fail(2)) SWIG_fail;
30289 if (arg2 == NULL) {
30290 SWIG_null_ref("wxVideoMode");
30291 }
30292 if (SWIG_arg_fail(2)) SWIG_fail;
30293 }
30294 {
30295 PyThreadState* __tstate = wxPyBeginAllowThreads();
30296 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30297
30298 wxPyEndAllowThreads(__tstate);
30299 if (PyErr_Occurred()) SWIG_fail;
30300 }
30301 {
30302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30303 }
30304 return resultobj;
30305 fail:
30306 return NULL;
30307 }
30308
30309
30310 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30311 PyObject *resultobj;
30312 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30313 int result;
30314 PyObject * obj0 = 0 ;
30315 char *kwnames[] = {
30316 (char *) "self", NULL
30317 };
30318
30319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30321 if (SWIG_arg_fail(1)) SWIG_fail;
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30325
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 {
30330 resultobj = SWIG_From_int((int)(result));
30331 }
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30339 PyObject *resultobj;
30340 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30341 int result;
30342 PyObject * obj0 = 0 ;
30343 char *kwnames[] = {
30344 (char *) "self", NULL
30345 };
30346
30347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30349 if (SWIG_arg_fail(1)) SWIG_fail;
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30353
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 {
30358 resultobj = SWIG_From_int((int)(result));
30359 }
30360 return resultobj;
30361 fail:
30362 return NULL;
30363 }
30364
30365
30366 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30367 PyObject *resultobj;
30368 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30369 int result;
30370 PyObject * obj0 = 0 ;
30371 char *kwnames[] = {
30372 (char *) "self", NULL
30373 };
30374
30375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30377 if (SWIG_arg_fail(1)) SWIG_fail;
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30381
30382 wxPyEndAllowThreads(__tstate);
30383 if (PyErr_Occurred()) SWIG_fail;
30384 }
30385 {
30386 resultobj = SWIG_From_int((int)(result));
30387 }
30388 return resultobj;
30389 fail:
30390 return NULL;
30391 }
30392
30393
30394 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30395 PyObject *resultobj;
30396 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30397 bool result;
30398 PyObject * obj0 = 0 ;
30399 char *kwnames[] = {
30400 (char *) "self", NULL
30401 };
30402
30403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30405 if (SWIG_arg_fail(1)) SWIG_fail;
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30409
30410 wxPyEndAllowThreads(__tstate);
30411 if (PyErr_Occurred()) SWIG_fail;
30412 }
30413 {
30414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30415 }
30416 return resultobj;
30417 fail:
30418 return NULL;
30419 }
30420
30421
30422 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30423 PyObject *resultobj;
30424 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30425 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30426 bool result;
30427 PyObject * obj0 = 0 ;
30428 PyObject * obj1 = 0 ;
30429 char *kwnames[] = {
30430 (char *) "self",(char *) "other", NULL
30431 };
30432
30433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30435 if (SWIG_arg_fail(1)) SWIG_fail;
30436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30437 if (SWIG_arg_fail(2)) SWIG_fail;
30438 {
30439 PyThreadState* __tstate = wxPyBeginAllowThreads();
30440 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30441
30442 wxPyEndAllowThreads(__tstate);
30443 if (PyErr_Occurred()) SWIG_fail;
30444 }
30445 {
30446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30447 }
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30455 PyObject *resultobj;
30456 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30457 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30458 bool result;
30459 PyObject * obj0 = 0 ;
30460 PyObject * obj1 = 0 ;
30461 char *kwnames[] = {
30462 (char *) "self",(char *) "other", NULL
30463 };
30464
30465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30467 if (SWIG_arg_fail(1)) SWIG_fail;
30468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30469 if (SWIG_arg_fail(2)) SWIG_fail;
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30473
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 {
30478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30479 }
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj;
30488 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30489 int arg2 ;
30490 PyObject * obj0 = 0 ;
30491 PyObject * obj1 = 0 ;
30492 char *kwnames[] = {
30493 (char *) "self",(char *) "w", NULL
30494 };
30495
30496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30498 if (SWIG_arg_fail(1)) SWIG_fail;
30499 {
30500 arg2 = (int)(SWIG_As_int(obj1));
30501 if (SWIG_arg_fail(2)) SWIG_fail;
30502 }
30503 if (arg1) (arg1)->w = arg2;
30504
30505 Py_INCREF(Py_None); resultobj = Py_None;
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30513 PyObject *resultobj;
30514 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30515 int result;
30516 PyObject * obj0 = 0 ;
30517 char *kwnames[] = {
30518 (char *) "self", NULL
30519 };
30520
30521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30523 if (SWIG_arg_fail(1)) SWIG_fail;
30524 result = (int) ((arg1)->w);
30525
30526 {
30527 resultobj = SWIG_From_int((int)(result));
30528 }
30529 return resultobj;
30530 fail:
30531 return NULL;
30532 }
30533
30534
30535 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30536 PyObject *resultobj;
30537 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30538 int arg2 ;
30539 PyObject * obj0 = 0 ;
30540 PyObject * obj1 = 0 ;
30541 char *kwnames[] = {
30542 (char *) "self",(char *) "h", NULL
30543 };
30544
30545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30547 if (SWIG_arg_fail(1)) SWIG_fail;
30548 {
30549 arg2 = (int)(SWIG_As_int(obj1));
30550 if (SWIG_arg_fail(2)) SWIG_fail;
30551 }
30552 if (arg1) (arg1)->h = arg2;
30553
30554 Py_INCREF(Py_None); resultobj = Py_None;
30555 return resultobj;
30556 fail:
30557 return NULL;
30558 }
30559
30560
30561 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30562 PyObject *resultobj;
30563 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30564 int result;
30565 PyObject * obj0 = 0 ;
30566 char *kwnames[] = {
30567 (char *) "self", NULL
30568 };
30569
30570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30572 if (SWIG_arg_fail(1)) SWIG_fail;
30573 result = (int) ((arg1)->h);
30574
30575 {
30576 resultobj = SWIG_From_int((int)(result));
30577 }
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30585 PyObject *resultobj;
30586 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30587 int arg2 ;
30588 PyObject * obj0 = 0 ;
30589 PyObject * obj1 = 0 ;
30590 char *kwnames[] = {
30591 (char *) "self",(char *) "bpp", NULL
30592 };
30593
30594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30596 if (SWIG_arg_fail(1)) SWIG_fail;
30597 {
30598 arg2 = (int)(SWIG_As_int(obj1));
30599 if (SWIG_arg_fail(2)) SWIG_fail;
30600 }
30601 if (arg1) (arg1)->bpp = arg2;
30602
30603 Py_INCREF(Py_None); resultobj = Py_None;
30604 return resultobj;
30605 fail:
30606 return NULL;
30607 }
30608
30609
30610 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30611 PyObject *resultobj;
30612 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30613 int result;
30614 PyObject * obj0 = 0 ;
30615 char *kwnames[] = {
30616 (char *) "self", NULL
30617 };
30618
30619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30621 if (SWIG_arg_fail(1)) SWIG_fail;
30622 result = (int) ((arg1)->bpp);
30623
30624 {
30625 resultobj = SWIG_From_int((int)(result));
30626 }
30627 return resultobj;
30628 fail:
30629 return NULL;
30630 }
30631
30632
30633 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30634 PyObject *resultobj;
30635 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30636 int arg2 ;
30637 PyObject * obj0 = 0 ;
30638 PyObject * obj1 = 0 ;
30639 char *kwnames[] = {
30640 (char *) "self",(char *) "refresh", NULL
30641 };
30642
30643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30645 if (SWIG_arg_fail(1)) SWIG_fail;
30646 {
30647 arg2 = (int)(SWIG_As_int(obj1));
30648 if (SWIG_arg_fail(2)) SWIG_fail;
30649 }
30650 if (arg1) (arg1)->refresh = arg2;
30651
30652 Py_INCREF(Py_None); resultobj = Py_None;
30653 return resultobj;
30654 fail:
30655 return NULL;
30656 }
30657
30658
30659 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30660 PyObject *resultobj;
30661 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30662 int result;
30663 PyObject * obj0 = 0 ;
30664 char *kwnames[] = {
30665 (char *) "self", NULL
30666 };
30667
30668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30670 if (SWIG_arg_fail(1)) SWIG_fail;
30671 result = (int) ((arg1)->refresh);
30672
30673 {
30674 resultobj = SWIG_From_int((int)(result));
30675 }
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30683 PyObject *obj;
30684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30685 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30686 Py_INCREF(obj);
30687 return Py_BuildValue((char *)"");
30688 }
30689 static int _wrap_DefaultVideoMode_set(PyObject *) {
30690 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30691 return 1;
30692 }
30693
30694
30695 static PyObject *_wrap_DefaultVideoMode_get(void) {
30696 PyObject *pyobj;
30697
30698 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30699 return pyobj;
30700 }
30701
30702
30703 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30704 PyObject *resultobj;
30705 size_t arg1 = (size_t) 0 ;
30706 wxDisplay *result;
30707 PyObject * obj0 = 0 ;
30708 char *kwnames[] = {
30709 (char *) "index", NULL
30710 };
30711
30712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30713 if (obj0) {
30714 {
30715 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30716 if (SWIG_arg_fail(1)) SWIG_fail;
30717 }
30718 }
30719 {
30720 PyThreadState* __tstate = wxPyBeginAllowThreads();
30721 result = (wxDisplay *)new wxDisplay(arg1);
30722
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30734 PyObject *resultobj;
30735 wxDisplay *arg1 = (wxDisplay *) 0 ;
30736 PyObject * obj0 = 0 ;
30737 char *kwnames[] = {
30738 (char *) "self", NULL
30739 };
30740
30741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30743 if (SWIG_arg_fail(1)) SWIG_fail;
30744 {
30745 PyThreadState* __tstate = wxPyBeginAllowThreads();
30746 delete arg1;
30747
30748 wxPyEndAllowThreads(__tstate);
30749 if (PyErr_Occurred()) SWIG_fail;
30750 }
30751 Py_INCREF(Py_None); resultobj = Py_None;
30752 return resultobj;
30753 fail:
30754 return NULL;
30755 }
30756
30757
30758 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30759 PyObject *resultobj;
30760 size_t result;
30761 char *kwnames[] = {
30762 NULL
30763 };
30764
30765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30766 {
30767 PyThreadState* __tstate = wxPyBeginAllowThreads();
30768 result = (size_t)wxDisplay::GetCount();
30769
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 {
30774 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30775 }
30776 return resultobj;
30777 fail:
30778 return NULL;
30779 }
30780
30781
30782 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30783 PyObject *resultobj;
30784 wxPoint *arg1 = 0 ;
30785 int result;
30786 wxPoint temp1 ;
30787 PyObject * obj0 = 0 ;
30788 char *kwnames[] = {
30789 (char *) "pt", NULL
30790 };
30791
30792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30793 {
30794 arg1 = &temp1;
30795 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30796 }
30797 {
30798 PyThreadState* __tstate = wxPyBeginAllowThreads();
30799 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30800
30801 wxPyEndAllowThreads(__tstate);
30802 if (PyErr_Occurred()) SWIG_fail;
30803 }
30804 {
30805 resultobj = SWIG_From_int((int)(result));
30806 }
30807 return resultobj;
30808 fail:
30809 return NULL;
30810 }
30811
30812
30813 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30814 PyObject *resultobj;
30815 wxWindow *arg1 = (wxWindow *) 0 ;
30816 int result;
30817 PyObject * obj0 = 0 ;
30818 char *kwnames[] = {
30819 (char *) "window", NULL
30820 };
30821
30822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30824 if (SWIG_arg_fail(1)) SWIG_fail;
30825 {
30826 PyThreadState* __tstate = wxPyBeginAllowThreads();
30827 result = (int)Display_GetFromWindow(arg1);
30828
30829 wxPyEndAllowThreads(__tstate);
30830 if (PyErr_Occurred()) SWIG_fail;
30831 }
30832 {
30833 resultobj = SWIG_From_int((int)(result));
30834 }
30835 return resultobj;
30836 fail:
30837 return NULL;
30838 }
30839
30840
30841 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30842 PyObject *resultobj;
30843 wxDisplay *arg1 = (wxDisplay *) 0 ;
30844 bool result;
30845 PyObject * obj0 = 0 ;
30846 char *kwnames[] = {
30847 (char *) "self", NULL
30848 };
30849
30850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30852 if (SWIG_arg_fail(1)) SWIG_fail;
30853 {
30854 PyThreadState* __tstate = wxPyBeginAllowThreads();
30855 result = (bool)((wxDisplay const *)arg1)->IsOk();
30856
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 {
30861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30862 }
30863 return resultobj;
30864 fail:
30865 return NULL;
30866 }
30867
30868
30869 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30870 PyObject *resultobj;
30871 wxDisplay *arg1 = (wxDisplay *) 0 ;
30872 wxRect result;
30873 PyObject * obj0 = 0 ;
30874 char *kwnames[] = {
30875 (char *) "self", NULL
30876 };
30877
30878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30880 if (SWIG_arg_fail(1)) SWIG_fail;
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = ((wxDisplay const *)arg1)->GetGeometry();
30884
30885 wxPyEndAllowThreads(__tstate);
30886 if (PyErr_Occurred()) SWIG_fail;
30887 }
30888 {
30889 wxRect * resultptr;
30890 resultptr = new wxRect((wxRect &)(result));
30891 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30892 }
30893 return resultobj;
30894 fail:
30895 return NULL;
30896 }
30897
30898
30899 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30900 PyObject *resultobj;
30901 wxDisplay *arg1 = (wxDisplay *) 0 ;
30902 wxString result;
30903 PyObject * obj0 = 0 ;
30904 char *kwnames[] = {
30905 (char *) "self", NULL
30906 };
30907
30908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30910 if (SWIG_arg_fail(1)) SWIG_fail;
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 result = ((wxDisplay const *)arg1)->GetName();
30914
30915 wxPyEndAllowThreads(__tstate);
30916 if (PyErr_Occurred()) SWIG_fail;
30917 }
30918 {
30919 #if wxUSE_UNICODE
30920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30921 #else
30922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30923 #endif
30924 }
30925 return resultobj;
30926 fail:
30927 return NULL;
30928 }
30929
30930
30931 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30932 PyObject *resultobj;
30933 wxDisplay *arg1 = (wxDisplay *) 0 ;
30934 bool result;
30935 PyObject * obj0 = 0 ;
30936 char *kwnames[] = {
30937 (char *) "self", NULL
30938 };
30939
30940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30942 if (SWIG_arg_fail(1)) SWIG_fail;
30943 {
30944 PyThreadState* __tstate = wxPyBeginAllowThreads();
30945 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30946
30947 wxPyEndAllowThreads(__tstate);
30948 if (PyErr_Occurred()) SWIG_fail;
30949 }
30950 {
30951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30952 }
30953 return resultobj;
30954 fail:
30955 return NULL;
30956 }
30957
30958
30959 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30960 PyObject *resultobj;
30961 wxDisplay *arg1 = (wxDisplay *) 0 ;
30962 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30963 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30964 PyObject *result;
30965 PyObject * obj0 = 0 ;
30966 PyObject * obj1 = 0 ;
30967 char *kwnames[] = {
30968 (char *) "self",(char *) "mode", NULL
30969 };
30970
30971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30973 if (SWIG_arg_fail(1)) SWIG_fail;
30974 if (obj1) {
30975 {
30976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30977 if (SWIG_arg_fail(2)) SWIG_fail;
30978 if (arg2 == NULL) {
30979 SWIG_null_ref("wxVideoMode");
30980 }
30981 if (SWIG_arg_fail(2)) SWIG_fail;
30982 }
30983 }
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30987
30988 wxPyEndAllowThreads(__tstate);
30989 if (PyErr_Occurred()) SWIG_fail;
30990 }
30991 resultobj = result;
30992 return resultobj;
30993 fail:
30994 return NULL;
30995 }
30996
30997
30998 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30999 PyObject *resultobj;
31000 wxDisplay *arg1 = (wxDisplay *) 0 ;
31001 wxVideoMode result;
31002 PyObject * obj0 = 0 ;
31003 char *kwnames[] = {
31004 (char *) "self", NULL
31005 };
31006
31007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31009 if (SWIG_arg_fail(1)) SWIG_fail;
31010 {
31011 PyThreadState* __tstate = wxPyBeginAllowThreads();
31012 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31013
31014 wxPyEndAllowThreads(__tstate);
31015 if (PyErr_Occurred()) SWIG_fail;
31016 }
31017 {
31018 wxVideoMode * resultptr;
31019 resultptr = new wxVideoMode((wxVideoMode &)(result));
31020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31021 }
31022 return resultobj;
31023 fail:
31024 return NULL;
31025 }
31026
31027
31028 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31029 PyObject *resultobj;
31030 wxDisplay *arg1 = (wxDisplay *) 0 ;
31031 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31032 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31033 bool result;
31034 PyObject * obj0 = 0 ;
31035 PyObject * obj1 = 0 ;
31036 char *kwnames[] = {
31037 (char *) "self",(char *) "mode", NULL
31038 };
31039
31040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31042 if (SWIG_arg_fail(1)) SWIG_fail;
31043 if (obj1) {
31044 {
31045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31046 if (SWIG_arg_fail(2)) SWIG_fail;
31047 if (arg2 == NULL) {
31048 SWIG_null_ref("wxVideoMode");
31049 }
31050 if (SWIG_arg_fail(2)) SWIG_fail;
31051 }
31052 }
31053 {
31054 PyThreadState* __tstate = wxPyBeginAllowThreads();
31055 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31056
31057 wxPyEndAllowThreads(__tstate);
31058 if (PyErr_Occurred()) SWIG_fail;
31059 }
31060 {
31061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31062 }
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31070 PyObject *resultobj;
31071 wxDisplay *arg1 = (wxDisplay *) 0 ;
31072 PyObject * obj0 = 0 ;
31073 char *kwnames[] = {
31074 (char *) "self", NULL
31075 };
31076
31077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31079 if (SWIG_arg_fail(1)) SWIG_fail;
31080 {
31081 PyThreadState* __tstate = wxPyBeginAllowThreads();
31082 (arg1)->ResetMode();
31083
31084 wxPyEndAllowThreads(__tstate);
31085 if (PyErr_Occurred()) SWIG_fail;
31086 }
31087 Py_INCREF(Py_None); resultobj = Py_None;
31088 return resultobj;
31089 fail:
31090 return NULL;
31091 }
31092
31093
31094 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31095 PyObject *obj;
31096 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31097 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31098 Py_INCREF(obj);
31099 return Py_BuildValue((char *)"");
31100 }
31101 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31102 PyObject *resultobj;
31103 wxStandardPaths *result;
31104 char *kwnames[] = {
31105 NULL
31106 };
31107
31108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31109 {
31110 PyThreadState* __tstate = wxPyBeginAllowThreads();
31111 result = (wxStandardPaths *)StandardPaths_Get();
31112
31113 wxPyEndAllowThreads(__tstate);
31114 if (PyErr_Occurred()) SWIG_fail;
31115 }
31116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31117 return resultobj;
31118 fail:
31119 return NULL;
31120 }
31121
31122
31123 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31124 PyObject *resultobj;
31125 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31126 wxString result;
31127 PyObject * obj0 = 0 ;
31128 char *kwnames[] = {
31129 (char *) "self", NULL
31130 };
31131
31132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31134 if (SWIG_arg_fail(1)) SWIG_fail;
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31138
31139 wxPyEndAllowThreads(__tstate);
31140 if (PyErr_Occurred()) SWIG_fail;
31141 }
31142 {
31143 #if wxUSE_UNICODE
31144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31145 #else
31146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31147 #endif
31148 }
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj;
31157 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31158 wxString result;
31159 PyObject * obj0 = 0 ;
31160 char *kwnames[] = {
31161 (char *) "self", NULL
31162 };
31163
31164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31166 if (SWIG_arg_fail(1)) SWIG_fail;
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31170
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 {
31175 #if wxUSE_UNICODE
31176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31177 #else
31178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31179 #endif
31180 }
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31188 PyObject *resultobj;
31189 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31190 wxString result;
31191 PyObject * obj0 = 0 ;
31192 char *kwnames[] = {
31193 (char *) "self", NULL
31194 };
31195
31196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31198 if (SWIG_arg_fail(1)) SWIG_fail;
31199 {
31200 PyThreadState* __tstate = wxPyBeginAllowThreads();
31201 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31202
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 {
31207 #if wxUSE_UNICODE
31208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31209 #else
31210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31211 #endif
31212 }
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31220 PyObject *resultobj;
31221 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31222 wxString result;
31223 PyObject * obj0 = 0 ;
31224 char *kwnames[] = {
31225 (char *) "self", NULL
31226 };
31227
31228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31230 if (SWIG_arg_fail(1)) SWIG_fail;
31231 {
31232 PyThreadState* __tstate = wxPyBeginAllowThreads();
31233 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31234
31235 wxPyEndAllowThreads(__tstate);
31236 if (PyErr_Occurred()) SWIG_fail;
31237 }
31238 {
31239 #if wxUSE_UNICODE
31240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31241 #else
31242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31243 #endif
31244 }
31245 return resultobj;
31246 fail:
31247 return NULL;
31248 }
31249
31250
31251 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31252 PyObject *resultobj;
31253 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31254 wxString result;
31255 PyObject * obj0 = 0 ;
31256 char *kwnames[] = {
31257 (char *) "self", NULL
31258 };
31259
31260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31262 if (SWIG_arg_fail(1)) SWIG_fail;
31263 {
31264 PyThreadState* __tstate = wxPyBeginAllowThreads();
31265 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31266
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 {
31271 #if wxUSE_UNICODE
31272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31273 #else
31274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31275 #endif
31276 }
31277 return resultobj;
31278 fail:
31279 return NULL;
31280 }
31281
31282
31283 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31284 PyObject *resultobj;
31285 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31286 wxString result;
31287 PyObject * obj0 = 0 ;
31288 char *kwnames[] = {
31289 (char *) "self", NULL
31290 };
31291
31292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31294 if (SWIG_arg_fail(1)) SWIG_fail;
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31298
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 {
31303 #if wxUSE_UNICODE
31304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31305 #else
31306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31307 #endif
31308 }
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31316 PyObject *resultobj;
31317 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31318 wxString result;
31319 PyObject * obj0 = 0 ;
31320 char *kwnames[] = {
31321 (char *) "self", NULL
31322 };
31323
31324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31326 if (SWIG_arg_fail(1)) SWIG_fail;
31327 {
31328 PyThreadState* __tstate = wxPyBeginAllowThreads();
31329 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31330
31331 wxPyEndAllowThreads(__tstate);
31332 if (PyErr_Occurred()) SWIG_fail;
31333 }
31334 {
31335 #if wxUSE_UNICODE
31336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31337 #else
31338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31339 #endif
31340 }
31341 return resultobj;
31342 fail:
31343 return NULL;
31344 }
31345
31346
31347 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31348 PyObject *resultobj;
31349 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31350 wxString *arg2 = 0 ;
31351 bool temp2 = false ;
31352 PyObject * obj0 = 0 ;
31353 PyObject * obj1 = 0 ;
31354 char *kwnames[] = {
31355 (char *) "self",(char *) "prefix", NULL
31356 };
31357
31358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31360 if (SWIG_arg_fail(1)) SWIG_fail;
31361 {
31362 arg2 = wxString_in_helper(obj1);
31363 if (arg2 == NULL) SWIG_fail;
31364 temp2 = true;
31365 }
31366 {
31367 PyThreadState* __tstate = wxPyBeginAllowThreads();
31368 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31369
31370 wxPyEndAllowThreads(__tstate);
31371 if (PyErr_Occurred()) SWIG_fail;
31372 }
31373 Py_INCREF(Py_None); resultobj = Py_None;
31374 {
31375 if (temp2)
31376 delete arg2;
31377 }
31378 return resultobj;
31379 fail:
31380 {
31381 if (temp2)
31382 delete arg2;
31383 }
31384 return NULL;
31385 }
31386
31387
31388 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31389 PyObject *resultobj;
31390 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31391 wxString result;
31392 PyObject * obj0 = 0 ;
31393 char *kwnames[] = {
31394 (char *) "self", NULL
31395 };
31396
31397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31399 if (SWIG_arg_fail(1)) SWIG_fail;
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31403
31404 wxPyEndAllowThreads(__tstate);
31405 if (PyErr_Occurred()) SWIG_fail;
31406 }
31407 {
31408 #if wxUSE_UNICODE
31409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31410 #else
31411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31412 #endif
31413 }
31414 return resultobj;
31415 fail:
31416 return NULL;
31417 }
31418
31419
31420 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31421 PyObject *obj;
31422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31423 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31424 Py_INCREF(obj);
31425 return Py_BuildValue((char *)"");
31426 }
31427 static PyMethodDef SwigMethods[] = {
31428 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31435 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31443 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31507 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31515 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31533 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31536 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31539 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31542 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31548 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31562 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31568 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31574 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31577 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31591 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31594 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31595 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31598 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31625 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31627 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31629 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31631 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31638 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31644 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31658 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31662 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31665 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31682 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31690 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31737 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31755 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31765 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31781 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31797 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31811 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31821 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31864 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31867 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31870 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31874 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31967 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31968 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31969 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31970 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31987 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32032 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32066 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32074 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32075 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32080 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32089 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32096 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32099 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32102 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32107 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32110 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32114 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32117 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32121 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32122 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32126 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32130 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32132 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32142 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32155 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32163 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32171 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32185 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32189 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32207 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32221 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32232 { NULL, NULL, 0, NULL }
32233 };
32234
32235
32236 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32237
32238 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32239 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32240 }
32241 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32242 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32243 }
32244 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32245 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32246 }
32247 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32248 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32249 }
32250 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32251 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32252 }
32253 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32254 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32255 }
32256 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32257 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32258 }
32259 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32260 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32261 }
32262 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32263 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32264 }
32265 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32266 return (void *)((wxEvent *) ((wxPyEvent *) x));
32267 }
32268 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32269 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32270 }
32271 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32272 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32273 }
32274 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32275 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32276 }
32277 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32278 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32279 }
32280 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32281 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32282 }
32283 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32284 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32285 }
32286 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32287 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32288 }
32289 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32290 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32291 }
32292 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32293 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32294 }
32295 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32296 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32297 }
32298 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32299 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32300 }
32301 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32302 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32303 }
32304 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32305 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32306 }
32307 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32308 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32309 }
32310 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32311 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32312 }
32313 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32314 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32315 }
32316 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32317 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32318 }
32319 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32320 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32321 }
32322 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32323 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32324 }
32325 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32326 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32327 }
32328 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32329 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32330 }
32331 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32332 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32333 }
32334 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32335 return (void *)((wxEvent *) ((wxShowEvent *) x));
32336 }
32337 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32338 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32339 }
32340 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32341 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32342 }
32343 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32344 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32345 }
32346 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32347 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32348 }
32349 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32350 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32351 }
32352 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32353 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32354 }
32355 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32356 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32357 }
32358 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32359 return (void *)((wxConfigBase *) ((wxConfig *) x));
32360 }
32361 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32362 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32363 }
32364 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32365 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32366 }
32367 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32368 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32369 }
32370 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32371 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32372 }
32373 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32374 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32375 }
32376 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32377 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32378 }
32379 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32380 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32381 }
32382 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32383 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32384 }
32385 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32386 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32387 }
32388 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32389 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32390 }
32391 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32392 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32393 }
32394 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32395 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32396 }
32397 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32398 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32399 }
32400 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32401 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32402 }
32403 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32404 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32405 }
32406 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32407 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32408 }
32409 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32410 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32411 }
32412 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32413 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32414 }
32415 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32416 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32417 }
32418 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32419 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32420 }
32421 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32422 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32423 }
32424 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32425 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32426 }
32427 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32428 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32429 }
32430 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32431 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32432 }
32433 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32434 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32435 }
32436 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32437 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32438 }
32439 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32440 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32441 }
32442 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32443 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32444 }
32445 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32446 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32447 }
32448 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32449 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32450 }
32451 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32452 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32453 }
32454 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32455 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32456 }
32457 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32458 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32459 }
32460 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32461 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32462 }
32463 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32464 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32465 }
32466 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32467 return (void *)((wxObject *) ((wxSizerItem *) x));
32468 }
32469 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32470 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32471 }
32472 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32473 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32474 }
32475 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32476 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32477 }
32478 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32479 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32480 }
32481 static void *_p_wxSizerTo_p_wxObject(void *x) {
32482 return (void *)((wxObject *) ((wxSizer *) x));
32483 }
32484 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32485 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32486 }
32487 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32488 return (void *)((wxObject *) ((wxFileHistory *) x));
32489 }
32490 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32491 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32492 }
32493 static void *_p_wxEventTo_p_wxObject(void *x) {
32494 return (void *)((wxObject *) ((wxEvent *) x));
32495 }
32496 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32497 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32498 }
32499 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32500 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32501 }
32502 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32503 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32504 }
32505 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32506 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32507 }
32508 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32509 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32510 }
32511 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32512 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32513 }
32514 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32515 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32516 }
32517 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32518 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32519 }
32520 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32521 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32522 }
32523 static void *_p_wxControlTo_p_wxObject(void *x) {
32524 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32525 }
32526 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32527 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32528 }
32529 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32530 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32531 }
32532 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32533 return (void *)((wxObject *) ((wxFSFile *) x));
32534 }
32535 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32536 return (void *)((wxObject *) ((wxClipboard *) x));
32537 }
32538 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32539 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32540 }
32541 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32542 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32543 }
32544 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32545 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32546 }
32547 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32548 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32549 }
32550 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32551 return (void *)((wxObject *) ((wxToolTip *) x));
32552 }
32553 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32554 return (void *)((wxObject *) ((wxMenuItem *) x));
32555 }
32556 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32557 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32558 }
32559 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32560 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32561 }
32562 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32563 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32564 }
32565 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32566 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32567 }
32568 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32569 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32570 }
32571 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32572 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32573 }
32574 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32575 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32576 }
32577 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32578 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32579 }
32580 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32581 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32582 }
32583 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32584 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32585 }
32586 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32587 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32588 }
32589 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32590 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32591 }
32592 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32593 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32594 }
32595 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32596 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32597 }
32598 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32599 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32600 }
32601 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32602 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32603 }
32604 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32605 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32606 }
32607 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32608 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32609 }
32610 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32611 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32612 }
32613 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) ((wxImageHandler *) x));
32615 }
32616 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32617 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32618 }
32619 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32620 return (void *)((wxObject *) ((wxEvtHandler *) x));
32621 }
32622 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32623 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32624 }
32625 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32626 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32627 }
32628 static void *_p_wxImageTo_p_wxObject(void *x) {
32629 return (void *)((wxObject *) ((wxImage *) x));
32630 }
32631 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32632 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32633 }
32634 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32635 return (void *)((wxObject *) ((wxSystemOptions *) x));
32636 }
32637 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32638 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32639 }
32640 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32641 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32642 }
32643 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32644 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32645 }
32646 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32647 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32648 }
32649 static void *_p_wxWindowTo_p_wxObject(void *x) {
32650 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32651 }
32652 static void *_p_wxMenuTo_p_wxObject(void *x) {
32653 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32654 }
32655 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32656 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32657 }
32658 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32659 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32660 }
32661 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32662 return (void *)((wxObject *) ((wxFileSystem *) x));
32663 }
32664 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32665 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32666 }
32667 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32668 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32669 }
32670 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32671 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32672 }
32673 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32674 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32675 }
32676 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32677 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32678 }
32679 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32680 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32681 }
32682 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32683 return (void *)((wxObject *) ((wxBusyInfo *) x));
32684 }
32685 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32686 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32687 }
32688 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32689 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32690 }
32691 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32692 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32693 }
32694 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32695 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32696 }
32697 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32698 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32699 }
32700 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32701 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32702 }
32703 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32704 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32705 }
32706 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32707 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32708 }
32709 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32710 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32711 }
32712 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32713 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32714 }
32715 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32716 return (void *)((wxLog *) ((wxLogStderr *) x));
32717 }
32718 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32719 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32720 }
32721 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32722 return (void *)((wxLog *) ((wxLogWindow *) x));
32723 }
32724 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32725 return (void *)((wxLog *) ((wxLogChain *) x));
32726 }
32727 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32728 return (void *)((wxLog *) ((wxLogGui *) x));
32729 }
32730 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32731 return (void *)((wxLog *) ((wxPyLog *) x));
32732 }
32733 static void *_p_wxControlTo_p_wxWindow(void *x) {
32734 return (void *)((wxWindow *) ((wxControl *) x));
32735 }
32736 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32737 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32738 }
32739 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32740 return (void *)((wxWindow *) ((wxMenuBar *) x));
32741 }
32742 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32743 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32744 }
32745 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32746 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32747 }
32748 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}};
32749 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}};
32750 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}};
32751 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}};
32752 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}};
32753 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}};
32754 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}};
32755 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}};
32756 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}};
32757 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}};
32758 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}};
32759 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}};
32760 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}};
32761 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}};
32762 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}};
32763 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}};
32764 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}};
32765 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}};
32766 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}};
32767 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}};
32768 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}};
32769 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}};
32770 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}};
32771 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}};
32772 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}};
32773 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}};
32774 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}};
32775 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}};
32776 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}};
32777 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}};
32778 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}};
32779 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}};
32780 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}};
32781 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}};
32782 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}};
32783 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}};
32784 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}};
32785 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}};
32786 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}};
32787 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}};
32788 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}};
32789 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}};
32790 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}};
32791 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}};
32792 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}};
32793 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}};
32794 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}};
32795 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}};
32796 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}};
32797 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}};
32798 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}};
32799 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}};
32800 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}};
32801 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}};
32802 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}};
32803 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}};
32804 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}};
32805 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}};
32806 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}};
32807 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}};
32808 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}};
32809 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}};
32810 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}};
32811 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}};
32812 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}};
32813 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}};
32814 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}};
32815 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}};
32816 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}};
32817 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}};
32818 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}};
32819 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}};
32820 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}};
32821 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}};
32822 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}};
32823 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}};
32824 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}};
32825 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}};
32826 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}};
32827 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}};
32828 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}};
32829 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}};
32830 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}};
32831 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}};
32832 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}};
32833 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}};
32834 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}};
32835 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}};
32836 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}};
32837 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}};
32838 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}};
32839 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}};
32840 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}};
32841 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}};
32842 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}};
32843 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}};
32844
32845 static swig_type_info *swig_types_initial[] = {
32846 _swigt__p_wxLogChain,
32847 _swigt__p_wxMutexGuiLocker,
32848 _swigt__p_wxFileHistory,
32849 _swigt__p_wxLog,
32850 _swigt__p_wxMenu,
32851 _swigt__p_wxEvent,
32852 _swigt__p_wxDateTime__TimeZone,
32853 _swigt__p_wxConfigBase,
32854 _swigt__p_wxDisplay,
32855 _swigt__p_wxFileType,
32856 _swigt__p_wxLogGui,
32857 _swigt__p_wxFont,
32858 _swigt__p_wxDataFormat,
32859 _swigt__p_wxTimerEvent,
32860 _swigt__p_wxCaret,
32861 _swigt__ptrdiff_t,
32862 _swigt__std__ptrdiff_t,
32863 _swigt__p_int,
32864 _swigt__p_wxSize,
32865 _swigt__p_wxClipboard,
32866 _swigt__p_wxStopWatch,
32867 _swigt__p_wxDC,
32868 _swigt__p_wxClipboardLocker,
32869 _swigt__p_wxIcon,
32870 _swigt__p_wxLogStderr,
32871 _swigt__p_wxLogTextCtrl,
32872 _swigt__p_wxTextCtrl,
32873 _swigt__p_wxBusyCursor,
32874 _swigt__p_wxBitmapDataObject,
32875 _swigt__p_wxTextDataObject,
32876 _swigt__p_wxDataObject,
32877 _swigt__p_wxPyTextDataObject,
32878 _swigt__p_wxPyBitmapDataObject,
32879 _swigt__p_wxFileDataObject,
32880 _swigt__p_wxCustomDataObject,
32881 _swigt__p_wxURLDataObject,
32882 _swigt__p_wxMetafileDataObject,
32883 _swigt__p_wxSound,
32884 _swigt__p_wxTimerRunner,
32885 _swigt__p_wxLogWindow,
32886 _swigt__p_wxTimeSpan,
32887 _swigt__p_wxArrayString,
32888 _swigt__p_wxWindowDisabler,
32889 _swigt__p_form_ops_t,
32890 _swigt__p_wxToolTip,
32891 _swigt__p_wxDataObjectComposite,
32892 _swigt__p_wxSystemSettings,
32893 _swigt__p_wxFileConfig,
32894 _swigt__p_wxVideoMode,
32895 _swigt__p_wxDataObjectSimple,
32896 _swigt__p_wxPyDataObjectSimple,
32897 _swigt__p_wxDuplexMode,
32898 _swigt__p_wxEvtHandler,
32899 _swigt__p_wxRect,
32900 _swigt__p_char,
32901 _swigt__p_wxSingleInstanceChecker,
32902 _swigt__p_wxStandardPaths,
32903 _swigt__p_wxFileTypeInfo,
32904 _swigt__p_wxFrame,
32905 _swigt__p_wxTimer,
32906 _swigt__p_wxPaperSize,
32907 _swigt__p_wxMimeTypesManager,
32908 _swigt__p_wxPyArtProvider,
32909 _swigt__p_wxPyTipProvider,
32910 _swigt__p_wxTipProvider,
32911 _swigt__p_wxJoystick,
32912 _swigt__p_wxSystemOptions,
32913 _swigt__p_wxPoint,
32914 _swigt__p_wxJoystickEvent,
32915 _swigt__p_wxCursor,
32916 _swigt__p_wxObject,
32917 _swigt__p_wxOutputStream,
32918 _swigt__p_wxDateTime,
32919 _swigt__p_wxPyDropSource,
32920 _swigt__p_unsigned_long,
32921 _swigt__p_wxKillError,
32922 _swigt__p_wxWindow,
32923 _swigt__p_wxString,
32924 _swigt__p_wxPyProcess,
32925 _swigt__p_wxBitmap,
32926 _swigt__p_wxConfig,
32927 _swigt__unsigned_int,
32928 _swigt__p_unsigned_int,
32929 _swigt__p_unsigned_char,
32930 _swigt__p_wxChar,
32931 _swigt__p_wxBusyInfo,
32932 _swigt__p_wxPyDropTarget,
32933 _swigt__p_wxPyTextDropTarget,
32934 _swigt__p_wxPyFileDropTarget,
32935 _swigt__p_wxProcessEvent,
32936 _swigt__p_wxPyLog,
32937 _swigt__p_wxLogNull,
32938 _swigt__p_wxColour,
32939 _swigt__p_wxPyTimer,
32940 _swigt__p_wxConfigPathChanger,
32941 _swigt__p_wxDateSpan,
32942 0
32943 };
32944
32945
32946 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32947
32948 static swig_const_info swig_const_table[] = {
32949 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32950 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32951 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32952 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32953 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32954 {0, 0, 0, 0.0, 0, 0}};
32955
32956 #ifdef __cplusplus
32957 }
32958 #endif
32959
32960
32961 #ifdef __cplusplus
32962 extern "C" {
32963 #endif
32964
32965 /* Python-specific SWIG API */
32966 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32967 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32968 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32969
32970 /* -----------------------------------------------------------------------------
32971 * global variable support code.
32972 * ----------------------------------------------------------------------------- */
32973
32974 typedef struct swig_globalvar {
32975 char *name; /* Name of global variable */
32976 PyObject *(*get_attr)(); /* Return the current value */
32977 int (*set_attr)(PyObject *); /* Set the value */
32978 struct swig_globalvar *next;
32979 } swig_globalvar;
32980
32981 typedef struct swig_varlinkobject {
32982 PyObject_HEAD
32983 swig_globalvar *vars;
32984 } swig_varlinkobject;
32985
32986 static PyObject *
32987 swig_varlink_repr(swig_varlinkobject *v) {
32988 v = v;
32989 return PyString_FromString("<Swig global variables>");
32990 }
32991
32992 static int
32993 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32994 swig_globalvar *var;
32995 flags = flags;
32996 fprintf(fp,"Swig global variables { ");
32997 for (var = v->vars; var; var=var->next) {
32998 fprintf(fp,"%s", var->name);
32999 if (var->next) fprintf(fp,", ");
33000 }
33001 fprintf(fp," }\n");
33002 return 0;
33003 }
33004
33005 static PyObject *
33006 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33007 swig_globalvar *var = v->vars;
33008 while (var) {
33009 if (strcmp(var->name,n) == 0) {
33010 return (*var->get_attr)();
33011 }
33012 var = var->next;
33013 }
33014 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33015 return NULL;
33016 }
33017
33018 static int
33019 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33020 swig_globalvar *var = v->vars;
33021 while (var) {
33022 if (strcmp(var->name,n) == 0) {
33023 return (*var->set_attr)(p);
33024 }
33025 var = var->next;
33026 }
33027 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33028 return 1;
33029 }
33030
33031 static PyTypeObject varlinktype = {
33032 PyObject_HEAD_INIT(0)
33033 0, /* Number of items in variable part (ob_size) */
33034 (char *)"swigvarlink", /* Type name (tp_name) */
33035 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33036 0, /* Itemsize (tp_itemsize) */
33037 0, /* Deallocator (tp_dealloc) */
33038 (printfunc) swig_varlink_print, /* Print (tp_print) */
33039 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33040 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33041 0, /* tp_compare */
33042 (reprfunc) swig_varlink_repr, /* tp_repr */
33043 0, /* tp_as_number */
33044 0, /* tp_as_sequence */
33045 0, /* tp_as_mapping */
33046 0, /* tp_hash */
33047 0, /* tp_call */
33048 0, /* tp_str */
33049 0, /* tp_getattro */
33050 0, /* tp_setattro */
33051 0, /* tp_as_buffer */
33052 0, /* tp_flags */
33053 0, /* tp_doc */
33054 #if PY_VERSION_HEX >= 0x02000000
33055 0, /* tp_traverse */
33056 0, /* tp_clear */
33057 #endif
33058 #if PY_VERSION_HEX >= 0x02010000
33059 0, /* tp_richcompare */
33060 0, /* tp_weaklistoffset */
33061 #endif
33062 #if PY_VERSION_HEX >= 0x02020000
33063 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33064 #endif
33065 #if PY_VERSION_HEX >= 0x02030000
33066 0, /* tp_del */
33067 #endif
33068 #ifdef COUNT_ALLOCS
33069 0,0,0,0 /* tp_alloc -> tp_next */
33070 #endif
33071 };
33072
33073 /* Create a variable linking object for use later */
33074 static PyObject *
33075 SWIG_Python_newvarlink(void) {
33076 swig_varlinkobject *result = 0;
33077 result = PyMem_NEW(swig_varlinkobject,1);
33078 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33079 result->ob_type = &varlinktype;
33080 result->vars = 0;
33081 result->ob_refcnt = 0;
33082 Py_XINCREF((PyObject *) result);
33083 return ((PyObject*) result);
33084 }
33085
33086 static void
33087 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33088 swig_varlinkobject *v;
33089 swig_globalvar *gv;
33090 v= (swig_varlinkobject *) p;
33091 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33092 gv->name = (char *) malloc(strlen(name)+1);
33093 strcpy(gv->name,name);
33094 gv->get_attr = get_attr;
33095 gv->set_attr = set_attr;
33096 gv->next = v->vars;
33097 v->vars = gv;
33098 }
33099
33100 /* -----------------------------------------------------------------------------
33101 * constants/methods manipulation
33102 * ----------------------------------------------------------------------------- */
33103
33104 /* Install Constants */
33105 static void
33106 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33107 PyObject *obj = 0;
33108 size_t i;
33109 for (i = 0; constants[i].type; i++) {
33110 switch(constants[i].type) {
33111 case SWIG_PY_INT:
33112 obj = PyInt_FromLong(constants[i].lvalue);
33113 break;
33114 case SWIG_PY_FLOAT:
33115 obj = PyFloat_FromDouble(constants[i].dvalue);
33116 break;
33117 case SWIG_PY_STRING:
33118 if (constants[i].pvalue) {
33119 obj = PyString_FromString((char *) constants[i].pvalue);
33120 } else {
33121 Py_INCREF(Py_None);
33122 obj = Py_None;
33123 }
33124 break;
33125 case SWIG_PY_POINTER:
33126 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33127 break;
33128 case SWIG_PY_BINARY:
33129 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33130 break;
33131 default:
33132 obj = 0;
33133 break;
33134 }
33135 if (obj) {
33136 PyDict_SetItemString(d,constants[i].name,obj);
33137 Py_DECREF(obj);
33138 }
33139 }
33140 }
33141
33142 /* -----------------------------------------------------------------------------*/
33143 /* Fix SwigMethods to carry the callback ptrs when needed */
33144 /* -----------------------------------------------------------------------------*/
33145
33146 static void
33147 SWIG_Python_FixMethods(PyMethodDef *methods,
33148 swig_const_info *const_table,
33149 swig_type_info **types,
33150 swig_type_info **types_initial) {
33151 size_t i;
33152 for (i = 0; methods[i].ml_name; ++i) {
33153 char *c = methods[i].ml_doc;
33154 if (c && (c = strstr(c, "swig_ptr: "))) {
33155 int j;
33156 swig_const_info *ci = 0;
33157 char *name = c + 10;
33158 for (j = 0; const_table[j].type; j++) {
33159 if (strncmp(const_table[j].name, name,
33160 strlen(const_table[j].name)) == 0) {
33161 ci = &(const_table[j]);
33162 break;
33163 }
33164 }
33165 if (ci) {
33166 size_t shift = (ci->ptype) - types;
33167 swig_type_info *ty = types_initial[shift];
33168 size_t ldoc = (c - methods[i].ml_doc);
33169 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33170 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33171 char *buff = ndoc;
33172 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33173 strncpy(buff, methods[i].ml_doc, ldoc);
33174 buff += ldoc;
33175 strncpy(buff, "swig_ptr: ", 10);
33176 buff += 10;
33177 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33178 methods[i].ml_doc = ndoc;
33179 }
33180 }
33181 }
33182 }
33183
33184 /* -----------------------------------------------------------------------------*
33185 * Initialize type list
33186 * -----------------------------------------------------------------------------*/
33187
33188 #if PY_MAJOR_VERSION < 2
33189 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33190 is copied out of Python/modsupport.c in python version 2.3.4 */
33191 static int
33192 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33193 {
33194 PyObject *dict;
33195 if (!PyModule_Check(m)) {
33196 PyErr_SetString(PyExc_TypeError,
33197 "PyModule_AddObject() needs module as first arg");
33198 return -1;
33199 }
33200 if (!o) {
33201 PyErr_SetString(PyExc_TypeError,
33202 "PyModule_AddObject() needs non-NULL value");
33203 return -1;
33204 }
33205
33206 dict = PyModule_GetDict(m);
33207 if (dict == NULL) {
33208 /* Internal error -- modules must have a dict! */
33209 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33210 PyModule_GetName(m));
33211 return -1;
33212 }
33213 if (PyDict_SetItemString(dict, name, o))
33214 return -1;
33215 Py_DECREF(o);
33216 return 0;
33217 }
33218 #endif
33219
33220 static swig_type_info **
33221 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33222 static PyMethodDef swig_empty_runtime_method_table[] = {
33223 {
33224 NULL, NULL, 0, NULL
33225 }
33226 };/* Sentinel */
33227
33228 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33229 swig_empty_runtime_method_table);
33230 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33231 if (pointer && module) {
33232 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33233 }
33234 return type_list_handle;
33235 }
33236
33237 static swig_type_info **
33238 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33239 swig_type_info **type_pointer;
33240
33241 /* first check if module already created */
33242 type_pointer = SWIG_Python_GetTypeListHandle();
33243 if (type_pointer) {
33244 return type_pointer;
33245 } else {
33246 /* create a new module and variable */
33247 return SWIG_Python_SetTypeListHandle(type_list_handle);
33248 }
33249 }
33250
33251 #ifdef __cplusplus
33252 }
33253 #endif
33254
33255 /* -----------------------------------------------------------------------------*
33256 * Partial Init method
33257 * -----------------------------------------------------------------------------*/
33258
33259 #ifdef SWIG_LINK_RUNTIME
33260 #ifdef __cplusplus
33261 extern "C"
33262 #endif
33263 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33264 #endif
33265
33266 #ifdef __cplusplus
33267 extern "C"
33268 #endif
33269 SWIGEXPORT(void) SWIG_init(void) {
33270 static PyObject *SWIG_globals = 0;
33271 static int typeinit = 0;
33272 PyObject *m, *d;
33273 int i;
33274 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33275
33276 /* Fix SwigMethods to carry the callback ptrs when needed */
33277 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33278
33279 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33280 d = PyModule_GetDict(m);
33281
33282 if (!typeinit) {
33283 #ifdef SWIG_LINK_RUNTIME
33284 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33285 #else
33286 # ifndef SWIG_STATIC_RUNTIME
33287 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33288 # endif
33289 #endif
33290 for (i = 0; swig_types_initial[i]; i++) {
33291 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33292 }
33293 typeinit = 1;
33294 }
33295 SWIG_InstallConstants(d,swig_const_table);
33296
33297 {
33298 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33299 }
33300 {
33301 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33302 }
33303 {
33304 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33305 }
33306 {
33307 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33308 }
33309 {
33310 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33311 }
33312 {
33313 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33314 }
33315 {
33316 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33317 }
33318 {
33319 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33320 }
33321 {
33322 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33323 }
33324 {
33325 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33326 }
33327 {
33328 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33329 }
33330 {
33331 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33332 }
33333 {
33334 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33338 }
33339 {
33340 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33344 }
33345 {
33346 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33347 }
33348 {
33349 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33350 }
33351 {
33352 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33353 }
33354 {
33355 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33356 }
33357 {
33358 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33359 }
33360 {
33361 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33362 }
33363 {
33364 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33365 }
33366 {
33367 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33368 }
33369 {
33370 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33371 }
33372 {
33373 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33374 }
33375 {
33376 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33377 }
33378 {
33379 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33380 }
33381 {
33382 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33383 }
33384 {
33385 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33386 }
33387 {
33388 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33389 }
33390 {
33391 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33392 }
33393 {
33394 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33419 }
33420 {
33421 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33422 }
33423 {
33424 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33569 }
33570 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33571 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33572 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33573 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33574 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33575 {
33576 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33586 }
33587 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33588
33589 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33590
33591 {
33592 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33623 }
33624 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33625 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33626 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33627 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33628 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33629 {
33630 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33721 }
33722 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33723 {
33724 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33737 }
33738
33739 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33740
33741 {
33742 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33761 }
33762 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33763 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33764 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33765 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33766 {
33767 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33768 }
33769 {
33770 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33771 }
33772 {
33773 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33780 }
33781 {
33782 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33783 }
33784 {
33785 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33789 }
33790 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33791 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33792 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33793 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33794 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33795 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33796 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33797 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33798 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33799 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33800 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33801 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33802 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33803 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33804 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33805 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33806 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33807 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33808 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33809 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33810 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33811 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33812 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33813 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33814 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33815 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33816 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33817 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33818 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33819 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33820 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33821 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33822 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33823 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33824 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33825 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33826 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33827 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33828 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33829 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33830 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33831 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33832 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33833 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33834 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33835 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33836 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33837 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33838 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33839 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33840 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33841 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33842 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33843 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33844 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33845 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33846
33847 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33848
33849 {
33850 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33875 }
33876 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33877 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33878 {
33879 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33895 }
33896 {
33897 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33898 }
33899 {
33900 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33901 }
33902 {
33903 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33937 }
33938 {
33939 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33946 }
33947 {
33948 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33949 }
33950 {
33951 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33994 }
33995 {
33996 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33997 }
33998 {
33999 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34132 }
34133 {
34134 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34135 }
34136 {
34137 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34138 }
34139 {
34140 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34141 }
34142 {
34143 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34144 }
34145 {
34146 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34147 }
34148 {
34149 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34150 }
34151 {
34152 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34153 }
34154 {
34155 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34156 }
34157 {
34158 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34159 }
34160 {
34161 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34162 }
34163 {
34164 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34165 }
34166 {
34167 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34168 }
34169 {
34170 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34171 }
34172 {
34173 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34174 }
34175 {
34176 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34177 }
34178 {
34179 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34180 }
34181 {
34182 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34183 }
34184 {
34185 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34186 }
34187 {
34188 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34189 }
34190 {
34191 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34192 }
34193 {
34194 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34195 }
34196 {
34197 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34231 }
34232 {
34233 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34234 }
34235 {
34236 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34237 }
34238 {
34239 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34246 }
34247 {
34248 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34249 }
34250 {
34251 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34252 }
34253 {
34254 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34255 }
34256 {
34257 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34258 }
34259 {
34260 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34261 }
34262 {
34263 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34264 }
34265 {
34266 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34267 }
34268 {
34269 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34297 }
34298 {
34299 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34303 }
34304 {
34305 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34306 }
34307 {
34308 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34309 }
34310 {
34311 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34312 }
34313 {
34314 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34315 }
34316 {
34317 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34318 }
34319 {
34320 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34321 }
34322 {
34323 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34324 }
34325 {
34326 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34327 }
34328 {
34329 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34330 }
34331 {
34332 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34333 }
34334 {
34335 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34336 }
34337 {
34338 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34339 }
34340 {
34341 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34342 }
34343 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34344 {
34345 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34394 }
34395 {
34396 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34397 }
34398 {
34399 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34400 }
34401 {
34402 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34403 }
34404 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34405 {
34406 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34407 }
34408 {
34409 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34410 }
34411 {
34412 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34413 }
34414 {
34415 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34416 }
34417 {
34418 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34419 }
34420 {
34421 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34422 }
34423 {
34424 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34425 }
34426 {
34427 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34428 }
34429 {
34430 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34431 }
34432 {
34433 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34434 }
34435 {
34436 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34437 }
34438 {
34439 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34440 }
34441
34442 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34443 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34444 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34445 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34446
34447 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34448 }
34449
wxWidgets (Impactor)